Subversion Repositories Applications.papyrus

/*

	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"){

// TODOC: HOW TO DOC THE BELOW?

// @global: djConfig

// summary:

//		Application code can set the global 'djConfig' prior to loading

//		the library to override certain global settings for how dojo works.

// description:  The variables that can be set are as follows:

//			- isDebug: false

//			- libraryScriptUri: ""

//			- locale: undefined

//			- extraLocale: undefined

//			- preventBackButtonFix: true

// note:

//		'djConfig' does not exist under 'dojo.*' so that it can be set before the

//		'dojo' variable exists.

// note:

//		Setting any of these variables *after* the library has loaded does

//		nothing at all.

(function(){

	// make sure djConfig is defined

	if(typeof this["djConfig"] == "undefined"){

		this.djConfig = {};

	}

	// firebug stubs

	if((!this["console"])||(!console["firebug"])){

		this.console = {};

	}

	var cn = [

		"assert", "count", "debug", "dir", "dirxml", "error", "group",

		"groupEnd", "info", "log", "profile", "profileEnd", "time",

		"timeEnd", "trace", "warn"

	];

	var i=0, tn;

	while((tn=cn[i++])){

		if(!console[tn]){

			console[tn] = function(){};

		}

	}

	//TODOC:  HOW TO DOC THIS?

	// dojo is the root variable of (almost all) our public symbols -- make sure it is defined.

	if(typeof this["dojo"] == "undefined"){

		this.dojo = {};

	}

	var d = dojo;

	// summary:

	//		return the current global context object

	//		(e.g., the window object in a browser).

	// description:

	//		Refer to 'dojo.global' rather than referring to window to ensure your

	//		code runs correctly in contexts other than web browsers (eg: Rhino on a server).

	dojo.global = this;

	var _config =/*===== djConfig = =====*/{

		isDebug: false,

		libraryScriptUri: "",

		preventBackButtonFix: true,

		delayMozLoadingFix: false

	};

	for(var option in _config){

		if(typeof djConfig[option] == "undefined"){

			djConfig[option] = _config[option];

		}

	}

	var _platforms = ["Browser", "Rhino", "Spidermonkey", "Mobile"];

	var t;

	while(t=_platforms.shift()){

		d["is"+t] = false;

	}

	// Override locale setting, if specified

	dojo.locale = djConfig.locale;

	//TODOC:  HOW TO DOC THIS?

	dojo.version = {

		// summary: version number of this instance of dojo.

		major: 1, minor: 0, patch: 2, flag: "",

		revision: Number("$Rev: 11832 $".match(/[0-9]+/)[0]),

		toString: function(){

			with(d.version){

				return major + "." + minor + "." + patch + flag + " (" + revision + ")";	// String

			}

		}

	}

	// Register with the OpenAjax hub

	if(typeof OpenAjax != "undefined"){

		OpenAjax.hub.registerLibrary("dojo", "http://dojotoolkit.org", d.version.toString());

	}

	dojo._mixin = function(/*Object*/ obj, /*Object*/ props){

		// summary:

		//		Adds all properties and methods of props to obj. This addition is

		//		"prototype extension safe", so that instances of objects will not

		//		pass along prototype defaults.

		var tobj = {};

		for(var x in props){

			// the "tobj" condition avoid copying properties in "props"

			// inherited from Object.prototype.  For example, if obj has a custom

			// toString() method, don't overwrite it with the toString() method

			// that props inherited from Object.prototype

			if(tobj[x] === undefined || tobj[x] != props[x]){

				obj[x] = props[x];

			}

		}

		// IE doesn't recognize custom toStrings in for..in

		if(d["isIE"] && props){

			var p = props.toString;

			if(typeof p == "function" && p != obj.toString && p != tobj.toString &&

				p != "\nfunction toString() {\n    [native code]\n}\n"){

					obj.toString = props.toString;

			}

		}

		return obj; // Object

	}

	dojo.mixin = function(/*Object*/obj, /*Object...*/props){

		// summary:	Adds all properties and methods of props to obj.

		for(var i=1, l=arguments.length; i<l; i++){

			d._mixin(obj, arguments[i]);

		}

		return obj; // Object

	}

	dojo._getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){

		var obj=context||d.global;

		for(var i=0, p; obj&&(p=parts[i]); i++){

			obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined));

		}

		return obj; // mixed

	}

	dojo.setObject = function(/*String*/name, /*mixed*/value, /*Object*/context){

		// summary:

		//		Set a property from a dot-separated string, such as "A.B.C"

		//	description:

		//		Useful for longer api chains where you have to test each object in

		//		the chain, or when you have an object reference in string format.

		//		Objects are created as needed along 'path'.

		//	name:

		//		Path to a property, in the form "A.B.C".

		//	context:

		//		Optional. Object to use as root of path. Defaults to

		//		'dojo.global'. Null may be passed.

		var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context);

		return (obj && p ? (obj[p]=value) : undefined); // mixed

	}

	dojo.getObject = function(/*String*/name, /*Boolean*/create, /*Object*/context){

		// summary:

		//		Get a property from a dot-separated string, such as "A.B.C"

		//	description:

		//		Useful for longer api chains where you have to test each object in

		//		the chain, or when you have an object reference in string format.

		//	name:

		//		Path to an property, in the form "A.B.C".

		//	context:

		//		Optional. Object to use as root of path. Defaults to

		//		'dojo.global'. Null may be passed.

		//	create:

		//		Optional. If true, Objects will be created at any point along the

		//		'path' that is undefined.

		return d._getProp(name.split("."), create, context); // mixed

	}

	dojo.exists = function(/*String*/name, /*Object?*/obj){

		// summary:

		//		determine if an object supports a given method

		// description:

		//		useful for longer api chains where you have to test each object in

		//		the chain

		// name:

		//		Path to an object, in the form "A.B.C".

		// obj:

		//		Object to use as root of path. Defaults to

		//		'dojo.global'. Null may be passed.

		return !!d.getObject(name, false, obj); // Boolean

	}

	dojo["eval"] = function(/*String*/ scriptFragment){

		// summary:

		//		Perform an evaluation in the global scope.  Use this rather than

		//		calling 'eval()' directly.

		// description:

		//		Placed in a separate function to minimize size of trapped

		//		evaluation context.

		// note:

		//	 - JSC eval() takes an optional second argument which can be 'unsafe'.

		//	 - Mozilla/SpiderMonkey eval() takes an optional second argument which is the

		//  	 scope object for new symbols.

		// FIXME: investigate Joseph Smarr's technique for IE:

		//		http://josephsmarr.com/2007/01/31/fixing-eval-to-use-global-scope-in-ie/

		//	see also:

		// 		http://trac.dojotoolkit.org/ticket/744

		return d.global.eval ? d.global.eval(scriptFragment) : eval(scriptFragment); 	// mixed

	}

	/*=====

		dojo.deprecated = function(behaviour, extra, removal){

			//	summary:

			//		Log a debug message to indicate that a behavior has been

			//		deprecated.

			//	behaviour: String

			//		The API or behavior being deprecated. Usually in the form

			//		of "myApp.someFunction()".

			//	extra: String?

			//		Text to append to the message. Often provides advice on a

			//		new function or facility to achieve the same goal during

			//		the deprecation period.

			//	removal: String?

			//		Text to indicate when in the future the behavior will be

			//		removed. Usually a version number.

			//	example:

			//	|	dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");

		}

		dojo.experimental = function(moduleName, extra){

			//	summary: Marks code as experimental.

			//	description:

			//	 	This can be used to mark a function, file, or module as

			//	 	experimental.  Experimental code is not ready to be used, and the

			//	 	APIs are subject to change without notice.  Experimental code may be

			//	 	completed deleted without going through the normal deprecation

			//	 	process.

			//	moduleName: String

			//	 	The name of a module, or the name of a module file or a specific

			//	 	function

			//	extra: String?

			//	 	some additional message for the user

			//	example:

			//	|	dojo.experimental("dojo.data.Result");

			//	example:

			//	|	dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");

		}

	=====*/

	//Real functions declared in dojo._firebug.firebug.

	d.deprecated = d.experimental = function(){};

})();

