diff options
Diffstat (limited to 'includes/js/dojo/_base/_loader')
| -rw-r--r-- | includes/js/dojo/_base/_loader/bootstrap.js | 436 | ||||
| -rw-r--r-- | includes/js/dojo/_base/_loader/hostenv_browser.js | 379 | ||||
| -rw-r--r-- | includes/js/dojo/_base/_loader/hostenv_rhino.js | 238 | ||||
| -rw-r--r-- | includes/js/dojo/_base/_loader/hostenv_spidermonkey.js | 80 | ||||
| -rw-r--r-- | includes/js/dojo/_base/_loader/loader.js | 690 | ||||
| -rw-r--r-- | includes/js/dojo/_base/_loader/loader_debug.js | 61 | ||||
| -rw-r--r-- | includes/js/dojo/_base/_loader/loader_xd.js | 631 |
7 files changed, 2515 insertions, 0 deletions
diff --git a/includes/js/dojo/_base/_loader/bootstrap.js b/includes/js/dojo/_base/_loader/bootstrap.js new file mode 100644 index 0000000..c62ab6a --- /dev/null +++ b/includes/js/dojo/_base/_loader/bootstrap.js @@ -0,0 +1,436 @@ +/*===== +// note: +// 'djConfig' does not exist under 'dojo.*' so that it can be set before the +// 'dojo' variable exists. +// note: +// Setting any of these variables *after* the library has loaded does +// nothing at all. + +djConfig = { + // summary: + // Application code can set the global 'djConfig' prior to loading + // the library to override certain global settings for how dojo works. + // + // isDebug: Boolean + // Defaults to `false`. If set to `true`, ensures that Dojo provides + // extende debugging feedback via Firebug. If Firebug is not available + // on your platform, setting `isDebug` to `true` will force Dojo to + // pull in (and display) the version of Firebug Lite which is + // integrated into the Dojo distribution, thereby always providing a + // debugging/logging console when `isDebug` is enabled. Note that + // Firebug's `console.*` methods are ALWAYS defined by Dojo. If + // `isDebug` is false and you are on a platform without Firebug, these + // methods will be defined as no-ops. + isDebug: false, + // debugAtAllCosts: Boolean + // Defaults to `false`. If set to `true`, this triggers an alternate + // mode of the package system in which dependencies are detected and + // only then are resources evaluated in dependency order via + // `<script>` tag inclusion. This may double-request resources and + // cause problems with scripts which expect `dojo.require()` to + // preform synchronously. `debugAtAllCosts` can be an invaluable + // debugging aid, but when using it, ensure that all code which + // depends on Dojo modules is wrapped in `dojo.addOnLoad()` handlers. + // Due to the somewhat unpredictable side-effects of using + // `debugAtAllCosts`, it is strongly recommended that you enable this + // flag as a last resort. `debugAtAllCosts` has no effect when loading + // resources across domains. For usage information, see the + // [Dojo Book](http://dojotoolkit.org/book/book-dojo/part-4-meta-dojo-making-your-dojo-code-run-faster-and-better/debugging-facilities/deb) + debugAtAllCosts: false, + // locale: String + // The locale to assume for loading localized resources in this page, + // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt). + // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`. + // See the documentation for `dojo.i18n` and `dojo.requireLocalization` + // for details on loading localized resources. If no locale is specified, + // Dojo assumes the locale of the user agent, according to `navigator.userLanguage` + // or `navigator.language` properties. + locale: undefined, + // extraLocale: Array + // No default value. Specifies additional locales whose + // resources should also be loaded alongside the default locale when + // calls to `dojo.requireLocalization()` are processed. + extraLocale: undefined, + // baseUrl: String + // The directory in which `dojo.js` is located. Under normal + // conditions, Dojo auto-detects the correct location from which it + // was loaded. You may need to manually configure `baseUrl` in cases + // where you have renamed `dojo.js` or in which `<base>` tags confuse + // some browsers (e.g., IE 6). The variable `dojo.baseUrl` is assigned + // either the value of `djConfig.baseUrl` if one is provided or the + // auto-detected root if not. Other modules are located relative to + // this path. + baseUrl: undefined, + // modulePaths: Object + // A map of module names to paths relative to `dojo.baseUrl`. The + // key/value pairs correspond directly to the arguments which + // `dojo.registerModulePath` accepts. Specifiying + // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent + // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple + // modules may be configured via `djConfig.modulePaths`. + modulePaths: {}, +} +=====*/ + +(function(){ + // firebug stubs + + // if((!this["console"])||(!console["firebug"])){ + + if(!this["console"]){ + this.console = { + log: function(){} // no-op + }; + } + + var cn = [ + "assert", "count", "debug", "dir", "dirxml", "error", "group", + "groupEnd", "info", "profile", "profileEnd", "time", "timeEnd", + "trace", "warn", "log" + ]; + var i=0, tn; + while((tn=cn[i++])){ + if(!console[tn]){ + (function(){ + var tcn = tn+""; + console[tcn] = function(){ + var a = Array.apply({}, arguments); + a.unshift(tcn+":"); + console.log(a.join(" ")); + } + })(); + } + } + + //TODOC: HOW TO DOC THIS? + // dojo is the root variable of (almost all) our public symbols -- make sure it is defined. + if(typeof dojo == "undefined"){ + this.dojo = { + _scopeName: "dojo", + _scopePrefix: "", + _scopePrefixArgs: "", + _scopeSuffix: "", + _scopeMap: {}, + _scopeMapRev: {} + }; + } + + var d = dojo; + + //Need placeholders for dijit and dojox for scoping code. + if(typeof dijit == "undefined"){ + this.dijit = {_scopeName: "dijit"}; + } + if(typeof dojox == "undefined"){ + this.dojox = {_scopeName: "dojox"}; + } + + if(!d._scopeArgs){ + d._scopeArgs = [dojo, dijit, dojox]; + } + +/*===== +dojo.global = { + // summary: + // Alias for the global scope + // (e.g. the window object in a browser). + // description: + // Refer to 'dojo.global' rather than referring to window to ensure your + // code runs correctly in contexts other than web browsers (e.g. Rhino on a server). +} +=====*/ + d.global = this; + + d.config =/*===== djConfig = =====*/{ + isDebug: false, + debugAtAllCosts: false + }; + + if(typeof djConfig != "undefined"){ + for(var opt in djConfig){ + d.config[opt] = djConfig[opt]; + } + } + + var _platforms = ["Browser", "Rhino", "Spidermonkey", "Mobile"]; + var t; + while((t=_platforms.shift())){ + d["is"+t] = false; + } + +/*===== + // Override locale setting, if specified + dojo.locale = { + // summary: the locale as defined by Dojo (read-only) + }; +=====*/ + dojo.locale = d.config.locale; + + var rev = "$Rev: 13707 $".match(/\d+/); + + dojo.version = { + // summary: + // version number of dojo + // major: Integer + // Major version. If total version is "1.2.0beta1", will be 1 + // minor: Integer + // Minor version. If total version is "1.2.0beta1", will be 2 + // patch: Integer + // Patch version. If total version is "1.2.0beta1", will be 0 + // flag: String + // Descriptor flag. If total version is "1.2.0beta1", will be "beta1" + // revision: Number + // The SVN rev from which dojo was pulled + major: 1, minor: 1, patch: 1, flag: "", + revision: rev ? +rev[0] : 999999, //FIXME: use NaN? + toString: function(){ + with(d.version){ + return major + "." + minor + "." + patch + flag + " (" + revision + ")"; // String + } + } + } + + // Register with the OpenAjax hub + if(typeof OpenAjax != "undefined"){ + OpenAjax.hub.registerLibrary(dojo._scopeName, "http://dojotoolkit.org", d.version.toString()); + } + + dojo._mixin = function(/*Object*/ obj, /*Object*/ props){ + // summary: + // Adds all properties and methods of props to obj. This addition + // is "prototype extension safe", so that instances of objects + // will not pass along prototype defaults. + var tobj = {}; + for(var x in props){ + // the "tobj" condition avoid copying properties in "props" + // inherited from Object.prototype. For example, if obj has a custom + // toString() method, don't overwrite it with the toString() method + // that props inherited from Object.prototype + if(tobj[x] === undefined || tobj[x] != props[x]){ + obj[x] = props[x]; + } + } + // IE doesn't recognize custom toStrings in for..in + if(d["isIE"] && props){ + var p = props.toString; + if(typeof p == "function" && p != obj.toString && p != tobj.toString && + p != "\nfunction toString() {\n [native code]\n}\n"){ + obj.toString = props.toString; + } + } + return obj; // Object + } + + dojo.mixin = function(/*Object*/obj, /*Object...*/props){ + // summary: + // Adds all properties and methods of props to obj and returns the + // (now modified) obj. + // description: + // `dojo.mixin` can mix multiple source objects into a + // destionation object which is then returned. Unlike regular + // `for...in` iteration, `dojo.mixin` is also smart about avoiding + // extensions which other toolkits may unwisely add to the root + // object prototype + // obj: + // The object to mix properties into. Also the return value. + // props: + // One or more objects whose values are successively copied into + // obj. If more than one of these objects contain the same value, + // the one specified last in the function call will "win". + // example: + // make a shallow copy of an object + // | var copy = dojo.mixin({}, source); + // example: + // many class constructors often take an object which specifies + // values to be configured on the object. In this case, it is + // often simplest to call `dojo.mixin` on the `this` object: + // | dojo.declare("acme.Base", null, { + // | constructor: function(properties){ + // | // property configuration: + // | dojo.mixin(this, properties); + // | + // | console.debug(this.quip); + // | // ... + // | }, + // | quip: "I wasn't born yesterday, you know - I've seen movies.", + // | // ... + // | }); + // | + // | // create an instance of the class and configure it + // | var b = new acme.Base({quip: "That's what it does!" }); + // example: + // copy in properties from multiple objects + // | var flattened = dojo.mixin( + // | { + // | name: "Frylock", + // | braces: true, + // | } + // | { + // | name: "Carl Brutanananadilewski" + // | } + // | ); + // | + // | // will print "Carl Brutanananadilewski" + // | console.debug(flattened.name); + // | // will print "true" + // | console.debug(flattened.braces); + for(var i=1, l=arguments.length; i<l; i++){ + d._mixin(obj, arguments[i]); + } + return obj; // Object + } + + dojo._getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){ + var obj=context || d.global; + for(var i=0, p; obj && (p=parts[i]); i++){ + if(i == 0 && this._scopeMap[p]){ + p = this._scopeMap[p]; + } + obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined)); + } + return obj; // mixed + } + + dojo.setObject = function(/*String*/name, /*Object*/value, /*Object?*/context){ + // summary: + // Set a property from a dot-separated string, such as "A.B.C" + // description: + // Useful for longer api chains where you have to test each object in + // the chain, or when you have an object reference in string format. + // Objects are created as needed along `path`. Returns the passed + // value if setting is successful or `undefined` if not. + // name: + // Path to a property, in the form "A.B.C". + // context: + // Optional. Object to use as root of path. Defaults to + // `dojo.global`. + // example: + // set the value of `foo.bar.baz`, regardless of whether + // intermediate objects already exist: + // | dojo.setObject("foo.bar.baz", value); + // example: + // without `dojo.setObject`, we often see code like this: + // | // ensure that intermediate objects are available + // | if(!obj["parent"]){ obj.parent = {}; } + // | if(!obj.parent["child"]){ obj.parent.child= {}; } + // | // now we can safely set the property + // | obj.parent.child.prop = "some value"; + // wheras with `dojo.setObject`, we can shorten that to: + // | dojo.setObject("parent.child.prop", "some value", obj); + var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context); + return obj && p ? (obj[p]=value) : undefined; // Object + } + + dojo.getObject = function(/*String*/name, /*Boolean*/create, /*Object*/context){ + // summary: + // Get a property from a dot-separated string, such as "A.B.C" + // description: + // Useful for longer api chains where you have to test each object in + // the chain, or when you have an object reference in string format. + // name: + // Path to an property, in the form "A.B.C". + // context: + // Optional. Object to use as root of path. Defaults to + // 'dojo.global'. Null may be passed. + // create: + // Optional. Defaults to `false`. If `true`, Objects will be + // created at any point along the 'path' that is undefined. + return d._getProp(name.split("."), create, context); // Object + } + + dojo.exists = function(/*String*/name, /*Object?*/obj){ + // summary: + // determine if an object supports a given method + // description: + // useful for longer api chains where you have to test each object in + // the chain + // name: + // Path to an object, in the form "A.B.C". + // obj: + // Object to use as root of path. Defaults to + // 'dojo.global'. Null may be passed. + // example: + // | // define an object + // | var foo = { + // | bar: { } + // | }; + // | + // | // search the global scope + // | dojo.exists("foo.bar"); // true + // | dojo.exists("foo.bar.baz"); // false + // | + // | // search from a particular scope + // | dojo.exists("bar", foo); // true + // | dojo.exists("bar.baz", foo); // false + return !!d.getObject(name, false, obj); // Boolean + } + + + dojo["eval"] = function(/*String*/ scriptFragment){ + // summary: + // Perform an evaluation in the global scope. Use this rather than + // calling 'eval()' directly. + // description: + // Placed in a separate function to minimize size of trapped + // exceptions. Calling eval() directly from some other scope may + // complicate tracebacks on some platforms. + // return: + // The result of the evaluation. Often `undefined` + + + // note: + // - JSC eval() takes an optional second argument which can be 'unsafe'. + // - Mozilla/SpiderMonkey eval() takes an optional second argument which is the + // scope object for new symbols. + + // FIXME: investigate Joseph Smarr's technique for IE: + // http://josephsmarr.com/2007/01/31/fixing-eval-to-use-global-scope-in-ie/ + // see also: + // http://trac.dojotoolkit.org/ticket/744 + return d.global.eval ? d.global.eval(scriptFragment) : eval(scriptFragment); // Object + } + + /*===== + dojo.deprecated = function(behaviour, extra, removal){ + // summary: + // Log a debug message to indicate that a behavior has been + // deprecated. + // behaviour: String + // The API or behavior being deprecated. Usually in the form + // of "myApp.someFunction()". + // extra: String? + // Text to append to the message. Often provides advice on a + // new function or facility to achieve the same goal during + // the deprecation period. + // removal: String? + // Text to indicate when in the future the behavior will be + // removed. Usually a version number. + // example: + // | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0"); + } + + dojo.experimental = function(moduleName, extra){ + // summary: Marks code as experimental. + // description: + // This can be used to mark a function, file, or module as + // experimental. Experimental code is not ready to be used, and the + // APIs are subject to change without notice. Experimental code may be + // completed deleted without going through the normal deprecation + // process. + // moduleName: String + // The name of a module, or the name of a module file or a specific + // function + // extra: String? + // some additional message for the user + // example: + // | dojo.experimental("dojo.data.Result"); + // example: + // | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA"); + } + =====*/ + + //Real functions declared in dojo._firebug.firebug. + d.deprecated = d.experimental = function(){}; + +})(); +// vim:ai:ts=4:noet diff --git a/includes/js/dojo/_base/_loader/hostenv_browser.js b/includes/js/dojo/_base/_loader/hostenv_browser.js new file mode 100644 index 0000000..f508830 --- /dev/null +++ b/includes/js/dojo/_base/_loader/hostenv_browser.js @@ -0,0 +1,379 @@ +/*===== +dojo.isBrowser = { + // example: + // | if(dojo.isBrowser){ ... } +}; + +dojo.isFF = { + // example: + // | if(dojo.isFF > 1){ ... } +}; + +dojo.isIE = { + // example: + // | if(dojo.isIE > 6){ + // | // we are IE7 + // | } +}; + +dojo.isSafari = { + // example: + // | if(dojo.isSafari){ ... } + // example: + // Detect iPhone: + // | if(dojo.isSafari && (navigator.userAgent.indexOf("iPhone") < 0)){ + // | // we are iPhone. iPod touch reports "iPod" above + // | } +}; + +dojo = { + // isBrowser: Boolean + // True if the client is a web-browser + isBrowser: true, + // isFF: Number + // Greater than zero if client is FireFox. 0 otherwise. Corresponds to + // major detected FireFox version (1.5, 2, 3, etc.) + isFF: 2, + // isIE: Number + // Greater than zero if client is MSIE(PC). 0 otherwise. Corresponds to + // major detected IE version (6, 7, 8, etc.) + isIE: 6, + // isKhtml: Number + // Greater than zero if client is a KTHML-derived browser (Konqueror, + // Safari, etc.). 0 otherwise. Corresponds to major detected version. + isKhtml: 0, + // isMozilla: Number + // Greater than zero if client is a Mozilla-based browser (Firefox, + // SeaMonkey). 0 otherwise. Corresponds to major detected version. + isMozilla: 0, + // isOpera: Number + // Greater than zero if client is Opera. 0 otherwise. Corresponds to + // major detected version. + isOpera: 0, + // isSafari: Number + // Greater than zero if client is Safari or iPhone. 0 otherwise. + isSafari: 0 +} +=====*/ + +if(typeof window != 'undefined'){ + dojo.isBrowser = true; + dojo._name = "browser"; + + + // attempt to figure out the path to dojo if it isn't set in the config + (function(){ + var d = dojo; + // this is a scope protection closure. We set browser versions and grab + // the URL we were loaded from here. + + // grab the node we were loaded from + if(document && document.getElementsByTagName){ + var scripts = document.getElementsByTagName("script"); + var rePkg = /dojo(\.xd)?\.js(\W|$)/i; + for(var i = 0; i < scripts.length; i++){ + var src = scripts[i].getAttribute("src"); + if(!src){ continue; } + var m = src.match(rePkg); + if(m){ + // find out where we came from + if(!d.config.baseUrl){ + d.config.baseUrl = src.substring(0, m.index); + } + // and find out if we need to modify our behavior + var cfg = scripts[i].getAttribute("djConfig"); + if(cfg){ + var cfgo = eval("({ "+cfg+" })"); + for(var x in cfgo){ + dojo.config[x] = cfgo[x]; + } + } + break; // "first Dojo wins" + } + } + } + d.baseUrl = d.config.baseUrl; + + // fill in the rendering support information in dojo.render.* + var n = navigator; + var dua = n.userAgent; + var dav = n.appVersion; + var tv = parseFloat(dav); + + d.isOpera = (dua.indexOf("Opera") >= 0) ? tv : 0; + // safari detection derived from: + // http://developer.apple.com/internet/safari/faq.html#anchor2 + // http://developer.apple.com/internet/safari/uamatrix.html + var idx = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0); + if(idx){ + // try to grab the explicit Safari version first. If we don't get + // one, look for 419.3+ as the indication that we're on something + // "Safari 3-ish". Lastly, default to "Safari 2" handling. + d.isSafari = parseFloat(dav.split("Version/")[1]) || ( ( parseFloat(dav.substr(idx+7)) >= 419.3 ) ? 3 : 2 ) || 2; + } + d.isAIR = (dua.indexOf("AdobeAIR") >= 0) ? 1 : 0; + d.isKhtml = (dav.indexOf("Konqueror") >= 0 || d.isSafari) ? tv : 0; + d.isMozilla = d.isMoz = (dua.indexOf("Gecko") >= 0 && !d.isKhtml) ? tv : 0; + d.isFF = d.isIE = 0; + if(d.isMoz){ + d.isFF = parseFloat(dua.split("Firefox/")[1]) || 0; + } + if(document.all && !d.isOpera){ + d.isIE = parseFloat(dav.split("MSIE ")[1]) || 0; + } + + //Workaround to get local file loads of dojo to work on IE 7 + //by forcing to not use native xhr. + if(dojo.isIE && window.location.protocol === "file:"){ + dojo.config.ieForceActiveXXhr=true; + } + + var cm = document.compatMode; + d.isQuirks = cm == "BackCompat" || cm == "QuirksMode" || d.isIE < 6; + + // TODO: is the HTML LANG attribute relevant? + d.locale = dojo.config.locale || (d.isIE ? n.userLanguage : n.language).toLowerCase(); + + // These are in order of decreasing likelihood; this will change in time. + d._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0']; + + d._xhrObj = function(){ + // summary: + // does the work of portably generating a new XMLHTTPRequest + // object. + var http = null; + var last_e = null; + if(!dojo.isIE || !dojo.config.ieForceActiveXXhr){ + try{ http = new XMLHttpRequest(); }catch(e){} + } + if(!http){ + for(var i=0; i<3; ++i){ + var progid = d._XMLHTTP_PROGIDS[i]; + try{ + http = new ActiveXObject(progid); + }catch(e){ + last_e = e; + } + + if(http){ + d._XMLHTTP_PROGIDS = [progid]; // so faster next time + break; + } + } + } + + if(!http){ + throw new Error("XMLHTTP not available: "+last_e); + } + + return http; // XMLHTTPRequest instance + } + + d._isDocumentOk = function(http){ + var stat = http.status || 0; + return (stat >= 200 && stat < 300) || // Boolean + stat == 304 || // allow any 2XX response code + stat == 1223 || // get it out of the cache + (!stat && (location.protocol=="file:" || location.protocol=="chrome:") ); // Internet Explorer mangled the status code + } + + //See if base tag is in use. + //This is to fix http://trac.dojotoolkit.org/ticket/3973, + //but really, we need to find out how to get rid of the dojo._Url reference + //below and still have DOH work with the dojo.i18n test following some other + //test that uses the test frame to load a document (trac #2757). + //Opera still has problems, but perhaps a larger issue of base tag support + //with XHR requests (hasBase is true, but the request is still made to document + //path, not base path). + var owloc = window.location+""; + var base = document.getElementsByTagName("base"); + var hasBase = (base && base.length > 0); + + d._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){ + // summary: Read the contents of the specified uri and return those contents. + // uri: + // A relative or absolute uri. If absolute, it still must be in + // the same "domain" as we are. + // fail_ok: + // Default false. If fail_ok and loading fails, return null + // instead of throwing. + // returns: The response text. null is returned when there is a + // failure and failure is okay (an exception otherwise) + + // alert("_getText: " + uri); + + // NOTE: must be declared before scope switches ie. this._xhrObj() + var http = this._xhrObj(); + + if(!hasBase && dojo._Url){ + uri = (new dojo._Url(owloc, uri)).toString(); + } + /* + console.debug("_getText:", uri); + console.debug(window.location+""); + alert(uri); + */ + + if(d.config.cacheBust){ + uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(d.config.cacheBust).replace(/\W+/g,""); + } + + http.open('GET', uri, false); + try{ + http.send(null); + // alert(http); + if(!d._isDocumentOk(http)){ + var err = Error("Unable to load "+uri+" status:"+ http.status); + err.status = http.status; + err.responseText = http.responseText; + throw err; + } + }catch(e){ + if(fail_ok){ return null; } // null + // rethrow the exception + throw e; + } + return http.responseText; // String + } + })(); + + dojo._initFired = false; + // BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/) + dojo._loadInit = function(e){ + dojo._initFired = true; + // allow multiple calls, only first one will take effect + // A bug in khtml calls events callbacks for document for event which isnt supported + // for example a created contextmenu event calls DOMContentLoaded, workaround + var type = (e && e.type) ? e.type.toLowerCase() : "load"; + if(arguments.callee.initialized || (type != "domcontentloaded" && type != "load")){ return; } + arguments.callee.initialized = true; + if("_khtmlTimer" in dojo){ + clearInterval(dojo._khtmlTimer); + delete dojo._khtmlTimer; + } + + if(dojo._inFlightCount == 0){ + dojo._modulesLoaded(); + } + } + + dojo._fakeLoadInit = function(){ + dojo._loadInit({type: "load"}); + } + + if(!dojo.config.afterOnLoad){ + // START DOMContentLoaded + // Mozilla and Opera 9 expose the event we could use + if(document.addEventListener){ + // NOTE: + // due to a threading issue in Firefox 2.0, we can't enable + // DOMContentLoaded on that platform. For more information, see: + // http://trac.dojotoolkit.org/ticket/1704 + if(dojo.isOpera || dojo.isFF >= 3 || (dojo.isMoz && dojo.config.enableMozDomContentLoaded === true)){ + document.addEventListener("DOMContentLoaded", dojo._loadInit, null); + } + + // mainly for Opera 8.5, won't be fired if DOMContentLoaded fired already. + // also used for Mozilla because of trac #1640 + window.addEventListener("load", dojo._loadInit, null); + } + + if(dojo.isAIR){ + window.addEventListener("load", dojo._loadInit, null); + }else if(/(WebKit|khtml)/i.test(navigator.userAgent)){ // sniff + dojo._khtmlTimer = setInterval(function(){ + if(/loaded|complete/.test(document.readyState)){ + dojo._loadInit(); // call the onload handler + } + }, 10); + } + // END DOMContentLoaded + } + + (function(){ + var _w = window; + var _handleNodeEvent = function(/*String*/evtName, /*Function*/fp){ + // summary: + // non-destructively adds the specified function to the node's + // evtName handler. + // evtName: should be in the form "onclick" for "onclick" handlers. + // Make sure you pass in the "on" part. + var oldHandler = _w[evtName] || function(){}; + _w[evtName] = function(){ + fp.apply(_w, arguments); + oldHandler.apply(_w, arguments); + }; + }; + + if(dojo.isIE){ + // for Internet Explorer. readyState will not be achieved on init + // call, but dojo doesn't need it however, we'll include it + // because we don't know if there are other functions added that + // might. Note that this has changed because the build process + // strips all comments -- including conditional ones. + if(!dojo.config.afterOnLoad){ + document.write('<scr'+'ipt defer src="//:" ' + + 'onreadystatechange="if(this.readyState==\'complete\'){' + dojo._scopeName + '._loadInit();}">' + + '</scr'+'ipt>' + ); + } + + // IE WebControl hosted in an application can fire "beforeunload" and "unload" + // events when control visibility changes, causing Dojo to unload too soon. The + // following code fixes the problem + // Reference: http://support.microsoft.com/default.aspx?scid=kb;en-us;199155 + var _unloading = true; + _handleNodeEvent("onbeforeunload", function(){ + _w.setTimeout(function(){ _unloading = false; }, 0); + }); + _handleNodeEvent("onunload", function(){ + if(_unloading){ dojo.unloaded(); } + }); + + try{ + document.namespaces.add("v","urn:schemas-microsoft-com:vml"); + document.createStyleSheet().addRule("v\\:*", "behavior:url(#default#VML)"); + }catch(e){} + }else{ + // FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper. + _handleNodeEvent("onbeforeunload", function() { dojo.unloaded(); }); + } + + })(); + + /* + OpenAjax.subscribe("OpenAjax", "onload", function(){ + if(dojo._inFlightCount == 0){ + dojo._modulesLoaded(); + } + }); + + OpenAjax.subscribe("OpenAjax", "onunload", function(){ + dojo.unloaded(); + }); + */ +} //if (typeof window != 'undefined') + +//Register any module paths set up in djConfig. Need to do this +//in the hostenvs since hostenv_browser can read djConfig from a +//script tag's attribute. +(function(){ + var mp = dojo.config["modulePaths"]; + if(mp){ + for(var param in mp){ + dojo.registerModulePath(param, mp[param]); + } + } +})(); + +//Load debug code if necessary. +if(dojo.config.isDebug){ + dojo.require("dojo._firebug.firebug"); +} + +if(dojo.config.debugAtAllCosts){ + dojo.config.useXDomain = true; + dojo.require("dojo._base._loader.loader_xd"); + dojo.require("dojo._base._loader.loader_debug"); + dojo.require("dojo.i18n"); +} diff --git a/includes/js/dojo/_base/_loader/hostenv_rhino.js b/includes/js/dojo/_base/_loader/hostenv_rhino.js new file mode 100644 index 0000000..d363861 --- /dev/null +++ b/includes/js/dojo/_base/_loader/hostenv_rhino.js @@ -0,0 +1,238 @@ +/* +* Rhino host environment +*/ + +if(dojo.config["baseUrl"]){ + dojo.baseUrl = dojo.config["baseUrl"]; +}else{ + dojo.baseUrl = "./"; +} + +dojo.locale = dojo.locale || String(java.util.Locale.getDefault().toString().replace('_','-').toLowerCase()); +dojo._name = 'rhino'; +dojo.isRhino = true; + +if(typeof print == "function"){ + console.debug = print; +} + +if(typeof dojo["byId"] == "undefined"){ + dojo.byId = function(id, doc){ + if(id && (typeof id == "string" || id instanceof String)){ + if(!doc){ doc = document; } + return doc.getElementById(id); + } + return id; // assume it's a node + } +} + +// see comments in spidermonkey loadUri +dojo._loadUri = function(uri, cb){ + try{ + var local = (new java.io.File(uri)).exists(); + if(!local){ + try{ + // try it as a file first, URL second + var stream = (new java.net.URL(uri)).openStream(); + // close the stream so we don't leak resources + stream.close(); + }catch(e){ + // no debug output; this failure just means the uri was not found. + return false; + } + } + //FIXME: Use Rhino 1.6 native readFile/readUrl if available? + if(cb){ + var contents = (local ? readText : readUri)(uri, "UTF-8"); + cb(eval('('+contents+')')); + }else{ + load(uri); + } + return true; + }catch(e){ + console.debug("rhino load('" + uri + "') failed. Exception: " + e); + return false; + } +} + +dojo.exit = function(exitcode){ + quit(exitcode); +} + +// Hack to determine current script... +// +// These initial attempts failed: +// 1. get an EcmaError and look at e.getSourceName(): try {eval ("static in return")} catch(e) { ... +// Won't work because NativeGlobal.java only does a put of "name" and "message", not a wrapped reflecting object. +// Even if the EcmaError object had the sourceName set. +// +// 2. var e = Packages.org.mozilla.javascript.Context.getCurrentContext().reportError(''); +// Won't work because it goes directly to the errorReporter, not the return value. +// We want context.interpreterSourceFile and context.interpreterLine, which are used in static Context.getSourcePositionFromStack +// (set by Interpreter.java at interpretation time, if in interpreter mode). +// +// 3. var e = Packages.org.mozilla.javascript.Context.getCurrentContext().reportRuntimeError(''); +// This returns an object, but e.message still does not have source info. +// In compiler mode, perhaps not set; in interpreter mode, perhaps not used by errorReporter? +// +// What we found works is to do basically the same hack as is done in getSourcePositionFromStack, +// making a new java.lang.Exception() and then calling printStackTrace on a string stream. +// We have to parse the string for the .js files (different from the java files). +// This only works however in compiled mode (-opt 0 or higher). +// In interpreter mode, entire stack is java. +// When compiled, printStackTrace is like: +// java.lang.Exception +// at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) +// at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39) +// at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27) +// at java.lang.reflect.Constructor.newInstance(Constructor.java:274) +// at org.mozilla.javascript.NativeJavaClass.constructSpecific(NativeJavaClass.java:228) +// at org.mozilla.javascript.NativeJavaClass.construct(NativeJavaClass.java:185) +// at org.mozilla.javascript.ScriptRuntime.newObject(ScriptRuntime.java:1269) +// at org.mozilla.javascript.gen.c2.call(/Users/mda/Sites/burstproject/testrhino.js:27) +// ... +// at org.mozilla.javascript.tools.shell.Main.main(Main.java:76) +// +// Note may get different answers based on: +// Context.setOptimizationLevel(-1) +// Context.setGeneratingDebug(true) +// Context.setGeneratingSource(true) +// +// Some somewhat helpful posts: +// http://groups.google.com/groups?hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=9v9n0g%246gr1%40ripley.netscape.com +// http://groups.google.com/groups?hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=3BAA2DC4.6010702%40atg.com +// +// Note that Rhino1.5R5 added source name information in some exceptions. +// But this seems not to help in command-line Rhino, because Context.java has an error reporter +// so no EvaluationException is thrown. + +// do it by using java java.lang.Exception +dojo._rhinoCurrentScriptViaJava = function(depth){ + var optLevel = Packages.org.mozilla.javascript.Context.getCurrentContext().getOptimizationLevel(); + var caw = new java.io.CharArrayWriter(); + var pw = new java.io.PrintWriter(caw); + var exc = new java.lang.Exception(); + var s = caw.toString(); + // we have to exclude the ones with or without line numbers because they put double entries in: + // at org.mozilla.javascript.gen.c3._c4(/Users/mda/Sites/burstproject/burst/Runtime.js:56) + // at org.mozilla.javascript.gen.c3.call(/Users/mda/Sites/burstproject/burst/Runtime.js) + var matches = s.match(/[^\(]*\.js\)/gi); + if(!matches){ + throw Error("cannot parse printStackTrace output: " + s); + } + + // matches[0] is entire string, matches[1] is this function, matches[2] is caller, ... + var fname = ((typeof depth != 'undefined')&&(depth)) ? matches[depth + 1] : matches[matches.length - 1]; + var fname = matches[3]; + if(!fname){ fname = matches[1]; } + // print("got fname '" + fname + "' from stack string '" + s + "'"); + if (!fname){ throw Error("could not find js file in printStackTrace output: " + s); } + //print("Rhino getCurrentScriptURI returning '" + fname + "' from: " + s); + return fname; +} + +// reading a file from disk in Java is a humiliating experience by any measure. +// Lets avoid that and just get the freaking text +function readText(path, encoding){ + encoding = encoding || "utf-8"; + // NOTE: we intentionally avoid handling exceptions, since the caller will + // want to know + var jf = new java.io.File(path); + var is = new java.io.FileInputStream(jf); + return dj_readInputStream(is, encoding); +} + +function readUri(uri, encoding){ + var conn = (new java.net.URL(uri)).openConnection(); + encoding = encoding || conn.getContentEncoding() || "utf-8"; + var is = conn.getInputStream(); + return dj_readInputStream(is, encoding); +} + +function dj_readInputStream(is, encoding){ + var input = new java.io.BufferedReader(new java.io.InputStreamReader(is, encoding)); + try { + var sb = new java.lang.StringBuffer(); + var line = ""; + while((line = input.readLine()) !== null){ + sb.append(line); + sb.append(java.lang.System.getProperty("line.separator")); + } + return sb.toString(); + } finally { + input.close(); + } +} + +// call this now because later we may not be on the top of the stack +if( + (!dojo.config.libraryScriptUri)|| + (!dojo.config.libraryScriptUri.length) +){ + try{ + dojo.config.libraryScriptUri = dojo._rhinoCurrentScriptViaJava(1); + }catch(e){ + // otherwise just fake it + if(dojo.config["isDebug"]){ + print("\n"); + print("we have no idea where Dojo is located."); + print("Please try loading rhino in a non-interpreted mode or set a"); + print("\n\tdjConfig.libraryScriptUri\n"); + print("Setting the dojo path to './'"); + print("This is probably wrong!"); + print("\n"); + print("Dojo will try to load anyway"); + } + dojo.config.libraryScriptUri = "./"; + } +} + +// summary: +// return the document object associated with the dojo.global +dojo.doc = typeof(document) != "undefined" ? document : null; + +dojo.body = function(){ + return document.body; +} + +dojo._timeouts = []; + +function clearTimeout(idx){ + if(!dojo._timeouts[idx]){ return; } + dojo._timeouts[idx].stop(); +} + +function setTimeout(func, delay){ + // summary: provides timed callbacks using Java threads + + var def={ + sleepTime:delay, + hasSlept:false, + + run:function(){ + if(!this.hasSlept){ + this.hasSlept=true; + java.lang.Thread.currentThread().sleep(this.sleepTime); + } + try{ + func(); + }catch(e){ + console.debug("Error running setTimeout thread:" + e); + } + } + }; + + var runnable = new java.lang.Runnable(def); + var thread = new java.lang.Thread(runnable); + thread.start(); + return dojo._timeouts.push(thread)-1; +} + +//Register any module paths set up in djConfig. Need to do this +//in the hostenvs since hostenv_browser can read djConfig from a +//script tag's attribute. +if(dojo.config["modulePaths"]){ + for(var param in dojo.config["modulePaths"]){ + dojo.registerModulePath(param, dojo.config["modulePaths"][param]); + } +} diff --git a/includes/js/dojo/_base/_loader/hostenv_spidermonkey.js b/includes/js/dojo/_base/_loader/hostenv_spidermonkey.js new file mode 100644 index 0000000..e31539f --- /dev/null +++ b/includes/js/dojo/_base/_loader/hostenv_spidermonkey.js @@ -0,0 +1,80 @@ +/* + * SpiderMonkey host environment + */ + +if(dojo.config["baseUrl"]){ + dojo.baseUrl = dojo.config["baseUrl"]; +}else{ + dojo.baseUrl = "./"; +} + +dojo._name = 'spidermonkey'; + +/*===== +dojo.isSpidermonkey = { + // summary: Detect spidermonkey +}; +=====*/ + +dojo.isSpidermonkey = true; +dojo.exit = function(exitcode){ + quit(exitcode); +} + +if(typeof print == "function"){ + console.debug = print; +} + +if(typeof line2pc == 'undefined'){ + throw new Error("attempt to use SpiderMonkey host environment when no 'line2pc' global"); +} + +dojo._spidermonkeyCurrentFile = function(depth){ + // + // This is a hack that determines the current script file by parsing a + // generated stack trace (relying on the non-standard "stack" member variable + // of the SpiderMonkey Error object). + // + // If param depth is passed in, it'll return the script file which is that far down + // the stack, but that does require that you know how deep your stack is when you are + // calling. + // + var s = ''; + try{ + throw Error("whatever"); + }catch(e){ + s = e.stack; + } + // lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101 + var matches = s.match(/[^@]*\.js/gi); + if(!matches){ + throw Error("could not parse stack string: '" + s + "'"); + } + var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1]; + if(!fname){ + throw Error("could not find file name in stack string '" + s + "'"); + } + //print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'"); + return fname; +} + +// print(dojo._spidermonkeyCurrentFile(0)); + +dojo._loadUri = function(uri){ + // spidermonkey load() evaluates the contents into the global scope (which + // is what we want). + // TODO: sigh, load() does not return a useful value. + // Perhaps it is returning the value of the last thing evaluated? + var ok = load(uri); + // console.debug("spidermonkey load(", uri, ") returned ", ok); + return 1; +} + +//Register any module paths set up in djConfig. Need to do this +//in the hostenvs since hostenv_browser can read djConfig from a +//script tag's attribute. +if(dojo.config["modulePaths"]){ + for(var param in dojo.config["modulePaths"]){ + dojo.registerModulePath(param, dojo.config["modulePaths"][param]); + } +} diff --git a/includes/js/dojo/_base/_loader/loader.js b/includes/js/dojo/_base/_loader/loader.js new file mode 100644 index 0000000..6a16e4f --- /dev/null +++ b/includes/js/dojo/_base/_loader/loader.js @@ -0,0 +1,690 @@ +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 + } +})(); + +} diff --git a/includes/js/dojo/_base/_loader/loader_debug.js b/includes/js/dojo/_base/_loader/loader_debug.js new file mode 100644 index 0000000..7e52373 --- /dev/null +++ b/includes/js/dojo/_base/_loader/loader_debug.js @@ -0,0 +1,61 @@ +if(!dojo._hasResource["dojo._base._loader.loader_debug"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base._loader.loader_debug"] = true; +dojo.provide("dojo._base._loader.loader_debug"); + +//Override dojo.provide, so we can trigger the next +//script tag for the next local module. We can only add one +//at a time because there are browsers that execute script tags +//in the order that the code is received, and not in the DOM order. +dojo.nonDebugProvide = dojo.provide; + +dojo.provide = function(resourceName){ + var dbgQueue = dojo["_xdDebugQueue"]; + if(dbgQueue && dbgQueue.length > 0 && resourceName == dbgQueue["currentResourceName"]){ + //Set a timeout so the module can be executed into existence. Normally the + //dojo.provide call in a module is the first line. Don't want to risk attaching + //another script tag until the current one finishes executing. + if(dojo.isAIR){ + window.setTimeout(function(){dojo._xdDebugFileLoaded(resourceName);}, 1); + }else{ + window.setTimeout(dojo._scopeName + "._xdDebugFileLoaded('" + resourceName + "')", 1); + } + } + + return dojo.nonDebugProvide.apply(dojo, arguments); +} + +dojo._xdDebugFileLoaded = function(resourceName){ + + if(!this._xdDebugScopeChecked){ + //If using a scoped dojo, we need to expose dojo as a real global + //for the debugAtAllCosts stuff to work. + if(dojo._scopeName != "dojo"){ + window.dojo = window[dojo.config.scopeMap[0][1]]; + window.dijit = window[dojo.config.scopeMap[1][1]]; + window.dojox = window[dojo.config.scopeMap[2][1]]; + } + + this._xdDebugScopeChecked = true; + } + + var dbgQueue = this._xdDebugQueue; + + if(resourceName && resourceName == dbgQueue.currentResourceName){ + dbgQueue.shift(); + } + + if(dbgQueue.length == 0){ + dbgQueue.currentResourceName = null; + this._xdNotifyLoaded(); + }else{ + if(resourceName == dbgQueue.currentResourceName){ + dbgQueue.currentResourceName = dbgQueue[0].resourceName; + var element = document.createElement("script"); + element.type = "text/javascript"; + element.src = dbgQueue[0].resourcePath; + document.getElementsByTagName("head")[0].appendChild(element); + } + } +} + +} diff --git a/includes/js/dojo/_base/_loader/loader_xd.js b/includes/js/dojo/_base/_loader/loader_xd.js new file mode 100644 index 0000000..d851df8 --- /dev/null +++ b/includes/js/dojo/_base/_loader/loader_xd.js @@ -0,0 +1,631 @@ +if(!dojo._hasResource["dojo._base._loader.loader_xd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base._loader.loader_xd"] = true; +//Cross-domain resource loader. +dojo.provide("dojo._base._loader.loader_xd"); + +dojo._xdReset = function(){ + //summary: Internal xd loader function. Resets the xd state. + + //This flag indicates where or not we have crossed into xdomain territory. Once any resource says + //it is cross domain, then the rest of the resources have to be treated as xdomain because we need + //to evaluate resources in order. If there is a xdomain resource followed by a xhr resource, we can't load + //the xhr resource until the one before it finishes loading. The text of the xhr resource will be converted + //to match the format for a xd resource and put in the xd load queue. + this._isXDomain = dojo.config.useXDomain || false; + + this._xdTimer = 0; + this._xdInFlight = {}; + this._xdOrderedReqs = []; + this._xdDepMap = {}; + this._xdContents = []; + this._xdDefList = []; +} + +//Call reset immediately to set the state. +dojo._xdReset(); + +dojo._xdCreateResource = function(/*String*/contents, /*String*/resourceName, /*String*/resourcePath){ + //summary: Internal xd loader function. Creates an xd module source given an + //non-xd module contents. + + //Remove comments. Not perfect, but good enough for dependency resolution. + var depContents = contents.replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg , ""); + + //Find dependencies. + var deps = []; + var depRegExp = /dojo.(require|requireIf|provide|requireAfterIf|platformRequire|requireLocalization)\(([\w\W]*?)\)/mg; + var match; + while((match = depRegExp.exec(depContents)) != null){ + if(match[1] == "requireLocalization"){ + //Need to load the local bundles asap, since they are not + //part of the list of modules watched for loading. + eval(match[0]); + }else{ + deps.push('"' + match[1] + '", ' + match[2]); + } + } + + //Create resource object and the call to _xdResourceLoaded. + var output = []; + output.push(dojo._scopeName + "._xdResourceLoaded({\n"); + + //Add dependencies + if(deps.length > 0){ + output.push("depends: ["); + for(var i = 0; i < deps.length; i++){ + if(i > 0){ + output.push(",\n"); + } + output.push("[" + deps[i] + "]"); + } + output.push("],"); + } + + //Add the contents of the file inside a function. + //Pass in scope arguments so we can support multiple versions of the + //same module on a page. + output.push("\ndefineResource: function(" + dojo._scopePrefixArgs + "){"); + + //Don't put in the contents in the debugAtAllCosts case + //since the contents may have syntax errors. Let those + //get pushed up when the script tags are added to the page + //in the debugAtAllCosts case. + if(!dojo.config["debugAtAllCosts"] || resourceName == "dojo._base._loader.loader_debug"){ + output.push(contents); + } + //Add isLocal property so we know if we have to do something different + //in debugAtAllCosts situations. + output.push("\n}, resourceName: '" + resourceName + "', resourcePath: '" + resourcePath + "'});"); + + return output.join(""); //String +} + +dojo._xdIsXDomainPath = function(/*string*/relpath) { + //summary: Figure out whether the path is local or x-domain + //If there is a colon before the first / then, we have a URL with a protocol. + + var colonIndex = relpath.indexOf(":"); + var slashIndex = relpath.indexOf("/"); + + if(colonIndex > 0 && colonIndex < slashIndex){ + return true; + }else{ + //Is the base script URI-based URL a cross domain URL? + //If so, then the relpath will be evaluated relative to + //baseUrl, and therefore qualify as xdomain. + //Only treat it as xdomain if the page does not have a + //host (file:// url) or if the baseUrl does not match the + //current window's domain. + var url = this.baseUrl; + colonIndex = url.indexOf(":"); + slashIndex = url.indexOf("/"); + if(colonIndex > 0 && colonIndex < slashIndex && (!location.host || url.indexOf("http://" + location.host) != 0)){ + return true; + } + } + return false; +} + +dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){ + //summary: Internal xd loader function. Overrides loadPath() from loader.js. + //xd loading requires slightly different behavior from loadPath(). + + var currentIsXDomain = this._xdIsXDomainPath(relpath); + this._isXDomain |= currentIsXDomain; + + var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : this.baseUrl) + relpath; + + try{ + return ((!module || this._isXDomain) ? this._loadUri(uri, cb, currentIsXDomain, module) : this._loadUriAndCheck(uri, module, cb)); //Boolean + }catch(e){ + console.debug(e); + return false; //Boolean + } +} + +dojo._loadUri = function(/*String*/uri, /*Function?*/cb, /*boolean*/currentIsXDomain, /*String?*/module){ + //summary: Internal xd loader function. Overrides loadUri() from loader.js. + // xd loading requires slightly different behavior from loadPath(). + //description: Wanted to override getText(), but it is used by + // the widget code in too many, synchronous ways right now. + if(this._loadedUrls[uri]){ + return 1; //Boolean + } + + //Add the module (resource) to the list of modules. + //Only do this work if we have a modlue name. Otherwise, + //it is a non-xd i18n bundle, which can load immediately and does not + //need to be tracked. Also, don't track dojo.i18n, since it is a prerequisite + //and will be loaded correctly if we load it right away: it has no dependencies. + if(this._isXDomain && module && module != "dojo.i18n"){ + this._xdOrderedReqs.push(module); + + //Add to waiting resources if it is an xdomain resource. + //Don't add non-xdomain i18n bundles, those get evaled immediately. + if(currentIsXDomain || uri.indexOf("/nls/") == -1){ + this._xdInFlight[module] = true; + + //Increment inFlightCount + //This will stop the modulesLoaded from firing all the way. + this._inFlightCount++; + } + + //Start timer + if(!this._xdTimer){ + if(dojo.isAIR){ + this._xdTimer = setInterval(function(){dojo._xdWatchInFlight();}, 100); + }else{ + this._xdTimer = setInterval(dojo._scopeName + "._xdWatchInFlight();", 100); + } + } + this._xdStartTime = (new Date()).getTime(); + } + + if (currentIsXDomain){ + //Fix name to be a .xd.fileextension name. + var lastIndex = uri.lastIndexOf('.'); + if(lastIndex <= 0){ + lastIndex = uri.length - 1; + } + + var xdUri = uri.substring(0, lastIndex) + ".xd"; + if(lastIndex != uri.length - 1){ + xdUri += uri.substring(lastIndex, uri.length); + } + + if (dojo.isAIR){ + xdUri = xdUri.replace("app:/", "/"); + } + + //Add to script src + var element = document.createElement("script"); + element.type = "text/javascript"; + element.src = xdUri; + if(!this.headElement){ + this._headElement = document.getElementsByTagName("head")[0]; + + //Head element may not exist, particularly in html + //html 4 or tag soup cases where the page does not + //have a head tag in it. Use html element, since that will exist. + //Seems to be an issue mostly with Opera 9 and to lesser extent Safari 2 + if(!this._headElement){ + this._headElement = document.getElementsByTagName("html")[0]; + } + } + this._headElement.appendChild(element); + }else{ + var contents = this._getText(uri, null, true); + if(contents == null){ return 0; /*boolean*/} + + //If this is not xdomain, or if loading a i18n resource bundle, then send it down + //the normal eval/callback path. + if(this._isXDomain + && uri.indexOf("/nls/") == -1 + && module != "dojo.i18n"){ + var res = this._xdCreateResource(contents, module, uri); + dojo.eval(res); + }else{ + 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; + } + var value = dojo["eval"](contents+"\r\n//@ sourceURL="+uri); + if(cb){ + cb(value); + } + } + } + + //These steps are done in the non-xd loader version of this function. + //Maintain these steps to fit in with the existing system. + this._loadedUrls[uri] = true; + this._loadedUrls.push(uri); + return true; //Boolean +} + +dojo._xdResourceLoaded = function(/*Object*/res){ + //summary: Internal xd loader function. Called by an xd module resource when + //it has been loaded via a script tag. + var deps = res.depends; + var requireList = null; + var requireAfterList = null; + var provideList = []; + if(deps && deps.length > 0){ + var dep = null; + var insertHint = 0; + var attachedResource = false; + for(var i = 0; i < deps.length; i++){ + dep = deps[i]; + + //Look for specific dependency indicators. + if (dep[0] == "provide"){ + provideList.push(dep[1]); + }else{ + if(!requireList){ + requireList = []; + } + if(!requireAfterList){ + requireAfterList = []; + } + + var unpackedDeps = this._xdUnpackDependency(dep); + if(unpackedDeps.requires){ + requireList = requireList.concat(unpackedDeps.requires); + } + if(unpackedDeps.requiresAfter){ + requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter); + } + } + + //Call the dependency indicator to allow for the normal dojo setup. + //Only allow for one dot reference, for the i18n._preloadLocalizations calls + //(and maybe future, one-dot things). + var depType = dep[0]; + var objPath = depType.split("."); + if(objPath.length == 2){ + dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1)); + }else{ + dojo[depType].apply(dojo, dep.slice(1)); + } + } + + + //If loading the debugAtAllCosts module, eval it right away since we need + //its functions to properly load the other modules. + if(provideList.length == 1 && provideList[0] == "dojo._base._loader.loader_debug"){ + res.defineResource(dojo); + }else{ + //Save off the resource contents for definition later. + var contentIndex = this._xdContents.push({ + content: res.defineResource, + resourceName: res["resourceName"], + resourcePath: res["resourcePath"], + isDefined: false + }) - 1; + + //Add provide/requires to dependency map. + for(var i = 0; i < provideList.length; i++){ + this._xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex }; + } + } + + //Now update the inflight status for any provided resources in this loaded resource. + //Do this at the very end (in a *separate* for loop) to avoid shutting down the + //inflight timer check too soon. + for(var i = 0; i < provideList.length; i++){ + this._xdInFlight[provideList[i]] = false; + } + } +} + +dojo._xdLoadFlattenedBundle = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*Object*/bundleData){ + //summary: Internal xd loader function. Used when loading + //a flattened localized bundle via a script tag. + locale = locale || "root"; + var jsLoc = dojo.i18n.normalizeLocale(locale).replace('-', '_'); + var bundleResource = [moduleName, "nls", bundleName].join("."); + var bundle = dojo["provide"](bundleResource); + bundle[jsLoc] = bundleData; + + //Assign the bundle for the original locale(s) we wanted. + var mapName = [moduleName, jsLoc, bundleName].join("."); + var bundleMap = dojo._xdBundleMap[mapName]; + if(bundleMap){ + for(var param in bundleMap){ + bundle[param] = bundleData; + } + } +}; + + +dojo._xdInitExtraLocales = function(){ + // Simulate the extra locale work that dojo.requireLocalization does. + + var extra = dojo.config.extraLocale; + if(extra){ + if(!extra instanceof Array){ + extra = [extra]; + } + + dojo._xdReqLoc = dojo.xdRequireLocalization; + dojo.xdRequireLocalization = function(m, b, locale, fLocales){ + dojo._xdReqLoc(m,b,locale, fLocales); + if(locale){return;} + for(var i=0; i<extra.length; i++){ + dojo._xdReqLoc(m,b,extra[i], fLocales); + } + }; + } +} + +dojo._xdBundleMap = {}; + +dojo.xdRequireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){ + //summary: Internal xd loader function. The xd version of dojo.requireLocalization. + + + //Account for allowing multiple extra locales. Do this here inside the function + //since dojo._xdInitExtraLocales() depends on djConfig being set up, but that only + //happens after hostenv_browser runs. loader_xd has to come before hostenv_browser + //though since hostenv_browser can do a dojo.require for the debug module. + if(dojo._xdInitExtraLocales){ + dojo._xdInitExtraLocales(); + dojo._xdInitExtraLocales = null; + dojo.xdRequireLocalization.apply(dojo, arguments); + return; + } + + var locales = availableFlatLocales.split(","); + + //Find the best-match locale to load. + //Assumes dojo.i18n has already been loaded. This is true for xdomain builds, + //since it is included in dojo.xd.js. + var jsLoc = dojo.i18n.normalizeLocale(locale); + + var bestLocale = ""; + for(var i = 0; i < locales.length; i++){ + //Locale must match from start of string. + if(jsLoc.indexOf(locales[i]) == 0){ + if(locales[i].length > bestLocale.length){ + bestLocale = locales[i]; + } + } + } + + var fixedBestLocale = bestLocale.replace('-', '_'); + //See if the bundle we are going to use is already loaded. + var bundleResource = dojo.getObject([moduleName, "nls", bundleName].join(".")); + if(bundleResource && bundleResource[fixedBestLocale]){ + bundle[jsLoc.replace('-', '_')] = bundleResource[fixedBestLocale]; + }else{ + //Need to remember what locale we wanted and which one we actually use. + //Then when we load the one we are actually using, use that bundle for the one + //we originally wanted. + var mapName = [moduleName, (fixedBestLocale||"root"), bundleName].join("."); + var bundleMap = dojo._xdBundleMap[mapName]; + if(!bundleMap){ + bundleMap = dojo._xdBundleMap[mapName] = {}; + } + bundleMap[jsLoc.replace('-', '_')] = true; + + //Do just a normal dojo.require so the resource tracking stuff works as usual. + dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName); + } +} + +// Replace dojo.requireLocalization with a wrapper +dojo._xdRealRequireLocalization = dojo.requireLocalization; +dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){ + // summary: loads a bundle intelligently based on whether the module is + // local or xd. Overrides the local-case implementation. + + var modulePath = this.moduleUrl(moduleName).toString(); + if (this._xdIsXDomainPath(modulePath)) { + // call cross-domain loader + return dojo.xdRequireLocalization.apply(dojo, arguments); + } else { + // call local-loader + return dojo._xdRealRequireLocalization.apply(dojo, arguments); + } +} + +//This is a bit brittle: it has to know about the dojo methods that deal with dependencies +//It would be ideal to intercept the actual methods and do something fancy at that point, +//but I have concern about knowing which provide to match to the dependency in that case, +//since scripts can load whenever they want, and trigger new calls to dojo._xdResourceLoaded(). +dojo._xdUnpackDependency = function(/*Array*/dep){ + //summary: Internal xd loader function. Determines what to do with a dependency + //that was listed in an xd version of a module contents. + + //Extract the dependency(ies). + var newDeps = null; + var newAfterDeps = null; + switch(dep[0]){ + case "requireIf": + case "requireAfterIf": + //First arg (dep[1]) is the test. Depedency is dep[2]. + if(dep[1] === true){ + newDeps = [{name: dep[2], content: null}]; + } + break; + case "platformRequire": + var modMap = dep[1]; + var common = modMap["common"]||[]; + var newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]); + //Flatten the array of arrays into a one-level deep array. + //Each result could be an array of 3 elements (the 3 arguments to dojo.require). + //We only need the first one. + if(newDeps){ + for(var i = 0; i < newDeps.length; i++){ + if(newDeps[i] instanceof Array){ + newDeps[i] = {name: newDeps[i][0], content: null}; + }else{ + newDeps[i] = {name: newDeps[i], content: null}; + } + } + } + break; + case "require": + //Just worry about dep[1] + newDeps = [{name: dep[1], content: null}]; + break; + case "i18n._preloadLocalizations": + //We can eval these immediately, since they load i18n bundles. + //Since i18n bundles have no dependencies, whenever they are loaded + //in a script tag, they are evaluated immediately, so we do not have to + //treat them has an explicit dependency for the dependency mapping. + //We can call it immediately since dojo.i18n is part of dojo.xd.js. + dojo.i18n._preloadLocalizations.apply(dojo.i18n._preloadLocalizations, dep.slice(1)); + break; + } + + //The requireIf and requireAfterIf needs to be evaluated after the current resource is evaluated. + if(dep[0] == "requireAfterIf" || dep[0] == "requireIf"){ + newAfterDeps = newDeps; + newDeps = null; + } + return {requires: newDeps, requiresAfter: newAfterDeps}; //Object +} + +dojo._xdWalkReqs = function(){ + //summary: Internal xd loader function. + //Walks the requires and evaluates module resource contents in + //the right order. + var reqChain = null; + var req; + for(var i = 0; i < this._xdOrderedReqs.length; i++){ + req = this._xdOrderedReqs[i]; + if(this._xdDepMap[req]){ + reqChain = [req]; + reqChain[req] = true; //Allow for fast lookup of the req in the array + this._xdEvalReqs(reqChain); + } + } +} + +dojo._xdEvalReqs = function(/*Array*/reqChain){ + //summary: Internal xd loader function. + //Does a depth first, breadth second search and eval of required modules. + while(reqChain.length > 0){ + var req = reqChain[reqChain.length - 1]; + var res = this._xdDepMap[req]; + if(res){ + //Trace down any requires for this resource. + //START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + var reqs = res.requires; + if(reqs && reqs.length > 0){ + var nextReq; + for(var i = 0; i < reqs.length; i++){ + nextReq = reqs[i].name; + if(nextReq && !reqChain[nextReq]){ + //New req depedency. Follow it down. + reqChain.push(nextReq); + reqChain[nextReq] = true; + this._xdEvalReqs(reqChain); + } + } + } + //END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + + //Evaluate the resource. + var contents = this._xdContents[res.contentIndex]; + if(!contents.isDefined){ + var content = contents.content; + content["resourceName"] = contents["resourceName"]; + content["resourcePath"] = contents["resourcePath"]; + this._xdDefList.push(content); + contents.isDefined = true; + } + this._xdDepMap[req] = null; + + //Trace down any requireAfters for this resource. + //START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + var reqs = res.requiresAfter; + if(reqs && reqs.length > 0){ + var nextReq; + for(var i = 0; i < reqs.length; i++){ + nextReq = reqs[i].name; + if(nextReq && !reqChain[nextReq]){ + //New req depedency. Follow it down. + reqChain.push(nextReq); + reqChain[nextReq] = true; + this._xdEvalReqs(reqChain); + } + } + } + //END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + } + + //Done with that require. Remove it and go to the next one. + reqChain.pop(); + } +} + +dojo._xdClearInterval = function(){ + //summary: Internal xd loader function. + //Clears the interval timer used to check on the + //status of in-flight xd module resource requests. + clearInterval(this._xdTimer); + this._xdTimer = 0; +} + +dojo._xdWatchInFlight = function(){ + //summary: Internal xd loader function. + //Monitors in-flight requests for xd module resources. + + var noLoads = ""; + var waitInterval = (dojo.config.xdWaitSeconds || 15) * 1000; + var expired = (this._xdStartTime + waitInterval) < (new Date()).getTime(); + + //If any xdInFlight are true, then still waiting for something to load. + //Come back later. If we timed out, report the things that did not load. + for(var param in this._xdInFlight){ + if(this._xdInFlight[param] === true){ + if(expired){ + noLoads += param + " "; + }else{ + return; + } + } + } + + //All done. Clean up and notify. + this._xdClearInterval(); + + if(expired){ + throw "Could not load cross-domain resources: " + noLoads; + } + + this._xdWalkReqs(); + + var defLength = this._xdDefList.length; + for(var i= 0; i < defLength; i++){ + var content = dojo._xdDefList[i]; + if(dojo.config["debugAtAllCosts"] && content["resourceName"]){ + if(!this["_xdDebugQueue"]){ + this._xdDebugQueue = []; + } + this._xdDebugQueue.push({resourceName: content.resourceName, resourcePath: content.resourcePath}); + }else{ + //Evaluate the resource to bring it into being. + //Pass in scope args to allow multiple versions of modules in a page. + content.apply(dojo.global, dojo._scopeArgs); + } + } + + //Evaluate any resources that were not evaled before. + //This normally shouldn't happen with proper dojo.provide and dojo.require + //usage, but providing it just in case. Note that these may not be executed + //in the original order that the developer intended. + for(var i = 0; i < this._xdContents.length; i++){ + var current = this._xdContents[i]; + if(current.content && !current.isDefined){ + //Pass in scope args to allow multiple versions of modules in a page. + current.content.apply(dojo.global, dojo._scopeArgs); + } + } + + //Clean up for the next round of xd loading. + this._xdReset(); + + if(this["_xdDebugQueue"] && this._xdDebugQueue.length > 0){ + this._xdDebugFileLoaded(); + }else{ + this._xdNotifyLoaded(); + } +} + +dojo._xdNotifyLoaded = function(){ + //Clear inflight count so we will finally do finish work. + this._inFlightCount = 0; + + //Only trigger call loaded if dj_load_init has run. + if(this._initFired && !this._loadNotifying){ + this._callLoaded(); + } +} + +} |