You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by fh...@apache.org on 2008/09/02 22:00:38 UTC
svn commit: r691359 [6/8] - in /tomcat/trunk: ./ java/org/apache/cometd/
java/org/apache/cometd/bayeux/ java/org/apache/tomcat/bayeux/
java/org/apache/tomcat/bayeux/request/ test/org/apache/cometd/
test/org/apache/cometd/bayeux/ test/org/apache/cometd/...
Added: tomcat/trunk/webapps/cometd/examples/dojo/dojo/dojo.xd.js.uncompressed.js
URL: http://svn.apache.org/viewvc/tomcat/trunk/webapps/cometd/examples/dojo/dojo/dojo.xd.js.uncompressed.js?rev=691359&view=auto
==============================================================================
--- tomcat/trunk/webapps/cometd/examples/dojo/dojo/dojo.xd.js.uncompressed.js (added)
+++ tomcat/trunk/webapps/cometd/examples/dojo/dojo/dojo.xd.js.uncompressed.js Tue Sep 2 13:00:36 2008
@@ -0,0 +1,8203 @@
+/*
+ Copyright (c) 2004-2007, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/book/dojo-book-0-9/introduction/licensing
+*/
+
+/*
+ This is a compiled version of Dojo, built for deployment and not for
+ development. To get an editable version, please visit:
+
+ http://dojotoolkit.org
+
+ for documentation and information on getting the source.
+*/
+
+if(typeof dojo == "undefined"){
+
+/*=====
+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;
+
+/*=====
+dojo.global = {
+ // summary:
+ // Alias for the global scope
+ // (e.g. the window object in a browser).
+ // description:
+ // Refer to 'dojo.global' rather than referring to window to ensure your
+ // code runs correctly in contexts other than web browsers (e.g. Rhino on a server).
+}
+=====*/
+ 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 = {
+ // summary: the locale as defined by Dojo (read-only)
+ };
+=====*/
+ dojo.locale = djConfig.locale;
+
+ var rev = "$Rev: 11742 $".match(/\d+/);
+
+ dojo.version = {
+ // summary: version number of this instance of dojo.
+ major: 0, minor: 0, patch: 0, flag: "dev",
+ revision: rev ? Number(rev[0]) : 999999,
+ 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
+
+/*
+ * loader.js - A bootstrap module. Runs before the hostenv_*.js file. Contains
+ * all of the package loading methods.
+ */
+
+(function(){
+ var d = dojo;
+
+ d.mixin(d, {
+ _loadedModules: {},
+ _inFlightCount: 0,
+ _hasResource: {},
+
+ // 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
+ });
+
+
+
+ // 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.error("failed loading " + uri + " with error: " + e);
+ }
+ return !!(ok && this._loadedModules[moduleName]); // Boolean
+ }
+
+ dojo.loaded = function(){
+ // summary:
+ // signal fired when initial environment and package loading is
+ // complete. You may use dojo.addOnLoad() or dojo.connect() to
+ // this method in order to handle initialization tasks that
+ // require the environment to be initialized. In a browser host,
+ // declarative widgets will be constructed when this function
+ // finishes runing.
+ this._loadNotifying = true;
+ this._postLoad = true;
+ var mll = 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++){
+ try{ mll[x](); }catch(e){ console.error(e); /* let other events fire */ }
+ }
+
+ 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.warn("files still in flight!");
+ return;
+ }
+ d._callLoaded();
+ }
+
+ dojo._callLoaded = function(){
+ //The "object" check is for IE, and the other opera check fixes an issue
+ //in Opera where it could not find the body element in some widget test cases.
+ //For 0.9, maybe route all browsers through the setTimeout (need protection
+ //still for non-browser environments though). This might also help the issue with
+ //FF 2.0 and freezing issues where we try to do sync xhr while background css images
+ //are being loaded (trac #2572)? Consider for 0.9.
+ if(typeof setTimeout == "object" || (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 = d._getModuleSymbols(module).join('/');
+ if(!loc){ return null; }
+ if(loc.lastIndexOf("/") != loc.length-1){
+ loc += "/";
+ }
+
+ //If the path is an absolute path (starts with a / or is on another
+ //domain/xdomain) then don't add the baseUrl.
+ var colonIndex = loc.indexOf(":");
+ if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > loc.indexOf("/"))){
+ loc = d.baseUrl + loc;
+ }
+
+ return new d._Url(loc, url); // String
+ }
+})();
+
+//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();
+ }
+}
+
+/*=====
+dojo.isBrowser = {
+ // summary: True if the client is a web-browser
+ // example:
+ // if(dojo.isBrowser){ ... }
+};
+
+dojo.isFF = {
+ // summary: True if client is using FireFox browser. False otherwise.
+ // example:
+ // if(dojo.isFF && dojo.isFF > 1){ ... }
+};
+
+dojo.isIE = {
+ // summary: The major version if client it using Internet Explorer (or false)
+ // example:
+ // if(dojo.isIE && dojo.isIE > 6){
+ // // we are IE7
+ // }
+};
+
+dojo.isKhtml = {
+ // summary: True if client is using Khtml browsers (konqueror, et al)
+};
+
+dojo.isMozilla = {
+ // summary: True if client is using a Mozilla-based browser.
+};
+
+dojo.isOpera = {
+ // summary: True if client is using the Opera web browser
+};
+
+dojo.isSafari = {
+ // summary: True if client is using the Safari web browser
+ // example:
+ // | if(dojo.isSafari){ ... }
+ //
+ // example:
+ // Detect iPhone:
+ // | if(dojo.isSafari && (navigator.userAgent.indexOf("iPhone") < 0)){
+ // | // we are iPhone. iPod touch reports "iPod" above
+ // | }
+};
+=====*/
+
+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");
+
+}
+
+};
+
+if(!dojo._hasResource["dojo._base.lang"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo._base.lang"] = true;
+dojo.provide("dojo._base.lang");
+
+// Crockford (ish) functions
+
+dojo.isString = function(/*anything*/ it){
+ // summary: Return true if it is a String
+ return typeof it == "string" || it instanceof String; // Boolean
+}
+
+dojo.isArray = function(/*anything*/ it){
+ // summary: Return true if it is an Array
+ return it && it instanceof Array || typeof it == "array"; // Boolean
+}
+
+/*=====
+dojo.isFunction = function(it){
+ // summary: Return true if it is a Function
+ // it: anything
+}
+=====*/
+
+dojo.isFunction = (function(){
+ var _isFunction = function(/*anything*/ it){
+ return typeof it == "function" || it instanceof Function; // Boolean
+ };
+
+ return dojo.isSafari ?
+ // only slow this down w/ gratuitious casting in Safari since it's what's b0rken
+ function(/*anything*/ it){
+ if(typeof it == "function" && it == "[object NodeList]"){ return false; }
+ return _isFunction(it); // Boolean
+ } : _isFunction;
+})();
+
+dojo.isObject = function(/*anything*/ it){
+ // summary:
+ // Returns true if it is a JavaScript object (or an Array, a Function or null)
+ return it !== undefined &&
+ (it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean
+}
+
+dojo.isArrayLike = function(/*anything*/ it){
+ // summary:
+ // similar to dojo.isArray() but more permissive
+ // description:
+ // Doesn't strongly test for "arrayness". Instead, settles for "isn't
+ // a string or number and has a length property". Arguments objects
+ // and DOM collections will return true when passed to
+ // dojo.isArrayLike(), but will return false when passed to
+ // dojo.isArray().
+ // return:
+ // If it walks like a duck and quicks like a duck, return true
+ var d = dojo;
+ return it && it !== undefined &&
+ // keep out built-in constructors (Number, String, ...) which have length
+ // properties
+ !d.isString(it) && !d.isFunction(it) &&
+ !(it.tagName && it.tagName.toLowerCase() == 'form') &&
+ (d.isArray(it) || isFinite(it.length)); // Boolean
+}
+
+dojo.isAlien = function(/*anything*/ it){
+ // summary:
+ // Returns true if it is a built-in function or some other kind of
+ // oddball that *should* report as a function but doesn't
+ return it && !dojo.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+}
+
+dojo.extend = function(/*Object*/ constructor, /*Object...*/ props){
+ // summary:
+ // Adds all properties and methods of props to constructor's
+ // prototype, making them available to all instances created with
+ // constructor.
+ for(var i=1, l=arguments.length; i<l; i++){
+ dojo._mixin(constructor.prototype, arguments[i]);
+ }
+ return constructor; // Object
+}
+
+dojo._hitchArgs = function(scope, method /*,...*/){
+ var pre = dojo._toArray(arguments, 2);
+ var named = dojo.isString(method);
+ return function(){
+ // arrayify arguments
+ var args = dojo._toArray(arguments);
+ // locate our method
+ var f = named ? (scope||dojo.global)[method] : method;
+ // invoke with collected args
+ return f && f.apply(scope || this, pre.concat(args)); // mixed
+ } // Function
+}
+
+dojo.hitch = function(/*Object*/scope, /*Function|String*/method /*,...*/){
+ // summary:
+ // Returns a function that will only ever execute in the a given scope.
+ // This allows for easy use of object member functions
+ // in callbacks and other places in which the "this" keyword may
+ // otherwise not reference the expected scope.
+ // Any number of default positional arguments may be passed as parameters
+ // beyond "method".
+ // Each of these values will be used to "placehold" (similar to curry)
+ // for the hitched function.
+ // scope:
+ // The scope to use when method executes. If method is a string,
+ // scope is also the object containing method.
+ // method:
+ // A function to be hitched to scope, or the name of the method in
+ // scope to be hitched.
+ // example:
+ // | dojo.hitch(foo, "bar")();
+ // runs foo.bar() in the scope of foo
+ // example:
+ // | dojo.hitch(foo, myFunction);
+ // returns a function that runs myFunction in the scope of foo
+ if(arguments.length > 2){
+ return dojo._hitchArgs.apply(dojo, arguments); // Function
+ }
+ if(!method){
+ method = scope;
+ scope = null;
+ }
+ if(dojo.isString(method)){
+ scope = scope || dojo.global;
+ if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
+ return function(){ return scope[method].apply(scope, arguments || []); }; // Function
+ }
+ return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
+}
+
+/*=====
+dojo.delegate = function(obj, props){
+ // summary:
+ // returns a new object which "looks" to obj for properties which it
+ // does not have a value for. Optionally takes a bag of properties to
+ // seed the returned object with initially.
+ // description:
+ // This is a small implementaton of the Boodman/Crockford delegation
+ // pattern in JavaScript. An intermediate object constructor mediates
+ // the prototype chain for the returned object, using it to delegate
+ // down to obj for property lookup when object-local lookup fails.
+ // This can be thought of similarly to ES4's "wrap", save that it does
+ // not act on types but rather on pure objects.
+ // obj:
+ // The object to delegate to for properties not found directly on the
+ // return object or in props.
+ // props:
+ // an object containing properties to assign to the returned object
+ // returns:
+ // an Object of anonymous type
+ // example:
+ // | var foo = { bar: "baz" };
+ // | var thinger = dojo.delegate(foo, { thud: "xyzzy"});
+ // | thinger.bar == "baz"; // delegated to foo
+ // | foo.xyzzy == undefined; // by definition
+ // | thinger.xyzzy == "xyzzy"; // mixed in from props
+ // | foo.bar = "thonk";
+ // | thinger.bar == "thonk"; // still delegated to foo's bar
+}
+=====*/
+
+
+dojo.delegate = dojo._delegate = function(obj, props){
+
+ // boodman/crockford delegation
+ function TMP(){};
+ TMP.prototype = obj;
+ var tmp = new TMP();
+ if(props){
+ dojo.mixin(tmp, props);
+ }
+ return tmp; // Object
+}
+
+dojo.partial = function(/*Function|String*/method /*, ...*/){
+ // summary:
+ // similar to hitch() except that the scope object is left to be
+ // whatever the execution context eventually becomes.
+ // description:
+ // Calling dojo.partial is the functional equivalent of calling:
+ // | dojo.hitch(null, funcName, ...);
+ var arr = [ null ];
+ return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function
+}
+
+dojo._toArray = function(/*Object*/obj, /*Number?*/offset, /*Array?*/ startWith){
+ // summary:
+ // Converts an array-like object (i.e. arguments, DOMCollection)
+ // to an array. Returns a new Array object.
+ // obj:
+ // the object to "arrayify". We expect the object to have, at a
+ // minimum, a length property which corresponds to integer-indexed
+ // properties.
+ // offset:
+ // the location in obj to start iterating from. Defaults to 0. Optional.
+ // startWith:
+ // An array to pack with the properties of obj. If provided,
+ // properties in obj are appended at the end of startWith and
+ // startWith is the returned array.
+ var arr = startWith||[];
+ for(var x = offset || 0; x < obj.length; x++){
+ arr.push(obj[x]);
+ }
+ return arr; // Array
+}
+
+dojo.clone = function(/*anything*/ o){
+ // summary:
+ // Clones objects (including DOM nodes) and all children.
+ // Warning: do not clone cyclic structures.
+ if(!o){ return o; }
+ if(dojo.isArray(o)){
+ var r = [];
+ for(var i = 0; i < o.length; ++i){
+ r.push(dojo.clone(o[i]));
+ }
+ return r; // Array
+ }
+ if(!dojo.isObject(o)){
+ return o; /*anything*/
+ }
+ if(o.nodeType && o.cloneNode){ // isNode
+ return o.cloneNode(true); // Node
+ }
+ if(o instanceof Date){
+ return new Date(o.getTime()); // Date
+ }
+ // Generic objects
+ var r = new o.constructor(); // specific to dojo.declare()'d classes!
+ for(var i in o){
+ if(!(i in r) || r[i] != o[i]){
+ r[i] = dojo.clone(o[i]);
+ }
+ }
+ return r; // Object
+}
+
+dojo.trim = function(/*String*/ str){
+ // summary:
+ // trims whitespaces from both sides of the string
+ // description:
+ // This version of trim() was selected for inclusion into the base due
+ // to its compact size and relatively good performance (see Steven
+ // Levithan's blog:
+ // http://blog.stevenlevithan.com/archives/faster-trim-javascript).
+ // The fastest but longest version of this function is located at
+ // dojo.string.trim()
+ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String
+}
+
+}
+
+if(!dojo._hasResource["dojo._base.declare"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo._base.declare"] = true;
+dojo.provide("dojo._base.declare");
+
+
+// this file courtesy of the TurboAjax group, licensed under a Dojo CLA
+
+dojo.declare = function(/*String*/ className, /*Function|Function[]*/ superclass, /*Object*/ props){
+ // summary:
+ // Create a feature-rich constructor from compact notation
+ // className:
+ // The name of the constructor (loosely, a "class")
+ // stored in the "declaredClass" property in the created prototype
+ // superclass:
+ // May be null, a Function, or an Array of Functions. If an array,
+ // the first element is used as the prototypical ancestor and
+ // any following Functions become mixin ancestors.
+ // props:
+ // An object whose properties are copied to the
+ // created prototype.
+ // Add an instance-initialization function by making it a property
+ // named "constructor".
+ // description:
+ // Create a constructor using a compact notation for inheritance and
+ // prototype extension.
+ //
+ // All superclasses (including mixins) must be Functions (not simple Objects).
+ //
+ // Mixin ancestors provide a type of multiple inheritance. Prototypes of mixin
+ // ancestors are copied to the new class: changes to mixin prototypes will
+ // not affect classes to which they have been mixed in.
+ //
+ // "className" is cached in "declaredClass" property of the new class.
+ //
+ // example:
+ // | dojo.declare("my.classes.bar", my.classes.foo, {
+ // | // properties to be added to the class prototype
+ // | someValue: 2,
+ // | // initialization function
+ // | constructor: function(){
+ // | this.myComplicatedObject = new ReallyComplicatedObject();
+ // | },
+ // | // other functions
+ // | someMethod: function(){
+ // | doStuff();
+ // | }
+ // | );
+
+ // argument juggling (deprecated)
+ if(dojo.isFunction(props)||(arguments.length>3)){
+ dojo.deprecated("dojo.declare: for class '" + className + "' pass initializer function as 'constructor' property instead of as a separate argument.", "", "1.0");
+ var c = props;
+ props = arguments[3] || {};
+ props.constructor = c;
+ }
+ // process superclass argument
+ // var dd=dojo.declare, mixins=null;
+ var dd=arguments.callee, mixins=null;
+ if(dojo.isArray(superclass)){
+ mixins = superclass;
+ superclass = mixins.shift();
+ }
+ // construct intermediate classes for mixins
+ if(mixins){
+ for(var i=0, m; i<mixins.length; i++){
+ m = mixins[i];
+ if(!m){throw("Mixin #" + i + " to declaration of " + className + " is null. It's likely a required module is not loaded.")};
+ superclass = dd._delegate(superclass, m);
+ }
+ }
+ // prepare values
+ var init=(props||0).constructor, ctor=dd._delegate(superclass), fn;
+ // name methods (experimental)
+ for(var i in props){if(dojo.isFunction(fn=props[i])&&(!0[i])){fn.nom=i;}}
+ // decorate prototype
+ dojo.extend(ctor, {declaredClass: className, _constructor: init, preamble: null}, props||0);
+ // special help for IE
+ ctor.prototype.constructor = ctor;
+ // create named reference
+ return dojo.setObject(className, ctor); // Function
+}
+
+dojo.mixin(dojo.declare, {
+ _delegate: function(base, mixin){
+ var bp = (base||0).prototype, mp = (mixin||0).prototype;
+ // fresh constructor, fresh prototype
+ var ctor = dojo.declare._makeCtor();
+ // cache ancestry
+ dojo.mixin(ctor, {superclass: bp, mixin: mp, extend: dojo.declare._extend});
+ // chain prototypes
+ if(base){ctor.prototype = dojo._delegate(bp);}
+ // add mixin and core
+ dojo.extend(ctor, dojo.declare._core, mp||0, {_constructor: null, preamble: null});
+ // special help for IE
+ ctor.prototype.constructor = ctor;
+ // name this class for debugging
+ ctor.prototype.declaredClass = (bp||0).declaredClass + '_' + (mp||0).declaredClass;
+ return ctor;
+ },
+ _extend: function(props){
+ for(var i in props){if(dojo.isFunction(fn=props[i])&&(!0[i])){fn.nom=i;}}
+ dojo.extend(this, props);
+ },
+ _makeCtor: function(){
+ // we have to make a function, but don't want to close over anything
+ return function(){ this._construct(arguments); }
+ },
+ _core: {
+ _construct: function(args){
+ var c=args.callee, s=c.superclass, ct=s&&s.constructor, m=c.mixin, mct=m&&m.constructor, a=args, ii, fn;
+ // side-effect of = used on purpose here, lint may complain, don't try this at home
+ if(a[0]){
+ // FIXME: preambles for each mixin should be allowed
+ // FIXME:
+ // should we allow the preamble here NOT to modify the
+ // default args, but instead to act on each mixin
+ // independently of the class instance being constructed
+ // (for impdedence matching)?
+
+ // allow any first argument w/ a "preamble" property to act as a
+ // class preamble (not exclusive of the prototype preamble)
+ if(/*dojo.isFunction*/(fn = a[0]["preamble"])){
+ a = fn.apply(this, a) || a;
+ }
+ }
+ // prototype preamble
+ if(fn=c.prototype.preamble){a = fn.apply(this, a) || a;}
+ // FIXME:
+ // need to provide an optional prototype-settable
+ // "_explicitSuper" property which disables this
+ // initialize superclass
+ if(ct&&ct.apply){ct.apply(this, a);}
+ // initialize mixin
+ if(mct&&mct.apply){mct.apply(this, a);}
+ // initialize self
+ if(ii=c.prototype._constructor){ii.apply(this, args);}
+ // post construction
+ if(this.constructor.prototype==c.prototype && (ct=this.postscript)){ct.apply(this, args)};
+ },
+ _findMixin: function(mixin){
+ var c = this.constructor, p, m;
+ while(c){
+ p = c.superclass;
+ m = c.mixin;
+ if(m==mixin || (m instanceof mixin.constructor)){return p;}
+ if(m && (m=m._findMixin(mixin))){return m;}
+ c = p && p.constructor;
+ }
+ },
+ _findMethod: function(name, method, ptype, has){
+ // consciously trading readability for bytes and speed in this low-level method
+ var p=ptype, c, m, f;
+ do{
+ c = p.constructor;
+ m = c.mixin;
+ // find method by name in our mixin ancestor
+ if(m && (m=this._findMethod(name, method, m, has))){return m};
+ // if we found a named method that either exactly-is or exactly-is-not 'method'
+ if((f=p[name])&&(has==(f==method))){return p};
+ // ascend chain
+ p = c.superclass;
+ }while(p);
+ // if we couldn't find an ancestor in our primary chain, try a mixin chain
+ return !has && (p=this._findMixin(ptype)) && this._findMethod(name, method, p, has);
+ },
+ inherited: function(name, args, newArgs){
+ // optionalize name argument (experimental)
+ var a = arguments;
+ if(!dojo.isString(a[0])){newArgs=args; args=name; name=args.callee.nom;}
+ var c=args.callee, p=this.constructor.prototype, a=newArgs||args, fn, mp;
+ // if not an instance override
+ if(this[name]!=c || p[name]==c){
+ mp = this._findMethod(name, c, p, true);
+ if(!mp){throw(this.declaredClass + ': name argument ("' + name + '") to inherited must match callee (declare.js)');}
+ p = this._findMethod(name, c, mp, false);
+ }
+ fn = p && p[name];
+ // FIXME: perhaps we should throw here?
+ if(!fn){console.debug(mp.declaredClass + ': no inherited "' + name + '" was found (declare.js)'); return;}
+ // if the function exists, invoke it in our scope
+ return fn.apply(this, a);
+ }
+ }
+});
+
+}
+
+if(!dojo._hasResource["dojo._base.connect"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo._base.connect"] = true;
+dojo.provide("dojo._base.connect");
+
+
+// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
+
+// low-level delegation machinery
+dojo._listener = {
+ // create a dispatcher function
+ getDispatcher: function(){
+ // following comments pulled out-of-line to prevent cloning them
+ // in the returned function.
+ // - indices (i) that are really in the array of listeners (ls) will
+ // not be in Array.prototype. This is the 'sparse array' trick
+ // that keeps us safe from libs that take liberties with built-in
+ // objects
+ // - listener is invoked with current scope (this)
+ return function(){
+ var ap=Array.prototype, c=arguments.callee, ls=c._listeners, t=c.target;
+ // return value comes from original target function
+ var r=t && t.apply(this, arguments);
+ // invoke listeners after target function
+ for(var i in ls){
+ if(!(i in ap)){
+ ls[i].apply(this, arguments);
+ }
+ }
+ // return value comes from original target function
+ return r;
+ }
+ },
+ // add a listener to an object
+ add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){
+ // Whenever 'method' is invoked, 'listener' will have the same scope.
+ // Trying to supporting a context object for the listener led to
+ // complexity.
+ // Non trivial to provide 'once' functionality here
+ // because listener could be the result of a dojo.hitch call,
+ // in which case two references to the same hitch target would not
+ // be equivalent.
+ source = source || dojo.global;
+ // The source method is either null, a dispatcher, or some other function
+ var f = source[method];
+ // Ensure a dispatcher
+ if(!f||!f._listeners){
+ var d = dojo._listener.getDispatcher();
+ // original target function is special
+ d.target = f;
+ // dispatcher holds a list of listeners
+ d._listeners = [];
+ // redirect source to dispatcher
+ f = source[method] = d;
+ }
+ // The contract is that a handle is returned that can
+ // identify this listener for disconnect.
+ //
+ // The type of the handle is private. Here is it implemented as Integer.
+ // DOM event code has this same contract but handle is Function
+ // in non-IE browsers.
+ //
+ // We could have separate lists of before and after listeners.
+ return f._listeners.push(listener) ; /*Handle*/
+ },
+ // remove a listener from an object
+ remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){
+ var f = (source||dojo.global)[method];
+ // remember that handle is the index+1 (0 is not a valid handle)
+ if(f && f._listeners && handle--){
+ delete f._listeners[handle];
+ }
+ }
+};
+
+// Multiple delegation for arbitrary methods.
+
+// This unit knows nothing about DOM,
+// but we include DOM aware
+// documentation and dontFix
+// argument here to help the autodocs.
+// Actual DOM aware code is in event.js.
+
+dojo.connect = function(/*Object|null*/ obj,
+ /*String*/ event,
+ /*Object|null*/ context,
+ /*String|Function*/ method,
+ /*Boolean*/ dontFix){
+ // summary:
+ // Create a link that calls one function when another executes.
+ //
+ // description:
+ // Connects method to event, so that after event fires, method
+ // does too. All connected functions are passed the same arguments as
+ // the event function was initially called with. You may connect as
+ // many methods to event as needed.
+ //
+ // event must be a string. If obj is null, dojo.global is used.
+ //
+ // null arguments may simply be omitted.
+ //
+ // obj[event] can resolve to a function or undefined (null).
+ // If obj[event] is null, it is assigned a function.
+ //
+ // The return value is a handle that is needed to
+ // remove this connection with dojo.disconnect.
+ //
+ // obj:
+ // The source object for the event function.
+ // Defaults to dojo.global if null.
+ // If obj is a DOM node, the connection is delegated
+ // to the DOM event manager (unless dontFix is true).
+ //
+ // event:
+ // String name of the event function in obj.
+ // I.e. identifies a property obj[event].
+ //
+ // context:
+ // The object that method will receive as "this".
+ //
+ // If context is null and method is a function, then method
+ // inherits the context of event.
+ //
+ // If method is a string then context must be the source
+ // object object for method (context[method]). If context is null,
+ // dojo.global is used.
+ //
+ // method:
+ // A function reference, or name of a function in context.
+ // The function identified by method fires after event does.
+ // method receives the same arguments as the event.
+ // See context argument comments for information on method's scope.
+ //
+ // dontFix:
+ // If obj is a DOM node, set dontFix to true to prevent delegation
+ // of this connection to the DOM event manager.
+ //
+ // example:
+ // When obj.onchange(), do ui.update():
+ // | dojo.connect(obj, "onchange", ui, "update");
+ // | dojo.connect(obj, "onchange", ui, ui.update); // same
+ //
+ // example:
+ // Using return value for disconnect:
+ // | var link = dojo.connect(obj, "onchange", ui, "update");
+ // | ...
+ // | dojo.disconnect(link);
+ //
+ // example:
+ // When onglobalevent executes, watcher.handler is invoked:
+ // | dojo.connect(null, "onglobalevent", watcher, "handler");
+ //
+ // example:
+ // When ob.onCustomEvent executes, customEventHandler is invoked:
+ // | dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+ // | dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+ //
+ // example:
+ // When ob.onCustomEvent executes, customEventHandler is invoked
+ // with the same scope (this):
+ // | dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+ // | dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+ //
+ // example:
+ // When globalEvent executes, globalHandler is invoked
+ // with the same scope (this):
+ // | dojo.connect(null, "globalEvent", null, globalHandler);
+ // | dojo.connect("globalEvent", globalHandler); // same
+
+ // normalize arguments
+ var a=arguments, args=[], i=0;
+ // if a[0] is a String, obj was ommited
+ args.push(dojo.isString(a[0]) ? null : a[i++], a[i++]);
+ // if the arg-after-next is a String or Function, context was NOT omitted
+ var a1 = a[i+1];
+ args.push(dojo.isString(a1)||dojo.isFunction(a1) ? a[i++] : null, a[i++]);
+ // absorb any additional arguments
+ for(var l=a.length; i<l; i++){ args.push(a[i]); }
+ // do the actual work
+ return dojo._connect.apply(this, args); /*Handle*/
+}
+
+// used by non-browser hostenvs. always overriden by event.js
+dojo._connect = function(obj, event, context, method){
+ var l=dojo._listener, h=l.add(obj, event, dojo.hitch(context, method));
+ return [obj, event, h, l]; // Handle
+}
+
+dojo.disconnect = function(/*Handle*/ handle){
+ // summary:
+ // Remove a link created by dojo.connect.
+ // description:
+ // Removes the connection between event and the method referenced by handle.
+ // handle:
+ // the return value of the dojo.connect call that created the connection.
+ if(handle && handle[0] !== undefined){
+ dojo._disconnect.apply(this, handle);
+ // let's not keep this reference
+ delete handle[0];
+ }
+}
+
+dojo._disconnect = function(obj, event, handle, listener){
+ listener.remove(obj, event, handle);
+}
+
+// topic publish/subscribe
+
+dojo._topics = {};
+
+dojo.subscribe = function(/*String*/ topic, /*Object|null*/ context, /*String|Function*/ method){
+ // summary:
+ // Attach a listener to a named topic. The listener function is invoked whenever the
+ // named topic is published (see: dojo.publish).
+ // Returns a handle which is needed to unsubscribe this listener.
+ // context:
+ // Scope in which method will be invoked, or null for default scope.
+ // method:
+ // The name of a function in context, or a function reference. This is the function that
+ // is invoked when topic is published.
+ // example:
+ // | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+ // | dojo.publish("alerts", [ "read this", "hello world" ]);
+
+ // support for 2 argument invocation (omitting context) depends on hitch
+ return [topic, dojo._listener.add(dojo._topics, topic, dojo.hitch(context, method))]; /*Handle*/
+}
+
+dojo.unsubscribe = function(/*Handle*/ handle){
+ // summary:
+ // Remove a topic listener.
+ // handle:
+ // The handle returned from a call to subscribe.
+ // example:
+ // | var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+ // | ...
+ // | dojo.unsubscribe(alerter);
+ if(handle){
+ dojo._listener.remove(dojo._topics, handle[0], handle[1]);
+ }
+}
+
+dojo.publish = function(/*String*/ topic, /*Array*/ args){
+ // summary:
+ // Invoke all listener method subscribed to topic.
+ // topic:
+ // The name of the topic to publish.
+ // args:
+ // An array of arguments. The arguments will be applied
+ // to each topic subscriber (as first class parameters, via apply).
+ // example:
+ // | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+ // | dojo.publish("alerts", [ "read this", "hello world" ]);
+
+ // Note that args is an array, which is more efficient vs variable length
+ // argument list. Ideally, var args would be implemented via Array
+ // throughout the APIs.
+ var f = dojo._topics[topic];
[... 5692 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org