// vim:ai:ts=4:noet

/*

 * 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

	});

		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

	}

	// FIXME: probably need to add logging to this method

	dojo._loadUriAndCheck = function(/*String (URL)*/uri, /*String*/moduleName, /*Function?*/cb){

		// summary: calls loadUri then findModule and returns true if both succeed

		var ok = false;

		try{

			ok = this._loadUri(uri, cb);

		}catch(e){

			console.debug("failed loading " + uri + " with error: " + e);

		}

		return Boolean(ok && this._loadedModules[moduleName]); // Boolean

	}

	dojo.loaded = function(){

		// summary:

		//		signal fired when initial environment and package loading is

		//		complete. You may use dojo.addOnLoad() or dojo.connect() to

		//		this method in order to handle initialization tasks that

		//		require the environment to be initialized. In a browser host,

		//		declarative widgets will be constructed when this function

		//		finishes runing.

		this._loadNotifying = true;

		this._postLoad = true;

		var mll = this._loaders;

		//Clear listeners so new ones can be added

		//For other xdomain package loads after the initial load.

		this._loaders = [];

		for(var x=0; x<mll.length; x++){

			mll[x]();

		}

		this._loadNotifying = false;

		//Make sure nothing else got added to the onload queue

		//after this first run. If something did, and we are not waiting for any

		//more inflight resources, run again.

		if(d._postLoad && d._inFlightCount == 0 && this._loaders.length > 0){

			d._callLoaded();

		}

	}

	dojo.unloaded = function(){

		// summary:

		//		signal fired by impending environment destruction. You may use

		//		dojo.addOnUnload() or dojo.connect() to this method to perform

		//		page/application cleanup methods.

		var mll = this._unloaders;

		while(mll.length){

			(mll.pop())();

		}

	}

	dojo.addOnLoad = function(/*Object?*/obj, /*String|Function*/functionName){

		// summary:

		//		Registers a function to be triggered after the DOM has finished

		//		loading and widgets declared in markup have been instantiated.

		//		Images and CSS files may or may not have finished downloading when

		//		the specified function is called.  (Note that widgets' CSS and HTML

		//		code is guaranteed to be downloaded before said widgets are

		//		instantiated.)

		// example:

		//	|	dojo.addOnLoad(functionPointer);

		//	|	dojo.addOnLoad(object, "functionName");

		if(arguments.length == 1){

			d._loaders.push(obj);

		}else if(arguments.length > 1){

			d._loaders.push(function(){

				obj[functionName]();

			});

		}

		//Added for xdomain loading. dojo.addOnLoad is used to

		//indicate callbacks after doing some dojo.require() statements.

		//In the xdomain case, if all the requires are loaded (after initial

		//page load), then immediately call any listeners.

		if(d._postLoad && d._inFlightCount == 0 && !d._loadNotifying){

			d._callLoaded();

		}

	}

	dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){

		// summary: registers a function to be triggered when the page unloads

		// example:

		//	|	dojo.addOnUnload(functionPointer)

		//	|	dojo.addOnUnload(object, "functionName")

		if(arguments.length == 1){

			d._unloaders.push(obj);

		}else if(arguments.length > 1){

			d._unloaders.push(function(){

				obj[functionName]();

			});

		}

	}

	dojo._modulesLoaded = function(){

		if(d._postLoad){ return; }

		if(d._inFlightCount > 0){

			console.debug("files still in flight!");

			return;

		}

		d._callLoaded();

	}

	dojo._callLoaded = function(){

		//The "object" check is for IE, and the other opera check fixes an issue

		//in Opera where it could not find the body element in some widget test cases.

		//For 0.9, maybe route all browsers through the setTimeout (need protection

		//still for non-browser environments though). This might also help the issue with

		//FF 2.0 and freezing issues where we try to do sync xhr while background css images

		//are being loaded (trac #2572)? Consider for 0.9.

		if(typeof setTimeout == "object" || (djConfig["useXDomain"] && d.isOpera)){

			setTimeout("dojo.loaded();", 0);

		}else{

			d.loaded();

		}

	}

	dojo._getModuleSymbols = function(/*String*/modulename){

		// summary:

		//		Converts a module name in dotted JS notation to an array

		//		representing the path in the source tree

		var syms = modulename.split(".");

		for(var i = syms.length; i>0; i--){

			var parentModule = syms.slice(0, i).join(".");

			if((i==1) && !this._moduleHasPrefix(parentModule)){

				// Support default module directory (sibling of dojo) for top-level modules

				syms[0] = "../" + syms[0];

			}else{

				var parentModulePath = this._getModulePrefix(parentModule);

				if(parentModulePath != parentModule){

					syms.splice(0, i, parentModulePath);

					break;

				}

			}

		}

		// console.debug(syms);

		return syms; // Array

	}

	dojo._global_omit_module_check = false;

	dojo._loadModule = dojo.require = function(/*String*/moduleName, /*Boolean?*/omitModuleCheck){

		//	summary:

		//		loads a Javascript module from the appropriate URI

		//	moduleName: String

		//	omitModuleCheck: Boolean?

		//	description:

		//		_loadModule("A.B") first checks to see if symbol A.B is defined. If

		//		it is, it is simply returned (nothing to do).

		//

		//		If it is not defined, it will look for "A/B.js" in the script root

		//		directory.

		//

		//		It throws if it cannot find a file to load, or if the symbol A.B is

		//		not defined after loading.

		//

		//		It returns the object A.B.

		//

		//		This does nothing about importing symbols into the current package.

		//		It is presumed that the caller will take care of that. For example,

		//		to import all symbols:

		//

		//		|	with (dojo._loadModule("A.B")) {

		//		|		...

		//		|	}

		//

		//		And to import just the leaf symbol:

		//

		//		|	var B = dojo._loadModule("A.B");

		//	   	|	...

		//	returns: the required namespace object

		omitModuleCheck = this._global_omit_module_check || omitModuleCheck;

		var module = this._loadedModules[moduleName];

		if(module){

			return module;

		}

		// convert periods to slashes

		var relpath = this._getModuleSymbols(moduleName).join("/") + '.js';

		var modArg = (!omitModuleCheck) ? moduleName : null;

		var ok = this._loadPath(relpath, modArg);

		if((!ok)&&(!omitModuleCheck)){

			throw new Error("Could not load '" + moduleName + "'; last tried '" + relpath + "'");

		}

		// check that the symbol was defined

		// Don't bother if we're doing xdomain (asynchronous) loading.

		if((!omitModuleCheck)&&(!this["_isXDomain"])){

			// pass in false so we can give better error

			module = this._loadedModules[moduleName];

			if(!module){

				throw new Error("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'");

			}

		}

		return module;

	}

	dojo.provide = function(/*String*/ resourceName){

		//	summary:

		//		Each javascript source file must have (exactly) one dojo.provide()

		//		call at the top of the file, corresponding to the file name.

		//		For example, js/dojo/foo.js must have dojo.provide("dojo.foo"); at the

		//		top of the file.

		//	description:

		//		Each javascript source file is called a resource.  When a resource

		//		is loaded by the browser, dojo.provide() registers that it has been

		//		loaded.

		//

		//		For backwards compatibility reasons, in addition to registering the

		//		resource, dojo.provide() also ensures that the javascript object

		//		for the module exists.  For example,

		//		dojo.provide("dojo.io.cometd"), in addition to registering that

		//		cometd.js is a resource for the dojo.iomodule, will ensure that

		//		the dojo.io javascript object exists, so that calls like

		//		dojo.io.foo = function(){ ... } don't fail.

		//

		//		In the case of a build (or in the future, a rollup), where multiple

		//		javascript source files are combined into one bigger file (similar

		//		to a .lib or .jar file), that file will contain multiple

		//		dojo.provide() calls, to note that it includes multiple resources.

		//Make sure we have a string.

		resourceName = resourceName + "";

		return (d._loadedModules[resourceName] = d.getObject(resourceName, true)); // Object

	}

	//Start of old bootstrap2:

	dojo.platformRequire = function(/*Object containing Arrays*/modMap){

		//	description:

		//		This method taks a "map" of arrays which one can use to optionally

		//		load dojo modules. The map is indexed by the possible

		//		dojo.name_ values, with two additional values: "default"

		//		and "common". The items in the "default" array will be loaded if

		//		none of the other items have been choosen based on the

		//		hostenv.name_ item. The items in the "common" array will _always_

		//		be loaded, regardless of which list is chosen.  Here's how it's

		//		normally called:

		//

		//		|	dojo.platformRequire({

		//		|		// an example that passes multiple args to _loadModule()

		//		|		browser: [

		//		|			["foo.bar.baz", true, true],

		//		|			"foo.sample",

		//		|			"foo.test,

		//		|		],

		//		|		default: [ "foo.sample.*" ],

		//		|		common: [ "really.important.module.*" ]

		//		|	});

		// FIXME: dojo.name_ no longer works!!

		var common = modMap["common"]||[];

		var result = common.concat(modMap[d._name]||modMap["default"]||[]);

		for(var x=0; x<result.length; x++){

			var curr = result[x];

			if(curr.constructor == Array){

				d._loadModule.apply(d, curr);

			}else{

				d._loadModule(curr);

			}

		}

	}

	dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){

		// summary:

		//		If the condition is true then call dojo.require() for the specified

		//		resource

		if(condition === true){

			// FIXME: why do we support chained require()'s here? does the build system?

			var args = [];

			for(var i = 1; i < arguments.length; i++){

				args.push(arguments[i]);

			}

			d.require.apply(d, args);

		}

	}

	dojo.requireAfterIf = d.requireIf;

	dojo.registerModulePath = function(/*String*/module, /*String*/prefix){

		//	summary:

		//		maps a module name to a path

		//	description:

		//		An unregistered module is given the default path of ../<module>,

		//		relative to Dojo root. For example, module acme is mapped to

		//		../acme.  If you want to use a different module name, use

		//		dojo.registerModulePath.

		d._modulePrefixes[module] = { name: module, value: prefix };

	}

	dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){

		// summary:

		//		Declares translated resources and loads them if necessary, in the

		//		same style as dojo.require.  Contents of the resource bundle are

		//		typically strings, but may be any name/value pair, represented in

		//		JSON format.  See also dojo.i18n.getLocalization.

		// moduleName:

		//		name of the package containing the "nls" directory in which the

		//		bundle is found

		// bundleName:

		//		bundle name, i.e. the filename without the '.js' suffix

		// locale:

		//		the locale to load (optional)  By default, the browser's user

		//		locale as defined by dojo.locale

		// availableFlatLocales:

		//		A comma-separated list of the available, flattened locales for this

		//		bundle. This argument should only be set by the build process.

		// description:

		//		Load translated resource bundles provided underneath the "nls"

		//		directory within a package.  Translated resources may be located in

		//		different packages throughout the source tree.  For example, a

		//		particular widget may define one or more resource bundles,

		//		structured in a program as follows, where moduleName is

		//		mycode.mywidget and bundleNames available include bundleone and

		//		bundletwo:

		//

		//			...

		//			mycode/

		//			 mywidget/

		//			  nls/

		//			   bundleone.js (the fallback translation, English in this example)

		//			   bundletwo.js (also a fallback translation)

		//			   de/

		//			    bundleone.js

		//			    bundletwo.js

		//			   de-at/

		//			    bundleone.js

		//			   en/

		//			    (empty; use the fallback translation)

		//			   en-us/

		//			    bundleone.js

		//			   en-gb/

		//			    bundleone.js

		//			   es/

		//			    bundleone.js

		//			    bundletwo.js

		//			  ...etc

		//			...

		//

		//		Each directory is named for a locale as specified by RFC 3066,

		//		(http://www.ietf.org/rfc/rfc3066.txt), normalized in lowercase.

		//		Note that the two bundles in the example do not define all the same

		//		variants.  For a given locale, bundles will be loaded for that

		//		locale and all more general locales above it, including a fallback

		//		at the root directory.  For example, a declaration for the "de-at"

		//		locale will first load nls/de-at/bundleone.js, then

		//		nls/de/bundleone.js and finally nls/bundleone.js.  The data will be

		//		flattened into a single Object so that lookups will follow this

		//		cascading pattern.  An optional build step can preload the bundles

		//		to avoid data redundancy and the multiple network hits normally

		//		required to load these resources.

		d.require("dojo.i18n");

		d.i18n._requireLocalization.apply(d.hostenv, arguments);

	};

	var ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$");

	var ire = new RegExp("^((([^:]+:)?([^@]+))@)?([^:]*)(:([0-9]+))?$");

	dojo._Url = function(/*dojo._Url||String...*/){

		// summary:

		//		Constructor to create an object representing a URL.

		//		It is marked as private, since we might consider removing

		//		or simplifying it.

		// description:

		//		Each argument is evaluated in order relative to the next until

		//		a canonical uri is produced. To get an absolute Uri relative to

		//		the current document use:

		//      	new dojo._Url(document.baseURI, url)

		var n = null;

		// TODO: support for IPv6, see RFC 2732

		var _a = arguments;

		var uri = _a[0];

		// resolve uri components relative to each other

		for(var i = 1; i<_a.length; i++){

			if(!_a[i]){ continue; }

			// Safari doesn't support this.constructor so we have to be explicit

			// FIXME: Tracked (and fixed) in Webkit bug 3537.

			//		http://bugs.webkit.org/show_bug.cgi?id=3537

			var relobj = new d._Url(_a[i]+"");

			var uriobj = new d._Url(uri+"");

			if(

				(relobj.path=="")	&&

				(!relobj.scheme)	&&

				(!relobj.authority)	&&

				(!relobj.query)

			){

				if(relobj.fragment != n){

					uriobj.fragment = relobj.fragment;

				}

				relobj = uriobj;

			}else if(!relobj.scheme){

				relobj.scheme = uriobj.scheme;

				if(!relobj.authority){

					relobj.authority = uriobj.authority;

					if(relobj.path.charAt(0) != "/"){

						var path = uriobj.path.substring(0,

							uriobj.path.lastIndexOf("/") + 1) + relobj.path;

						var segs = path.split("/");

						for(var j = 0; j < segs.length; j++){

							if(segs[j] == "."){

								if(j == segs.length - 1){

									segs[j] = "";

								}else{

									segs.splice(j, 1);

									j--;

								}

							}else if(j > 0 && !(j == 1 && segs[0] == "") &&

								segs[j] == ".." && segs[j-1] != ".."){

								if(j == (segs.length - 1)){

									segs.splice(j, 1);

									segs[j - 1] = "";

								}else{

									segs.splice(j - 1, 2);

									j -= 2;

								}

							}

						}

						relobj.path = segs.join("/");

					}

				}

			}

			uri = "";

			if(relobj.scheme){

				uri += relobj.scheme + ":";

			}

			if(relobj.authority){

				uri += "//" + relobj.authority;

			}

			uri += relobj.path;

			if(relobj.query){

				uri += "?" + relobj.query;

			}

			if(relobj.fragment){

				uri += "#" + relobj.fragment;

			}

		}

		this.uri = uri.toString();

		// break the uri into its main components

		var r = this.uri.match(ore);

		this.scheme = r[2] || (r[1] ? "" : n);

		this.authority = r[4] || (r[3] ? "" : n);

		this.path = r[5]; // can never be undefined

		this.query = r[7] || (r[6] ? "" : n);

		this.fragment  = r[9] || (r[8] ? "" : n);

		if(this.authority != n){

			// server based naming authority

			r = this.authority.match(ire);

			this.user = r[3] || n;

			this.password = r[4] || n;

			this.host = r[5];

			this.port = r[7] || n;

		}

	}

	dojo._Url.prototype.toString = function(){ return this.uri; };

	dojo.moduleUrl = function(/*String*/module, /*dojo._Url||String*/url){

		// summary:

		//		Returns a Url object relative to a module

		//

		// example:

		//	|	dojo.moduleUrl("dojo.widget","templates/template.html");

		// example:

		//	|	dojo.moduleUrl("acme","images/small.png")

		var loc = dojo._getModuleSymbols(module).join('/');

		if(!loc){ return null; }

		if(loc.lastIndexOf("/") != loc.length-1){

			loc += "/";

		}

		//If the path is an absolute path (starts with a / or is on another

		//domain/xdomain) then don't add the baseUrl.

		var colonIndex = loc.indexOf(":");

		if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > loc.indexOf("/"))){

			loc = d.baseUrl + loc;

		}

		return new d._Url(loc, url); // String

	}

})();

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