From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001
From: mensonge
Date: Thu, 13 Nov 2008 09:49:11 +0000
Subject: New feature: basic Ajax suggestion for tags and implementation of
Dojo toolkit
git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
---
includes/js/dojo/_base/_loader/bootstrap.js | 436 +++++++++++++
includes/js/dojo/_base/_loader/hostenv_browser.js | 379 +++++++++++
includes/js/dojo/_base/_loader/hostenv_rhino.js | 238 +++++++
.../js/dojo/_base/_loader/hostenv_spidermonkey.js | 80 +++
includes/js/dojo/_base/_loader/loader.js | 690 +++++++++++++++++++++
includes/js/dojo/_base/_loader/loader_debug.js | 61 ++
includes/js/dojo/_base/_loader/loader_xd.js | 631 +++++++++++++++++++
7 files changed, 2515 insertions(+)
create mode 100644 includes/js/dojo/_base/_loader/bootstrap.js
create mode 100644 includes/js/dojo/_base/_loader/hostenv_browser.js
create mode 100644 includes/js/dojo/_base/_loader/hostenv_rhino.js
create mode 100644 includes/js/dojo/_base/_loader/hostenv_spidermonkey.js
create mode 100644 includes/js/dojo/_base/_loader/loader.js
create mode 100644 includes/js/dojo/_base/_loader/loader_debug.js
create mode 100644 includes/js/dojo/_base/_loader/loader_xd.js
(limited to 'includes/js/dojo/_base/_loader')
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
+ // `
+ // |
+ 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 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();
+ }
+}
+
+}
--
cgit v1.2.3-54-g00ecf