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 + "'"); 			}		}