/trunk/api/js/dojo1.0/dojo/_base/_loader/hostenv_rhino.js |
---|
New file |
0,0 → 1,235 |
/* |
* Rhino host environment |
*/ |
if(djConfig["baseUrl"]){ |
dojo.baseUrl = djConfig["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(!djConfig.libraryScriptUri.length){ |
try{ |
djConfig.libraryScriptUri = dojo._rhinoCurrentScriptViaJava(1); |
}catch(e){ |
// otherwise just fake it |
if(djConfig["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"); |
} |
djConfig.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(djConfig["modulePaths"]){ |
for(var param in djConfig["modulePaths"]){ |
dojo.registerModulePath(param, djConfig["modulePaths"][param]); |
} |
} |
/trunk/api/js/dojo1.0/dojo/_base/_loader/loader.js |
---|
New file |
0,0 → 1,618 |
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; |
dojo.mixin(dojo, { |
_loadedModules: {}, |
_inFlightCount: 0, |
_hasResource: {}, |
// FIXME: it should be possible to pull module prefixes in from djConfig |
_modulePrefixes: { |
dojo: {name: "dojo", value: "."}, |
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 |
}); |
//>>excludeStart("xdomainExclude", fileName.indexOf("dojo.xd.js") != -1 && kwArgs.loader == "xdomain"); |
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; |
if(djConfig.cacheBust && d.isBrowser){ |
uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,""); |
} |
try{ |
return !module ? this._loadUri(uri, cb) : this._loadUriAndCheck(uri, module, cb); // Boolean |
}catch(e){ |
console.debug(e); |
return false; // Boolean |
} |
} |
dojo._loadUri = function(/*String (URL)*/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+')'; } |
var value = d["eval"](contents+"\r\n//@ sourceURL="+uri); |
if(cb){ cb(value); } |
return true; // Boolean |
} |
//>>excludeEnd("xdomainExclude"); |
// FIXME: probably need to add logging to this method |
dojo._loadUriAndCheck = function(/*String (URL)*/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.debug("failed loading " + uri + " with error: " + e); |
} |
return Boolean(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 = this._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++){ |
mll[x](); |
} |
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 && this._loaders.length > 0){ |
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())(); |
} |
} |
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"); |
if(arguments.length == 1){ |
d._loaders.push(obj); |
}else if(arguments.length > 1){ |
d._loaders.push(function(){ |
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") |
if(arguments.length == 1){ |
d._unloaders.push(obj); |
}else if(arguments.length > 1){ |
d._unloaders.push(function(){ |
obj[functionName](); |
}); |
} |
} |
dojo._modulesLoaded = function(){ |
if(d._postLoad){ return; } |
if(d._inFlightCount > 0){ |
console.debug("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" || (djConfig["useXDomain"] && d.isOpera)){ |
setTimeout("dojo.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: String |
// omitModuleCheck: Boolean? |
// description: |
// _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. |
// |
// It throws 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. |
// |
// This does nothing about importing symbols into the current package. |
// It is presumed that the caller will take care of that. For example, |
// to import all symbols: |
// |
// | with (dojo._loadModule("A.B")) { |
// | ... |
// | } |
// |
// And to import just the leaf symbol: |
// |
// | var B = dojo._loadModule("A.B"); |
// | ... |
// returns: the required namespace object |
omitModuleCheck = this._global_omit_module_check || omitModuleCheck; |
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 (exactly) 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"); at the |
// top of the file. |
// 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("dojo.io.cometd"), in addition to registering that |
// cometd.js is a resource for the dojo.iomodule, will ensure that |
// the dojo.io javascript object exists, so that calls like |
// dojo.io.foo = function(){ ... } don't fail. |
// |
// In the case of a build (or in the future, a rollup), where multiple |
// javascript source files are combined into one bigger file (similar |
// to a .lib or .jar file), that file will 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 containing Arrays*/modMap){ |
// description: |
// This method taks 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 the |
// hostenv.name_ item. The items in the "common" array will _always_ |
// be loaded, regardless of which list is chosen. Here's how it's |
// normally called: |
// |
// | dojo.platformRequire({ |
// | // an example that passes multiple args to _loadModule() |
// | browser: [ |
// | ["foo.bar.baz", true, true], |
// | "foo.sample", |
// | "foo.test, |
// | ], |
// | default: [ "foo.sample.*" ], |
// | common: [ "really.important.module.*" ] |
// | }); |
// FIXME: dojo.name_ no longer works!! |
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. |
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+""); |
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] == "."){ |
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] != ".."){ |
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 += relobj.scheme + ":"; |
} |
if(relobj.authority){ |
uri += "//" + relobj.authority; |
} |
uri += relobj.path; |
if(relobj.query){ |
uri += "?" + relobj.query; |
} |
if(relobj.fragment){ |
uri += "#" + relobj.fragment; |
} |
} |
this.uri = uri.toString(); |
// 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 Url object relative to a module |
// |
// example: |
// | dojo.moduleUrl("dojo.widget","templates/template.html"); |
// example: |
// | dojo.moduleUrl("acme","images/small.png") |
var loc = dojo._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 |
} |
})(); |
} |
/trunk/api/js/dojo1.0/dojo/_base/_loader/hostenv_browser.js |
---|
New file |
0,0 → 1,303 |
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([\?\.]|$)/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(!djConfig["baseUrl"]){ |
djConfig["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){ |
djConfig[x] = cfgo[x]; |
} |
} |
break; // "first Dojo wins" |
} |
} |
} |
d.baseUrl = djConfig["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; |
d.isKhtml = (dav.indexOf("Konqueror") >= 0)||(dav.indexOf("Safari") >= 0) ? tv : 0; |
if(dav.indexOf("Safari") >= 0){ |
d.isSafari = parseFloat(dav.split("Version/")[1]) || 2; |
} |
var geckoPos = dua.indexOf("Gecko"); |
d.isMozilla = d.isMoz = ((geckoPos >= 0)&&(!d.isKhtml)) ? tv : 0; |
d.isFF = 0; |
d.isIE = 0; |
try{ |
if(d.isMoz){ |
d.isFF = parseFloat(dua.split("Firefox/")[1].split(" ")[0]); |
} |
if((document.all)&&(!d.isOpera)){ |
d.isIE = parseFloat(dav.split("MSIE ")[1].split(";")[0]); |
} |
}catch(e){} |
//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:")){ |
djConfig.ieForceActiveXXhr=true; |
} |
var cm = document["compatMode"]; |
d.isQuirks = (cm == "BackCompat")||(cm == "QuirksMode")||(d.isIE < 6); |
// TODO: is the HTML LANG attribute relevant? |
d.locale = djConfig.locale || (d.isIE ? n.userLanguage : n.language).toLowerCase(); |
d._println = console.debug; |
// 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 || !djConfig.ieForceActiveXXhr){ |
try{ http = new XMLHttpRequest(); }catch(e){} |
} |
if(!http){ |
for(var i=0; i<3; ++i){ |
var progid = dojo._XMLHTTP_PROGIDS[i]; |
try{ |
http = new ActiveXObject(progid); |
}catch(e){ |
last_e = e; |
} |
if(http){ |
dojo._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); |
*/ |
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(typeof dojo["_khtmlTimer"] != 'undefined'){ |
clearInterval(dojo._khtmlTimer); |
delete dojo._khtmlTimer; |
} |
if(dojo._inFlightCount == 0){ |
dojo._modulesLoaded(); |
} |
} |
// 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.isMoz && (djConfig["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(/(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. |
document.write('<scr'+'ipt defer src="//:" ' |
+ 'onreadystatechange="if(this.readyState==\'complete\'){dojo._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') |
//Load debug code if necessary. |
// dojo.requireIf((djConfig["isDebug"] || djConfig["debugAtAllCosts"]), "dojo.debug"); |
//window.widget is for Dashboard detection |
//The full conditionals are spelled out to avoid issues during builds. |
//Builds may be looking for require/requireIf statements and processing them. |
// dojo.requireIf(djConfig["debugAtAllCosts"] && !window.widget && !djConfig["useXDomain"], "dojo.browser_debug"); |
// dojo.requireIf(djConfig["debugAtAllCosts"] && !window.widget && djConfig["useXDomain"], "dojo.browser_debug_xd"); |
if(djConfig.isDebug){ |
dojo.require("dojo._firebug.firebug"); |
} |
if(djConfig.debugAtAllCosts){ |
djConfig.useXDomain = true; |
dojo.require("dojo._base._loader.loader_xd"); |
dojo.require("dojo._base._loader.loader_debug"); |
dojo.require("dojo.i18n"); |
} |
/trunk/api/js/dojo1.0/dojo/_base/_loader/loader_debug.js |
---|
New file |
0,0 → 1,42 |
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. |
window.setTimeout("dojo._xdDebugFileLoaded('" + resourceName + "')", 1); |
} |
return dojo.nonDebugProvide.apply(dojo, arguments); |
} |
dojo._xdDebugFileLoaded = function(resourceName){ |
var dbgQueue = this._xdDebugQueue; |
if(resourceName && resourceName == dbgQueue.currentResourceName){ |
dbgQueue.shift(); |
} |
if(dbgQueue.length == 0){ |
dbgQueue.currentResourceName = null; |
this._xdNotifyLoaded(); |
}else{ |
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); |
} |
} |
} |
/trunk/api/js/dojo1.0/dojo/_base/_loader/bootstrap.js |
---|
New file |
0,0 → 1,249 |
// TODOC: HOW TO DOC THE BELOW? |
// @global: djConfig |
// summary: |
// Application code can set the global 'djConfig' prior to loading |
// the library to override certain global settings for how dojo works. |
// description: The variables that can be set are as follows: |
// - isDebug: false |
// - libraryScriptUri: "" |
// - locale: undefined |
// - extraLocale: undefined |
// - preventBackButtonFix: true |
// 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. |
(function(){ |
// make sure djConfig is defined |
if(typeof this["djConfig"] == "undefined"){ |
this.djConfig = {}; |
} |
// firebug stubs |
if((!this["console"])||(!console["firebug"])){ |
this.console = {}; |
} |
var cn = [ |
"assert", "count", "debug", "dir", "dirxml", "error", "group", |
"groupEnd", "info", "log", "profile", "profileEnd", "time", |
"timeEnd", "trace", "warn" |
]; |
var i=0, tn; |
while((tn=cn[i++])){ |
if(!console[tn]){ |
console[tn] = function(){}; |
} |
} |
//TODOC: HOW TO DOC THIS? |
// dojo is the root variable of (almost all) our public symbols -- make sure it is defined. |
if(typeof this["dojo"] == "undefined"){ |
this.dojo = {}; |
} |
var d = dojo; |
// summary: |
// return the current global context object |
// (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 (eg: Rhino on a server). |
dojo.global = this; |
var _config =/*===== djConfig = =====*/{ |
isDebug: false, |
libraryScriptUri: "", |
preventBackButtonFix: true, |
delayMozLoadingFix: false |
}; |
for(var option in _config){ |
if(typeof djConfig[option] == "undefined"){ |
djConfig[option] = _config[option]; |
} |
} |
var _platforms = ["Browser", "Rhino", "Spidermonkey", "Mobile"]; |
var t; |
while(t=_platforms.shift()){ |
d["is"+t] = false; |
} |
// Override locale setting, if specified |
dojo.locale = djConfig.locale; |
//TODOC: HOW TO DOC THIS? |
dojo.version = { |
// summary: version number of this instance of dojo. |
major: 1, minor: 0, patch: 2, flag: "", |
revision: Number("$Rev: 11832 $".match(/[0-9]+/)[0]), |
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", "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. |
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++){ |
obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined)); |
} |
return obj; // mixed |
} |
dojo.setObject = function(/*String*/name, /*mixed*/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'. |
// name: |
// Path to a property, in the form "A.B.C". |
// context: |
// Optional. Object to use as root of path. Defaults to |
// 'dojo.global'. Null may be passed. |
var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context); |
return (obj && p ? (obj[p]=value) : undefined); // mixed |
} |
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. If true, Objects will be created at any point along the |
// 'path' that is undefined. |
return d._getProp(name.split("."), create, context); // mixed |
} |
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. |
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 |
// evaluation context. |
// 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); // mixed |
} |
/*===== |
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 |
/trunk/api/js/dojo1.0/dojo/_base/_loader/hostenv_spidermonkey.js |
---|
New file |
0,0 → 1,73 |
/* |
* SpiderMonkey host environment |
*/ |
if(djConfig["baseUrl"]){ |
dojo.baseUrl = djConfig["baseUrl"]; |
}else{ |
dojo.baseUrl = "./"; |
} |
dojo._name = '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(djConfig["modulePaths"]){ |
for(var param in djConfig["modulePaths"]){ |
dojo.registerModulePath(param, djConfig["modulePaths"][param]); |
} |
} |
/trunk/api/js/dojo1.0/dojo/_base/_loader/loader_xd.js |
---|
New file |
0,0 → 1,629 |
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 = djConfig.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._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 dojo as an argument to the function to help with |
//allowing multiple versions of dojo in a page. |
output.push("\ndefineResource: function(dojo){"); |
//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(!djConfig["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 = this.baseUrl + relpath; |
if(currentIsXDomain){ |
// check whether the relpath is an absolute URL itself. If so, we |
// ignore baseUrl |
var colonIndex = relpath.indexOf(":"); |
var slashIndex = relpath.indexOf("/"); |
if(colonIndex > 0 && colonIndex < slashIndex){ |
uri = relpath; |
} |
} |
if(djConfig.cacheBust && dojo.isBrowser) { uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,""); } |
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){ |
this._xdTimer = setInterval("dojo._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); |
} |
//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+')'; } |
var value = dojo.eval(contents); |
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 = djConfig.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 = (djConfig.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(djConfig["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 dojo in so that later, to support multiple versions of dojo |
//in a page, we can pass which version of dojo to use. |
content(dojo); |
} |
} |
//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. |
//Pass dojo in so that later, to support multiple versions of dojo |
//in a page, we can pass which version of dojo to use. |
for(var i = 0; i < this._xdContents.length; i++){ |
var current = this._xdContents[i]; |
if(current.content && !current.isDefined){ |
current.content(dojo); |
} |
} |
//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(); |
} |
} |
} |