add Dojo 1.1.1

[eow] / static / dojo-release-1.1.1 / dojo / _base / _loader / loader.js

if(!dojo._hasResource["dojo.foo"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo.foo"] = true;
/*
 * loader.js - A bootstrap module.  Runs before the hostenv_*.js file. Contains
 * all of the package loading methods.
 */

(function(){
        var d = dojo;

        d.mixin(d, {
                _loadedModules: {},
                _inFlightCount: 0,
                _hasResource: {},

                _modulePrefixes: {
                        dojo:   {       name: "dojo", value: "." },
                        // dojox:       {       name: "dojox", value: "../dojox" },
                        // dijit:       {       name: "dijit", value: "../dijit" },
                        doh:    {       name: "doh", value: "../util/doh" },
                        tests:  {       name: "tests", value: "tests" }
                },

                _moduleHasPrefix: function(/*String*/module){
                        // summary: checks to see if module has been established
                        var mp = this._modulePrefixes;
                        return !!(mp[module] && mp[module].value); // Boolean
                },

                _getModulePrefix: function(/*String*/module){
                        // summary: gets the prefix associated with module
                        var mp = this._modulePrefixes;
                        if(this._moduleHasPrefix(module)){
                                return mp[module].value; // String
                        }
                        return module; // String
                },

                _loadedUrls: [],

                //WARNING: 
                //              This variable is referenced by packages outside of bootstrap:
                //              FloatingPane.js and undo/browser.js
                _postLoad: false,
                
                //Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
                _loaders: [],
                _unloaders: [],
                _loadNotifying: false
        });


                dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
                //      summary:
                //              Load a Javascript module given a relative path
                //
                //      description:
                //              Loads and interprets the script located at relpath, which is
                //              relative to the script root directory.  If the script is found but
                //              its interpretation causes a runtime exception, that exception is
                //              not caught by us, so the caller will see it.  We return a true
                //              value if and only if the script is found.
                //
                // relpath: 
                //              A relative path to a script (no leading '/', and typically ending
                //              in '.js').
                // module: 
                //              A module whose existance to check for after loading a path.  Can be
                //              used to determine success or failure of the load.
                // cb: 
                //              a callback function to pass the result of evaluating the script

                var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : this.baseUrl) + relpath;
                try{
                        return !module ? this._loadUri(uri, cb) : this._loadUriAndCheck(uri, module, cb); // Boolean
                }catch(e){
                        console.error(e);
                        return false; // Boolean
                }
        }

        dojo._loadUri = function(/*String*/uri, /*Function?*/cb){
                //      summary:
                //              Loads JavaScript from a URI
                //      description:
                //              Reads the contents of the URI, and evaluates the contents.  This is
                //              used to load modules as well as resource bundles. Returns true if
                //              it succeeded. Returns false if the URI reading failed.  Throws if
                //              the evaluation throws.
                //      uri: a uri which points at the script to be loaded
                //      cb: 
                //              a callback function to process the result of evaluating the script
                //              as an expression, typically used by the resource bundle loader to
                //              load JSON-style resources

                if(this._loadedUrls[uri]){
                        return true; // Boolean
                }
                var contents = this._getText(uri, true);
                if(!contents){ return false; } // Boolean
                this._loadedUrls[uri] = true;
                this._loadedUrls.push(uri);
                if(cb){
                        contents = '('+contents+')';
                }else{
                        //Only do the scoping if no callback. If a callback is specified,
                        //it is most likely the i18n bundle stuff.
                        contents = this._scopePrefix + contents + this._scopeSuffix;
                }
                if(d.isMoz){ contents += "\r\n//@ sourceURL=" + uri; } // debugging assist for Firebug
                var value = d["eval"](contents);
                if(cb){ cb(value); }
                return true; // Boolean
        }
        
        // FIXME: probably need to add logging to this method
        dojo._loadUriAndCheck = function(/*String*/uri, /*String*/moduleName, /*Function?*/cb){
                // summary: calls loadUri then findModule and returns true if both succeed
                var ok = false;
                try{
                        ok = this._loadUri(uri, cb);
                }catch(e){
                        console.error("failed loading " + uri + " with error: " + e);
                }
                return !!(ok && this._loadedModules[moduleName]); // Boolean
        }

        dojo.loaded = function(){
                // summary:
                //              signal fired when initial environment and package loading is
                //              complete. You may use dojo.addOnLoad() or dojo.connect() to
                //              this method in order to handle initialization tasks that
                //              require the environment to be initialized. In a browser host,
                //              declarative widgets will be constructed when this function
                //              finishes runing.
                this._loadNotifying = true;
                this._postLoad = true;
                var mll = d._loaders;
                
                //Clear listeners so new ones can be added
                //For other xdomain package loads after the initial load.
                this._loaders = [];

                for(var x = 0; x < mll.length; x++){
                        try{
                                mll[x]();
                        }catch(e){
                                throw e;
                                console.error("dojo.addOnLoad callback failed: " + e, e); /* let other load events fire, like the parser, but report the error */
                        }
                }

                this._loadNotifying = false;
                
                //Make sure nothing else got added to the onload queue
                //after this first run. If something did, and we are not waiting for any
                //more inflight resources, run again.
                if(d._postLoad && d._inFlightCount == 0 && mll.length){
                        d._callLoaded();
                }
        }

        dojo.unloaded = function(){
                // summary:
                //              signal fired by impending environment destruction. You may use
                //              dojo.addOnUnload() or dojo.connect() to this method to perform
                //              page/application cleanup methods.
                var mll = this._unloaders;
                while(mll.length){
                        (mll.pop())();
                }
        }

        var onto = function(arr, obj, fn){
                if(!fn){
                        arr.push(obj);
                }else if(fn){
                        var func = (typeof fn == "string") ? obj[fn] : fn;
                        arr.push(function(){ func.call(obj); });
                }
        }

        dojo.addOnLoad = function(/*Object?*/obj, /*String|Function*/functionName){
                // summary:
                //              Registers a function to be triggered after the DOM has finished
                //              loading and widgets declared in markup have been instantiated.
                //              Images and CSS files may or may not have finished downloading when
                //              the specified function is called.  (Note that widgets' CSS and HTML
                //              code is guaranteed to be downloaded before said widgets are
                //              instantiated.)
                // example:
                //      |       dojo.addOnLoad(functionPointer);
                //      |       dojo.addOnLoad(object, "functionName");
                //      |       dojo.addOnLoad(object, function(){ /* ... */});

                onto(d._loaders, obj, functionName);

                //Added for xdomain loading. dojo.addOnLoad is used to
                //indicate callbacks after doing some dojo.require() statements.
                //In the xdomain case, if all the requires are loaded (after initial
                //page load), then immediately call any listeners.
                if(d._postLoad && d._inFlightCount == 0 && !d._loadNotifying){
                        d._callLoaded();
                }
        }

        dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
                // summary:
                //              registers a function to be triggered when the page unloads
                // example:
                //      |       dojo.addOnUnload(functionPointer)
                //      |       dojo.addOnUnload(object, "functionName")
                //      |       dojo.addOnUnload(object, function(){ /* ... */});

                onto(d._unloaders, obj, functionName);
        }

        dojo._modulesLoaded = function(){
                if(d._postLoad){ return; }
                if(d._inFlightCount > 0){ 
                        console.warn("files still in flight!");
                        return;
                }
                d._callLoaded();
        }

        dojo._callLoaded = function(){

                // The "object" check is for IE, and the other opera check fixes an
                // issue in Opera where it could not find the body element in some
                // widget test cases.  For 0.9, maybe route all browsers through the
                // setTimeout (need protection still for non-browser environments
                // though). This might also help the issue with FF 2.0 and freezing
                // issues where we try to do sync xhr while background css images are
                // being loaded (trac #2572)? Consider for 0.9.
                if(typeof setTimeout == "object" || (dojo.config.useXDomain && d.isOpera)){
                        if(dojo.isAIR){
                                setTimeout(function(){dojo.loaded();}, 0);
                        }else{
                                setTimeout(dojo._scopeName + ".loaded();", 0);
                        }
                }else{
                        d.loaded();
                }
        }

        dojo._getModuleSymbols = function(/*String*/modulename){
                // summary:
                //              Converts a module name in dotted JS notation to an array
                //              representing the path in the source tree
                var syms = modulename.split(".");
                for(var i = syms.length; i>0; i--){
                        var parentModule = syms.slice(0, i).join(".");
                        if((i==1) && !this._moduleHasPrefix(parentModule)){             
                                // Support default module directory (sibling of dojo) for top-level modules 
                                syms[0] = "../" + syms[0];
                        }else{
                                var parentModulePath = this._getModulePrefix(parentModule);
                                if(parentModulePath != parentModule){
                                        syms.splice(0, i, parentModulePath);
                                        break;
                                }
                        }
                }
                // console.debug(syms);
                return syms; // Array
        }

        dojo._global_omit_module_check = false;

        dojo._loadModule = dojo.require = function(/*String*/moduleName, /*Boolean?*/omitModuleCheck){
                //      summary:
                //              loads a Javascript module from the appropriate URI
                //      moduleName:
                //              module name to load. Module paths are de-referenced by dojo's
                //              internal mapping of locations to names and are disambiguated by
                //              longest prefix. See `dojo.registerModulePath()` for details on
                //              registering new modules.
                //      omitModuleCheck:
                //              if `true`, omitModuleCheck skips the step of ensuring that the
                //              loaded file actually defines the symbol it is referenced by.
                //              For example if it called as `dojo._loadModule("a.b.c")` and the
                //              file located at `a/b/c.js` does not define an object `a.b.c`,
                //              and exception will be throws whereas no exception is raised
                //              when called as `dojo._loadModule("a.b.c", true)`
                //      description:
                //              `dojo._loadModule("A.B")` first checks to see if symbol A.B is
                //              defined. If it is, it is simply returned (nothing to do).
                //      
                //              If it is not defined, it will look for `A/B.js` in the script root
                //              directory.
                //      
                //              `dojo._loadModule` throws an excpetion if it cannot find a file
                //              to load, or if the symbol `A.B` is not defined after loading.
                //      
                //              It returns the object `A.B`.
                //      
                //              `dojo._loadModule()` does nothing about importing symbols into
                //              the current namespace.  It is presumed that the caller will
                //              take care of that. For example, to import all symbols into a
                //              local block, you might write:
                //      
                //              |       with (dojo._loadModule("A.B")) {
                //              |               ...
                //              |       }
                //      
                //              And to import just the leaf symbol to a local variable:
                //      
                //              |       var B = dojo._loadModule("A.B");
                //              |       ...
                //      returns: the required namespace object
                omitModuleCheck = this._global_omit_module_check || omitModuleCheck;

                //Check if it is already loaded.
                var module = this._loadedModules[moduleName];
                if(module){
                        return module;
                }

                // convert periods to slashes
                var relpath = this._getModuleSymbols(moduleName).join("/") + '.js';

                var modArg = (!omitModuleCheck) ? moduleName : null;
                var ok = this._loadPath(relpath, modArg);

                if(!ok && !omitModuleCheck){
                        throw new Error("Could not load '" + moduleName + "'; last tried '" + relpath + "'");
                }

                // check that the symbol was defined
                // Don't bother if we're doing xdomain (asynchronous) loading.
                if(!omitModuleCheck && !this._isXDomain){
                        // pass in false so we can give better error
                        module = this._loadedModules[moduleName];
                        if(!module){
                                throw new Error("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'"); 
                        }
                }

                return module;
        }

        dojo.provide = function(/*String*/ resourceName){
                //      summary:
                //              Each javascript source file must have at least one
                //              `dojo.provide()` call at the top of the file, corresponding to
                //              the file name.  For example, `js/dojo/foo.js` must have
                //              `dojo.provide("dojo.foo");` before any calls to
                //              `dojo.require()` are made.
                //      description:
                //              Each javascript source file is called a resource.  When a
                //              resource is loaded by the browser, `dojo.provide()` registers
                //              that it has been loaded.
                //      
                //              For backwards compatibility reasons, in addition to registering
                //              the resource, `dojo.provide()` also ensures that the javascript
                //              object for the module exists.  For example,
                //              `dojo.provide("dojox.data.FlickrStore")`, in addition to
                //              registering that `FlickrStore.js` is a resource for the
                //              `dojox.data` module, will ensure that the `dojox.data`
                //              javascript object exists, so that calls like 
                //              `dojo.data.foo = function(){ ... }` don't fail.
                //
                //              In the case of a build where multiple javascript source files
                //              are combined into one bigger file (similar to a .lib or .jar
                //              file), that file may contain multiple dojo.provide() calls, to
                //              note that it includes multiple resources.

                //Make sure we have a string.
                resourceName = resourceName + "";
                return (d._loadedModules[resourceName] = d.getObject(resourceName, true)); // Object
        }

        //Start of old bootstrap2:

        dojo.platformRequire = function(/*Object*/modMap){
                //      summary:
                //              require one or more modules based on which host environment
                //              Dojo is currently operating in
                //      description:
                //              This method takes a "map" of arrays which one can use to
                //              optionally load dojo modules. The map is indexed by the
                //              possible dojo.name_ values, with two additional values:
                //              "default" and "common". The items in the "default" array will
                //              be loaded if none of the other items have been choosen based on
                //              dojo.name_, set by your host environment. The items in the
                //              "common" array will *always* be loaded, regardless of which
                //              list is chosen.
                //      example:
                //              |       dojo.platformRequire({
                //              |               browser: [
                //              |                       "foo.sample", // simple module
                //              |                       "foo.test",
                //              |                       ["foo.bar.baz", true] // skip object check in _loadModule
                //              |               ],
                //              |               default: [ "foo.sample._base" ],
                //              |               common: [ "important.module.common" ]
                //              |       });

                var common = modMap.common || [];
                var result = common.concat(modMap[d._name] || modMap["default"] || []);

                for(var x=0; x<result.length; x++){
                        var curr = result[x];
                        if(curr.constructor == Array){
                                d._loadModule.apply(d, curr);
                        }else{
                                d._loadModule(curr);
                        }
                }
        }

        dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
                // summary:
                //              If the condition is true then call dojo.require() for the specified
                //              resource
                if(condition === true){
                        // FIXME: why do we support chained require()'s here? does the build system?
                        var args = [];
                        for(var i = 1; i < arguments.length; i++){ 
                                args.push(arguments[i]);
                        }
                        d.require.apply(d, args);
                }
        }

        dojo.requireAfterIf = d.requireIf;

        dojo.registerModulePath = function(/*String*/module, /*String*/prefix){
                //      summary: 
                //              maps a module name to a path
                //      description: 
                //              An unregistered module is given the default path of ../[module],
                //              relative to Dojo root. For example, module acme is mapped to
                //              ../acme.  If you want to use a different module name, use
                //              dojo.registerModulePath. 
                //      example:
                //              If your dojo.js is located at this location in the web root:
                //      |       /myapp/js/dojo/dojo/dojo.js
                //              and your modules are located at:
                //      |       /myapp/js/foo/bar.js
                //      |       /myapp/js/foo/baz.js
                //      |       /myapp/js/foo/thud/xyzzy.js
                //              Your application can tell Dojo to locate the "foo" namespace by calling:
                //      |       dojo.registerModulePath("foo", "../../foo");
                //              At which point you can then use dojo.require() to load the
                //              modules (assuming they provide() the same things which are
                //              required). The full code might be:
                //      |       <script type="text/javascript" 
                //      |               src="/myapp/js/dojo/dojo/dojo.js"></script>
                //      |       <script type="text/javascript">
                //      |               dojo.registerModulePath("foo", "../../foo");
                //      |               dojo.require("foo.bar");
                //      |               dojo.require("foo.baz");
                //      |               dojo.require("foo.thud.xyzzy");
                //      |       </script>
                d._modulePrefixes[module] = { name: module, value: prefix };
        }

        dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
                // summary:
                //              Declares translated resources and loads them if necessary, in the
                //              same style as dojo.require.  Contents of the resource bundle are
                //              typically strings, but may be any name/value pair, represented in
                //              JSON format.  See also dojo.i18n.getLocalization.
                // moduleName: 
                //              name of the package containing the "nls" directory in which the
                //              bundle is found
                // bundleName: 
                //              bundle name, i.e. the filename without the '.js' suffix
                // locale: 
                //              the locale to load (optional)  By default, the browser's user
                //              locale as defined by dojo.locale
                // availableFlatLocales: 
                //              A comma-separated list of the available, flattened locales for this
                //              bundle. This argument should only be set by the build process.
                // description:
                //              Load translated resource bundles provided underneath the "nls"
                //              directory within a package.  Translated resources may be located in
                //              different packages throughout the source tree.  For example, a
                //              particular widget may define one or more resource bundles,
                //              structured in a program as follows, where moduleName is
                //              mycode.mywidget and bundleNames available include bundleone and
                //              bundletwo:
                //
                //      |               ...
                //      |               mycode/
                //      |                mywidget/
                //      |                 nls/
                //      |                  bundleone.js (the fallback translation, English in this example)
                //      |                  bundletwo.js (also a fallback translation)
                //      |                  de/
                //      |                   bundleone.js
                //      |                   bundletwo.js
                //      |                  de-at/
                //      |                   bundleone.js
                //      |                  en/
                //      |                   (empty; use the fallback translation)
                //      |                  en-us/
                //      |                   bundleone.js
                //      |                  en-gb/
                //      |                   bundleone.js
                //      |                  es/
                //      |                   bundleone.js
                //      |                   bundletwo.js
                //      |                 ...etc
                //      |               ...
                //
                //              Each directory is named for a locale as specified by RFC 3066,
                //              (http://www.ietf.org/rfc/rfc3066.txt), normalized in lowercase.
                //              Note that the two bundles in the example do not define all the
                //              same variants.  For a given locale, bundles will be loaded for
                //              that locale and all more general locales above it, including a
                //              fallback at the root directory.  For example, a declaration for
                //              the "de-at" locale will first load `nls/de-at/bundleone.js`,
                //              then `nls/de/bundleone.js` and finally `nls/bundleone.js`.  The
                //              data will be flattened into a single Object so that lookups
                //              will follow this cascading pattern.  An optional build step can
                //              preload the bundles to avoid data redundancy and the multiple
                //              network hits normally required to load these resources.

                d.require("dojo.i18n");
                d.i18n._requireLocalization.apply(d.hostenv, arguments);
        };


        var ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$");
        var ire = new RegExp("^((([^:]+:)?([^@]+))@)?([^:]*)(:([0-9]+))?$");

        dojo._Url = function(/*dojo._Url||String...*/){
                // summary: 
                //              Constructor to create an object representing a URL.
                //              It is marked as private, since we might consider removing
                //              or simplifying it.
                // description: 
                //              Each argument is evaluated in order relative to the next until
                //              a canonical uri is produced. To get an absolute Uri relative to
                //              the current document use:
                //              new dojo._Url(document.baseURI, url)

                var n = null;

                // TODO: support for IPv6, see RFC 2732
                var _a = arguments;
                var uri = [_a[0]];
                // resolve uri components relative to each other
                for(var i = 1; i<_a.length; i++){
                        if(!_a[i]){ continue; }

                        // Safari doesn't support this.constructor so we have to be explicit
                        // FIXME: Tracked (and fixed) in Webkit bug 3537.
                        //              http://bugs.webkit.org/show_bug.cgi?id=3537
                        var relobj = new d._Url(_a[i]+"");
                        var uriobj = new d._Url(uri[0]+"");

                        if(
                                relobj.path == "" &&
                                !relobj.scheme &&
                                !relobj.authority &&
                                !relobj.query
                        ){
                                if(relobj.fragment != n){
                                        uriobj.fragment = relobj.fragment;
                                }
                                relobj = uriobj;
                        }else if(!relobj.scheme){
                                relobj.scheme = uriobj.scheme;

                                if(!relobj.authority){
                                        relobj.authority = uriobj.authority;

                                        if(relobj.path.charAt(0) != "/"){
                                                var path = uriobj.path.substring(0,
                                                        uriobj.path.lastIndexOf("/") + 1) + relobj.path;

                                                var segs = path.split("/");
                                                for(var j = 0; j < segs.length; j++){
                                                        if(segs[j] == "."){
                                                                // flatten "./" references
                                                                if(j == segs.length - 1){
                                                                        segs[j] = "";
                                                                }else{
                                                                        segs.splice(j, 1);
                                                                        j--;
                                                                }
                                                        }else if(j > 0 && !(j == 1 && segs[0] == "") &&
                                                                segs[j] == ".." && segs[j-1] != ".."){
                                                                // flatten "../" references
                                                                if(j == (segs.length - 1)){
                                                                        segs.splice(j, 1);
                                                                        segs[j - 1] = "";
                                                                }else{
                                                                        segs.splice(j - 1, 2);
                                                                        j -= 2;
                                                                }
                                                        }
                                                }
                                                relobj.path = segs.join("/");
                                        }
                                }
                        }

                        uri = [];
                        if(relobj.scheme){ 
                                uri.push(relobj.scheme, ":");
                        }
                        if(relobj.authority){
                                uri.push("//", relobj.authority);
                        }
                        uri.push(relobj.path);
                        if(relobj.query){
                                uri.push("?", relobj.query);
                        }
                        if(relobj.fragment){
                                uri.push("#", relobj.fragment);
                        }
                }

                this.uri = uri.join("");

                // break the uri into its main components
                var r = this.uri.match(ore);

                this.scheme = r[2] || (r[1] ? "" : n);
                this.authority = r[4] || (r[3] ? "" : n);
                this.path = r[5]; // can never be undefined
                this.query = r[7] || (r[6] ? "" : n);
                this.fragment  = r[9] || (r[8] ? "" : n);

                if(this.authority != n){
                        // server based naming authority
                        r = this.authority.match(ire);

                        this.user = r[3] || n;
                        this.password = r[4] || n;
                        this.host = r[5];
                        this.port = r[7] || n;
                }
        }

        dojo._Url.prototype.toString = function(){ return this.uri; };

        dojo.moduleUrl = function(/*String*/module, /*dojo._Url||String*/url){
                //      summary: 
                //              Returns a `dojo._Url` object relative to a module.
                //      example:
                //      |       var pngPath = dojo.moduleUrl("acme","images/small.png");
                //      |       console.dir(pngPath); // list the object properties
                //      |       // create an image and set it's source to pngPath's value:
                //      |       var img = document.createElement("img");
                //      |       // NOTE: we assign the string representation of the url object
                //      |       img.src = pngPath.toString(); 
                //      |       // add our image to the document
                //      |       dojo.body().appendChild(img);
                //      example: 
                //              you may de-reference as far as you like down the package
                //              hierarchy.  This is sometimes handy to avoid lenghty relative
                //              urls or for building portable sub-packages. In this example,
                //              the `acme.widget` and `acme.util` directories may be located
                //              under different roots (see `dojo.registerModulePath`) but the
                //              the modules which reference them can be unaware of their
                //              relative locations on the filesystem:
                //      |       // somewhere in a configuration block
                //      |       dojo.registerModulePath("acme.widget", "../../acme/widget");
                //      |       dojo.registerModulePath("acme.util", "../../util");
                //      |       
                //      |       // ...
                //      |       
                //      |       // code in a module using acme resources
                //      |       var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
                //      |       var dataPath = dojo.moduleUrl("acme.util","resources/data.json");

                var loc = d._getModuleSymbols(module).join('/');
                if(!loc){ return null; }
                if(loc.lastIndexOf("/") != loc.length-1){
                        loc += "/";
                }
                
                //If the path is an absolute path (starts with a / or is on another
                //domain/xdomain) then don't add the baseUrl.
                var colonIndex = loc.indexOf(":");
                if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > loc.indexOf("/"))){
                        loc = d.baseUrl + loc;
                }

                return new d._Url(loc, url); // String
        }
})();

}