Subversion Repositories Applications.papyrus

Compare Revisions

Ignore whitespace Rev 2149 → Rev 2150

/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();
}
}
 
}