Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo.parser"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo.parser"] = true;
dojo.provide("dojo.parser");
dojo.require("dojo.date.stamp");

dojo.parser = new function(){

        var d = dojo;

        function val2type(/*Object*/ value){
                // summary:
                //              Returns name of type of given value.

                if(d.isString(value)){ return "string"; }
                if(typeof value == "number"){ return "number"; }
                if(typeof value == "boolean"){ return "boolean"; }
                if(d.isFunction(value)){ return "function"; }
                if(d.isArray(value)){ return "array"; } // typeof [] == "object"
                if(value instanceof Date) { return "date"; } // assume timestamp
                if(value instanceof d._Url){ return "url"; }
                return "object";
        }

        function str2obj(/*String*/ value, /*String*/ type){
                // summary:
                //              Convert given string value to given type
                switch(type){
                        case "string":
                                return value;
                        case "number":
                                return value.length ? Number(value) : NaN;
                        case "boolean":
                                // for checked/disabled value might be "" or "checked".  interpret as true.
                                return typeof value == "boolean" ? value : !(value.toLowerCase()=="false");
                        case "function":
                                if(d.isFunction(value)){
                                        // IE gives us a function, even when we say something like onClick="foo"
                                        // (in which case it gives us an invalid function "function(){ foo }"). 
                                        //  Therefore, convert to string
                                        value=value.toString();
                                        value=d.trim(value.substring(value.indexOf('{')+1, value.length-1));
                                }
                                try{
                                        if(value.search(/[^\w\.]+/i) != -1){
                                                // TODO: "this" here won't work
                                                value = d.parser._nameAnonFunc(new Function(value), this);
                                        }
                                        return d.getObject(value, false);
                                }catch(e){ return new Function(); }
                        case "array":
                                return value.split(/\s*,\s*/);
                        case "date":
                                switch(value){
                                        case "": return new Date("");   // the NaN of dates
                                        case "now": return new Date();  // current date
                                        default: return d.date.stamp.fromISOString(value);
                                }
                        case "url":
                                return d.baseUrl + value;
                        default:
                                return d.fromJson(value);
                }
        }

        var instanceClasses = {
                // map from fully qualified name (like "dijit.Button") to structure like
                // { cls: dijit.Button, params: {label: "string", disabled: "boolean"} }
        };
        
        function getClassInfo(/*String*/ className){
                // className:
                //              fully qualified name (like "dijit.Button")
                // returns:
                //              structure like
                //                      { 
                //                              cls: dijit.Button, 
                //                              params: { label: "string", disabled: "boolean"}
                //                      }

                if(!instanceClasses[className]){
                        // get pointer to widget class
                        var cls = d.getObject(className);
                        if(!d.isFunction(cls)){
                                throw new Error("Could not load class '" + className +
                                        "'. Did you spell the name correctly and use a full path, like 'dijit.form.Button'?");
                        }
                        var proto = cls.prototype;
        
                        // get table of parameter names & types
                        var params={};
                        for(var name in proto){
                                if(name.charAt(0)=="_"){ continue; }    // skip internal properties
                                var defVal = proto[name];
                                params[name]=val2type(defVal);
                        }

                        instanceClasses[className] = { cls: cls, params: params };
                }
                return instanceClasses[className];
        }

        this._functionFromScript = function(script){
                var preamble = "";
                var suffix = "";
                var argsStr = script.getAttribute("args");
                if(argsStr){
                        d.forEach(argsStr.split(/\s*,\s*/), function(part, idx){
                                preamble += "var "+part+" = arguments["+idx+"]; ";
                        });
                }
                var withStr = script.getAttribute("with");
                if(withStr && withStr.length){
                        d.forEach(withStr.split(/\s*,\s*/), function(part){
                                preamble += "with("+part+"){";
                                suffix += "}";
                        });
                }
                return new Function(preamble+script.innerHTML+suffix);
        }

        this.instantiate = function(/* Array */nodes){
                // summary:
                //              Takes array of nodes, and turns them into class instances and
                //              potentially calls a layout method to allow them to connect with
                //              any children            
                var thelist = [];
                d.forEach(nodes, function(node){
                        if(!node){ return; }
                        var type = node.getAttribute("dojoType");
                        if((!type)||(!type.length)){ return; }
                        var clsInfo = getClassInfo(type);
                        var clazz = clsInfo.cls;
                        var ps = clazz._noScript||clazz.prototype._noScript;

                        // read parameters (ie, attributes).
                        // clsInfo.params lists expected params like {"checked": "boolean", "n": "number"}
                        var params = {};
                        var attributes = node.attributes;
                        for(var name in clsInfo.params){
                                var item = attributes.getNamedItem(name);
                                if(!item || (!item.specified && (!dojo.isIE || name.toLowerCase()!="value"))){ continue; }
                                var value = item.value;
                                // Deal with IE quirks for 'class' and 'style'
                                switch(name){
                                case "class":
                                        value = node.className;
                                        break;
                                case "style":
                                        value = node.style && node.style.cssText; // FIXME: Opera?
                                }
                                var _type = clsInfo.params[name];
                                params[name] = str2obj(value, _type);
                        }

                        // Process <script type="dojo/*"> script tags
                        // <script type="dojo/method" event="foo"> tags are added to params, and passed to
                        // the widget on instantiation.
                        // <script type="dojo/method"> tags (with no event) are executed after instantiation
                        // <script type="dojo/connect" event="foo"> tags are dojo.connected after instantiation
                        if(!ps){
                                var connects = [],      // functions to connect after instantiation
                                        calls = [];             // functions to call after instantiation

                                d.query("> script[type^='dojo/']", node).orphan().forEach(function(script){
                                        var event = script.getAttribute("event"),
                                                type = script.getAttribute("type"),
                                                nf = d.parser._functionFromScript(script);
                                        if(event){
                                                if(type == "dojo/connect"){
                                                        connects.push({event: event, func: nf});
                                                }else{
                                                        params[event] = nf;
                                                }
                                        }else{
                                                calls.push(nf);
                                        }
                                });
                        }

                        var markupFactory = clazz["markupFactory"];
                        if(!markupFactory && clazz["prototype"]){
                                markupFactory = clazz.prototype["markupFactory"];
                        }
                        // create the instance
                        var instance = markupFactory ? markupFactory(params, node, clazz) : new clazz(params, node);
                        thelist.push(instance);

                        // map it to the JS namespace if that makes sense
                        var jsname = node.getAttribute("jsId");
                        if(jsname){
                                d.setObject(jsname, instance);
                        }

                        // process connections and startup functions
                        if(!ps){
                                dojo.forEach(connects, function(connect){
                                        dojo.connect(instance, connect.event, null, connect.func);
                                });
                                dojo.forEach(calls, function(func){
                                        func.call(instance);
                                });
                        }
                });

                // Call startup on each top level instance if it makes sense (as for
                // widgets).  Parent widgets will recursively call startup on their
                // (non-top level) children
                d.forEach(thelist, function(instance){
                        if(     instance  && 
                                (instance.startup) && 
                                ((!instance.getParent) || (!instance.getParent()))
                        ){
                                instance.startup();
                        }
                });
                return thelist;
        };

        this.parse = function(/*DomNode?*/ rootNode){
                // summary:
                //              Search specified node (or root node) recursively for class instances,
                //              and instantiate them Searches for
                //              dojoType="qualified.class.name"
                var list = d.query('[dojoType]', rootNode);
                // go build the object instances
                var instances = this.instantiate(list);
                return instances;
        };
}();

//Register the parser callback. It should be the first callback
//after the a11y test.

(function(){
        var parseRunner = function(){ 
                if(djConfig["parseOnLoad"] == true){
                        dojo.parser.parse(); 
                }
        };

        // FIXME: need to clobber cross-dependency!!
        if(dojo.exists("dijit.wai.onload") && (dijit.wai.onload === dojo._loaders[0])){
                dojo._loaders.splice(1, 0, parseRunner);
        }else{
                dojo._loaders.unshift(parseRunner);
        }
})();

//TODO: ported from 0.4.x Dojo.  Can we reduce this?
dojo.parser._anonCtr = 0;
dojo.parser._anon = {}; // why is this property required?
dojo.parser._nameAnonFunc = function(/*Function*/anonFuncPtr, /*Object*/thisObj){
        // summary:
        //              Creates a reference to anonFuncPtr in thisObj with a completely
        //              unique name. The new name is returned as a String. 
        var jpn = "$joinpoint";
        var nso = (thisObj|| dojo.parser._anon);
        if(dojo.isIE){
                var cn = anonFuncPtr["__dojoNameCache"];
                if(cn && nso[cn] === anonFuncPtr){
                        return anonFuncPtr["__dojoNameCache"];
                }
        }
        var ret = "__"+dojo.parser._anonCtr++;
        while(typeof nso[ret] != "undefined"){
                ret = "__"+dojo.parser._anonCtr++;
        }
        nso[ret] = anonFuncPtr;
        return ret; // String
}

}