Quelle  dojo.js   Sprache: JAVA

/*
Copyright (c) 2004-2008, The Dojo Foundation All Rights Reserved.
Available via Academic Free License >= 2.1 OR the modified BSD license.
see: http://dojotoolkit.org/license for details
*/

/*
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.
*/

;(function(){

 /*
dojo, dijit, and dojox must always be the first three, and in that order.
djConfig.scopeMap = [
["dojo", "fojo"],
["dijit", "fijit"],
["dojox", "fojox"]

]
*/

 /**Build will replace this comment with a scoped djConfig **/

 //The null below can be relaced by a build-time value used instead of djConfig.scopeMap.
 var sMap = null;

 //See if new scopes need to be defined.
 if((sMap || (typeof djConfig != "undefined" && djConfig.scopeMap)) && (typeof window != "undefined")){
  var scopeDef = "", scopePrefix = "", scopeSuffix = "", scopeMap = {}, scopeMapRev = {};
  sMap = sMap || djConfig.scopeMap;
  for(var i = 0; i < sMap.length; i++){
   //Make local variables, then global variables that use the locals.
   var newScope = sMap[i];
   scopeDef += "var " + newScope[0] + " = {}; " + newScope[1] + " = " + newScope[0] + ";" + newScope[1] + "._scopeName = '" + newScope[1] + "';";
   scopePrefix += (i == 0 ? "" : ",") + newScope[0];
   scopeSuffix += (i == 0 ? "" : ",") + newScope[1];
   scopeMap[newScope[0]] = newScope[1];
   scopeMapRev[newScope[1]] = newScope[0];
  }

  eval(scopeDef + "dojo._scopeArgs = [" + scopeSuffix + "];");

  dojo._scopePrefixArgs = scopePrefix;
  dojo._scopePrefix = "(function(" + scopePrefix + "){";
  dojo._scopeSuffix = "})(" + scopeSuffix + ")";
  dojo._scopeMap = scopeMap;
  dojo._scopeMapRev = scopeMapRev;
 }

/*=====
// 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.

djConfig = {
// summary:
// Application code can set the global 'djConfig' prior to loading
// the library to override certain global settings for how dojo works.
//
// isDebug: Boolean
// Defaults to `false`. If set to `true`, ensures that Dojo provides
// extended debugging feedback via Firebug. If Firebug is not available
// on your platform, setting `isDebug` to `true` will force Dojo to
// pull in (and display) the version of Firebug Lite which is
// integrated into the Dojo distribution, thereby always providing a
// debugging/logging console when `isDebug` is enabled. Note that
// Firebug's `console.*` methods are ALWAYS defined by Dojo. If
// `isDebug` is false and you are on a platform without Firebug, these
// methods will be defined as no-ops.
isDebug: false,
// debugAtAllCosts: Boolean
// Defaults to `false`. If set to `true`, this triggers an alternate
// mode of the package system in which dependencies are detected and
// only then are resources evaluated in dependency order via
// `<script>` tag inclusion. This may double-request resources and
// cause problems with scripts which expect `dojo.require()` to
// preform synchronously. `debugAtAllCosts` can be an invaluable
// debugging aid, but when using it, ensure that all code which
// depends on Dojo modules is wrapped in `dojo.addOnLoad()` handlers.
// Due to the somewhat unpredictable side-effects of using
// `debugAtAllCosts`, it is strongly recommended that you enable this
// flag as a last resort. `debugAtAllCosts` has no effect when loading
// resources across domains. For usage information, see the
// [Dojo Book](http://dojotoolkit.org/book/book-dojo/part-4-meta-dojo-making-your-dojo-code-run-faster-and-better/debugging-facilities/deb)
debugAtAllCosts: false,
// locale: String
// The locale to assume for loading localized resources in this page,
// specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
// Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
// See the documentation for `dojo.i18n` and `dojo.requireLocalization`
// for details on loading localized resources. If no locale is specified,
// Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
// or `navigator.language` properties.
locale: undefined,
// extraLocale: Array
// No default value. Specifies additional locales whose
// resources should also be loaded alongside the default locale when
// calls to `dojo.requireLocalization()` are processed.
extraLocale: undefined,
// baseUrl: String
// The directory in which `dojo.js` is located. Under normal
// conditions, Dojo auto-detects the correct location from which it
// was loaded. You may need to manually configure `baseUrl` in cases
// where you have renamed `dojo.js` or in which `<base>` tags confuse
// some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
// either the value of `djConfig.baseUrl` if one is provided or the
// auto-detected root if not. Other modules are located relative to
// this path.
baseUrl: undefined,
// modulePaths: Object
// A map of module names to paths relative to `dojo.baseUrl`. The
// key/value pairs correspond directly to the arguments which
// `dojo.registerModulePath` accepts. Specifiying
// `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
// of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
// modules may be configured via `djConfig.modulePaths`.
modulePaths: {},
// afterOnLoad: Boolean 
// Indicates Dojo was added to the page after the page load. In this case
// Dojo will not wait for the page DOMContentLoad/load events and fire
// its dojo.addOnLoad callbacks after making sure all outstanding
// dojo.required modules have loaded.
afterOnLoad: false,
// addOnLoad: Function or Array
// Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
// the page loads and djConfig.afterOnLoad is true. Supports the same
// arguments as dojo.addOnLoad. When using a function reference, use
// `djConfig.addOnLoad = function(){};`. For object with function name use
// `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
// function reference use
// `djConfig.addOnLoad = [myObject, function(){}];`
addOnLoad: null,
// require: Array
// An array of module names to be loaded immediately after dojo.js has been included
// in a page. 
require: []
}
=====*/

(function(){
// firebug stubs

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

if(!this["console"]){
this.console = {
};
}

// Be careful to leave 'log' always at the end
var cn = [
"assert", "count", "debug", "dir", "dirxml", "error", "group",
"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
"trace", "warn", "log" 
];
var i=0, tn;
while((tn=cn[i++])){
if(!console[tn]){
(function(){
var tcn = tn+"";
console[tcn] = ('log' in console) ? function(){ 
var a = Array.apply({}, arguments);
a.unshift(tcn+":");
console["log"](a.join(" "));
} : function(){}
})();
}
}

//TODOC:  HOW TO DOC THIS?
// dojo is the root variable of (almost all) our public symbols -- make sure it is defined.
if(typeof dojo == "undefined"){
this.dojo = {
_scopeName: "dojo",
_scopePrefix: "",
_scopePrefixArgs: "",
_scopeSuffix: "",
_scopeMap: {},
_scopeMapRev: {}
};
}

var d = dojo;

//Need placeholders for dijit and dojox for scoping code.
if(typeof dijit == "undefined"){
this.dijit = {_scopeName: "dijit"};
}
if(typeof dojox == "undefined"){
this.dojox = {_scopeName: "dojox"};
}

if(!d._scopeArgs){
d._scopeArgs = [dojo, dijit, dojox];
}

/*=====
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).
}
=====*/
d.global = this;

d.config =/*===== djConfig = =====*/{
isDebug: false,
debugAtAllCosts: false
};

if(typeof djConfig != "undefined"){
for(var opt in djConfig){
d.config[opt] = djConfig[opt];
}
}

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 = d.config.locale;

var rev = "$Rev: 15729 $".match(/\d+/);

dojo.version = {
// summary: 
// version number of dojo
// major: Integer
// Major version. If total version is "1.2.0beta1", will be 1
// minor: Integer
// Minor version. If total version is "1.2.0beta1", will be 2
// patch: Integer
// Patch version. If total version is "1.2.0beta1", will be 0
// flag: String
// Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
// revision: Number
// The SVN rev from which dojo was pulled
major: 1, minor: 2, patch: 2, flag: "",
revision: rev ? +rev[0] : 999999, //FIXME: use NaN?
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._scopeName, "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 and returns the
// (now modified) obj.
// description:
// `dojo.mixin` can mix multiple source objects into a
// destionation object which is then returned. Unlike regular
// `for...in` iteration, `dojo.mixin` is also smart about avoiding
// extensions which other toolkits may unwisely add to the root
// object prototype
// obj:
// The object to mix properties into. Also the return value.
// props:
// One or more objects whose values are successively copied into
// obj. If more than one of these objects contain the same value,
// the one specified last in the function call will "win".
// example:
// make a shallow copy of an object
// | var copy = dojo.mixin({}, source);
// example:
// many class constructors often take an object which specifies
// values to be configured on the object. In this case, it is
// often simplest to call `dojo.mixin` on the `this` object:
// | dojo.declare("acme.Base", null, {
// | constructor: function(properties){
// | // property configuration:
// | dojo.mixin(this, properties);
// |
// |
// | //  ...
// | },
// | quip: "I wasn't born yesterday, you know - I've seen movies.",
// | // ...
// | });
// |
// | // create an instance of the class and configure it
// | var b = new acme.Base({quip: "That's what it does!" });
// example:
// copy in properties from multiple objects
// | var flattened = dojo.mixin(
// | {
// | name: "Frylock",
// | braces: true
// | },
// | {
// | name: "Carl Brutanananadilewski"
// | }
// | );
// |
// | // will print "Carl Brutanananadilewski"
// |
// | // will print "true"
// |
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++){
if(i == 0 && this._scopeMap[p]){
p = this._scopeMap[p];
}
obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined));
}
return obj; // mixed
}

dojo.setObject = function(/*String*/name, /*Object*/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`. Returns the passed
// value if setting is successful or `undefined` if not.
// name: 
// Path to a property, in the form "A.B.C".
// context:
// Optional. Object to use as root of path. Defaults to
// `dojo.global`.
// example:
// set the value of `foo.bar.baz`, regardless of whether
// intermediate objects already exist:
// | dojo.setObject("foo.bar.baz", value);
// example:
// without `dojo.setObject`, we often see code like this:
// | // ensure that intermediate objects are available
// | if(!obj["parent"]){ obj.parent = {}; }
// | if(!obj.parent["child"]){ obj.parent.child= {}; }
// | // now we can safely set the property
// | obj.parent.child.prop = "some value";
// wheras with `dojo.setObject`, we can shorten that to:
// | dojo.setObject("parent.child.prop", "some value", obj);
var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context);
return obj && p ? (obj[p]=value) : undefined; // Object
}

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. Defaults to `false`. If `true`, Objects will be
// created at any point along the 'path' that is undefined.
return d._getProp(name.split("."), create, context); // Object
}

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.
// example:
// | // define an object
// | var foo = {
// | bar: { }
// | };
// |
// | // search the global scope
// | dojo.exists("foo.bar"); // true
// | dojo.exists("foo.bar.baz"); // false
// |
// | // search from a particular scope
// | dojo.exists("bar", foo); // true
// | dojo.exists("bar.baz", foo); // false
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
// exceptions. Calling eval() directly from some other scope may
// complicate tracebacks on some platforms.
// returns:
// The result of the evaluation. Often `undefined`


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

/*=====
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: {},

_modulePrefixes: {
dojo:  { name: "dojo", value: "." },
// dojox:  { name: "dojox", value: "../dojox" },
// dijit:  { name: "dijit", value: "../dijit" },
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;
try{
return !module ? this._loadUri(uri, cb) : this._loadUriAndCheck(uri, module, cb); // Boolean
}catch(e){
console.error(e);
return false; // Boolean
}
}

dojo._loadUri = function(/*String*/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+')';
}else{
//Only do the scoping if no callback. If a callback is specified,
//it is most likely the i18n bundle stuff.
contents = this._scopePrefix + contents + this._scopeSuffix;
}
if(d.isMoz){ contents += "\r\n//@ sourceURL=" + uri; } // debugging assist for Firebug
var value = d["eval"](contents);
if(cb){ cb(value); }
return true; // Boolean
}

// FIXME: probably need to add logging to this method
dojo._loadUriAndCheck = function(/*String*/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 = d._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 && mll.length){
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. See dojo.addOnUnload for more info.
var mll = this._unloaders;
while(mll.length){
(mll.pop())();
}
}

d._onto = function(arr, obj, fn){
if(!fn){
arr.push(obj);
}else if(fn){
var func = (typeof fn == "string") ? obj[fn] : fn;
arr.push(function(){ func.call(obj); });
}
}

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");
// | dojo.addOnLoad(object, function(){ /* ... */});

d._onto(d._loaders, 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();
}
}

//Support calling dojo.addOnLoad via djConfig.addOnLoad. Support all the
//call permutations of dojo.addOnLoad. Mainly useful when dojo is added
//to the page after the page has loaded.
var dca = d.config.addOnLoad;
if(dca){
d.addOnLoad[(dca instanceof Array ? "apply" : "call")](d, dca);
}

dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
// summary:
// registers a function to be triggered when the page unloads. In a browser
// enviroment, the functions will be triggered during the window.onbeforeunload
// event. Be careful doing work during window.onbeforeunload. onbeforeunload
// can be triggered if a link to download a file is clicked, or if the link is a
// javascript: link. In these cases, the onbeforeunload event fires, but the
// document is not actually destroyed. So be careful about doing destructive
// operations in a dojo.addOnUnload callback.
// example:
// | dojo.addOnUnload(functionPointer)
// | dojo.addOnUnload(object, "functionName")
// | dojo.addOnUnload(object, function(){ /* ... */});

d._onto(d._unloaders, 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" || (dojo.config.useXDomain && d.isOpera)){
if(dojo.isAIR){
setTimeout(function(){dojo.loaded();}, 0);
}else{
setTimeout(dojo._scopeName + ".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;
}
}
}
// 
return syms; // Array
}

dojo._global_omit_module_check = false;

dojo.loadInit = function(/*Function*/init){
// summary:
// Executes a function that needs to be executed for the loader's dojo.requireIf
// resolutions to work. This is needed mostly for the xdomain loader case where
// a function needs to be executed to set up the possible values for a dojo.requireIf
// call.
// init:
// a function reference. Executed immediately.
// description: This function is mainly a marker for the xdomain loader to know parts of
// code that needs be executed outside the function wrappper that is placed around modules.
// The init function could be executed more than once, and it should make no assumptions
// on what is loaded, or what modules are available. Only the functionality in Dojo Base
// is allowed to be used. Avoid using this method. For a valid use case,
// see the source for dojox.gfx.
init();
}

dojo._loadModule = dojo.require = function(/*String*/moduleName, /*Boolean?*/omitModuleCheck){
// summary:
// loads a Javascript module from the appropriate URI
// moduleName:
// module name to load, using periods for separators,
//  e.g. "dojo.date.locale".  Module paths are de-referenced by dojo's
// internal mapping of locations to names and are disambiguated by
// longest prefix. See `dojo.registerModulePath()` for details on
// registering new modules.
// omitModuleCheck:
// if `true`, omitModuleCheck skips the step of ensuring that the
// loaded file actually defines the symbol it is referenced by.
// For example if it called as `dojo.require("a.b.c")` and the
// file located at `a/b/c.js` does not define an object `a.b.c`,
// and exception will be throws whereas no exception is raised
// when called as `dojo.require("a.b.c", true)`
// description:
// `dojo.require("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.
//
// `dojo.require` throws an excpetion 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`.
//
// `dojo.require()` does nothing about importing symbols into
// the current namespace.  It is presumed that the caller will
// take care of that. For example, to import all symbols into a
// local block, you might write:
//
// | with (dojo.require("A.B")) {
// | ...
// | }
//
// And to import just the leaf symbol to a local variable:
//
// | var B = dojo.require("A.B");
//     | ...
// returns: the required namespace object
omitModuleCheck = this._global_omit_module_check || omitModuleCheck;

//Check if it is already loaded.
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 at least 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");` before any calls to
// `dojo.require()` are made.
// 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("dojox.data.FlickrStore")`, in addition to
// registering that `FlickrStore.js` is a resource for the
// `dojox.data` module, will ensure that the `dojox.data`
// javascript object exists, so that calls like 
// `dojo.data.foo = function(){ ... }` don't fail.
//
// In the case of a build where multiple javascript source files
// are combined into one bigger file (similar to a .lib or .jar
// file), that file may 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*/modMap){
// summary:
// require one or more modules based on which host environment
// Dojo is currently operating in
// description:
// This method takes 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
// dojo.name_, set by your host environment. The items in the
// "common" array will *always* be loaded, regardless of which
// list is chosen.
// example:
// | dojo.platformRequire({
// | browser: [
// | "foo.sample", // simple module
// | "foo.test",
// | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
// | ],
// | default: [ "foo.sample._base" ],
// | common: [ "important.module.common" ]
// | });

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. 
// example:
// If your dojo.js is located at this location in the web root:
// | /myapp/js/dojo/dojo/dojo.js
// and your modules are located at:
// | /myapp/js/foo/bar.js
// | /myapp/js/foo/baz.js
// | /myapp/js/foo/thud/xyzzy.js
// Your application can tell Dojo to locate the "foo" namespace by calling:
// | dojo.registerModulePath("foo", "../../foo");
// At which point you can then use dojo.require() to load the
// modules (assuming they provide() the same things which are
// required). The full code might be:
// | <script type="text/javascript" 
// | src="/myapp/js/dojo/dojo/dojo.js"></script>
// | <script type="text/javascript">
// | dojo.registerModulePath("foo", "../../foo");
// | dojo.require("foo.bar");
// | dojo.require("foo.baz");
// | dojo.require("foo.thud.xyzzy");
// | </script>
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`.
//
// 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.  
//
// 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.
//
// 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.
//
// 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
// | ...
//

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;

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[0]+"");

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] == "."){
// flatten "./" references
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] != ".."){
// flatten "../" references
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.push(relobj.scheme, ":");
}
if(relobj.authority){
uri.push("//", relobj.authority);
}
uri.push(relobj.path);
if(relobj.query){
uri.push("?", relobj.query);
}
if(relobj.fragment){
uri.push("#", relobj.fragment);
}
}

this.uri = uri.join("");

// 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[6] || r[7]; // ipv6 || ipv4
this.port = r[9] || n;
}
}

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

dojo.moduleUrl = function(/*String*/module, /*dojo._Url||String*/url){
// summary: 
// Returns a `dojo._Url` object relative to a module.
// example:
// | var pngPath = dojo.moduleUrl("acme","images/small.png");
// |  // list the object properties
// | // create an image and set it's source to pngPath's value:
// | var img = document.createElement("img");
//  | // NOTE: we assign the string representation of the url object
// | img.src = pngPath.toString(); 
// | // add our image to the document
// | dojo.body().appendChild(img);
// example: 
// you may de-reference as far as you like down the package
// hierarchy.  This is sometimes handy to avoid lenghty relative
// urls or for building portable sub-packages. In this example,
// the `acme.widget` and `acme.util` directories may be located
// under different roots (see `dojo.registerModulePath`) but the
// the modules which reference them can be unaware of their
// relative locations on the filesystem:
// | // somewhere in a configuration block
// | dojo.registerModulePath("acme.widget", "../../acme/widget");
// | dojo.registerModulePath("acme.util", "../../util");
// |
// | // ...
// |
// | // code in a module using acme resources
// | var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
// | var dataPath = dojo.moduleUrl("acme.util","resources/data.json");

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

/*=====
dojo.isBrowser = {
// example:
// | if(dojo.isBrowser){ ... }
};

dojo.isFF = {
// example:
// | if(dojo.isFF > 1){ ... }
};

dojo.isIE = {
// example:
// | if(dojo.isIE > 6){
// | // we are IE7
//  | }
};

dojo.isSafari = {
// example:
// | if(dojo.isSafari){ ... }
// example: 
// Detect iPhone:
// | if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){ 
// | // we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
// | }
};

dojo = {
// isBrowser: Boolean
// True if the client is a web-browser
isBrowser: true,
// isFF: Number | undefined
// Version as a Number if client is FireFox. undefined otherwise. Corresponds to
// major detected FireFox version (1.5, 2, 3, etc.)
isFF: 2,
// isIE: Number | undefined
// Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
// major detected IE version (6, 7, 8, etc.)
isIE: 6,
// isKhtml: Number | undefined
// Version as a Number if client is a KTHML-derived browser (Konqueror,
// Safari, etc.). undefined otherwise. Corresponds to major detected version.
isKhtml: 0,
// isMozilla: Number | undefined
// Version as a Number if client is a Mozilla-based browser (Firefox,
// SeaMonkey). undefined otherwise. Corresponds to major detected version.
isMozilla: 0,
// isOpera: Number | undefined
// Version as a Number if client is Opera. undefined otherwise. Corresponds to
// major detected version.
isOpera: 0,
// isSafari: Number | undefined
// Version as a Number if client is Safari or iPhone. undefined otherwise.
isSafari: 0
}
=====*/

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(\W|$)/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(!d.config.baseUrl){
d.config.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){
dojo.config[x] = cfgo[x];
}
}
break; // "first Dojo wins"
}
}
}
d.baseUrl = d.config.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);

if(dua.indexOf("Opera") >= 0){ d.isOpera = tv; }
// safari detection derived from:
// http://developer.apple.com/internet/safari/faq.html#anchor2
// http://developer.apple.com/internet/safari/uamatrix.html
var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
if(index){
// try to grab the explicit Safari version first. If we don't get
// one, look for 419.3+ as the indication that we're on something
// "Safari 3-ish". Lastly, default to "Safari 2" handling.
d.isSafari = parseFloat(dav.split("Version/")[1]) ||
(parseFloat(dav.substr(index + 7)) > 419.3) ? 3 : 2;
}
if(dua.indexOf("AdobeAIR") >= 0){ d.isAIR = 1; }
if(dav.indexOf("Konqueror") >= 0 || d.isSafari){ d.isKhtml =  tv; }
if(dua.indexOf("Gecko") >= 0 && !d.isKhtml){ d.isMozilla = d.isMoz = tv; }
if(d.isMoz){
d.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
}
if(document.all && !d.isOpera){
d.isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
}

//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:"){
dojo.config.ieForceActiveXXhr=true;
}

var cm = document.compatMode;
d.isQuirks = cm == "BackCompat" || cm == "QuirksMode" || d.isIE < 6;

// TODO: is the HTML LANG attribute relevant?
d.locale = dojo.config.locale || (d.isIE ? n.userLanguage : n.language).toLowerCase();

// 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 || !dojo.config.ieForceActiveXXhr){
try{ http = new XMLHttpRequest(); }catch(e){}
}
if(!http){
for(var i=0; i<3; ++i){
var progid = d._XMLHTTP_PROGIDS[i];
try{
http = new ActiveXObject(progid);
}catch(e){
last_e = e;
}

if(http){
d._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();
}
/*


alert(uri);
*/

if(d.config.cacheBust){
//Make sure we have a string before string methods are used on uri
uri += "";
uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(d.config.cacheBust).replace(/\W+/g,"");
}

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
}

d._windowUnloaders = [];

d.windowUnloaded = function(){
// summary:
// signal fired by impending window destruction. You may use
// dojo.addOnWIndowUnload() or dojo.connect() to this method to perform
// page/application cleanup methods. See dojo.addOnWindowUnload for more info.
var mll = this._windowUnloaders;
while(mll.length){
(mll.pop())();
}
}

d.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
// summary:
// registers a function to be triggered when window.onunload fires.
// Be careful trying to modify the DOM or access JavaScript properties
// during this phase of page unloading: they may not always be available.
// Consider dojo.addOnUnload() if you need to modify the DOM or do heavy
// JavaScript work.
// example:
// | dojo.addOnWindowUnload(functionPointer)
// | dojo.addOnWindowUnload(object, "functionName")
// | dojo.addOnWindowUnload(object, function(){ /* ... */});

d._onto(d._windowUnloaders, obj, functionName);
}
})();

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("_khtmlTimer" in dojo){
clearInterval(dojo._khtmlTimer);
delete dojo._khtmlTimer;
}

if(dojo._inFlightCount == 0){
dojo._modulesLoaded();
}
}

dojo._fakeLoadInit = function(){
dojo._loadInit({type: "load"});
}

if(!dojo.config.afterOnLoad){
// 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.isFF >= 3 || (dojo.isMoz && dojo.config.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(dojo.isAIR){
window.addEventListener("load", dojo._loadInit, null);
}else 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.
if(!dojo.config.afterOnLoad){
document.write('<scr'+'ipt defer src="//:" '
+ 'onreadystatechange="if(this.readyState==\'complete\'){' + dojo._scopeName + '._loadInit();}">'
+ '</scr'+'ipt>'
);
}

try{
document.namespaces.add("v","urn:schemas-microsoft-com:vml");
document.createStyleSheet().addRule("v\\:*", "behavior:url(#default#VML)");
}catch(e){}
}

// FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper.
_handleNodeEvent("onbeforeunload", function() { dojo.unloaded(); });
_handleNodeEvent("onunload", function() { dojo.windowUnloaded(); });
})();

/*
OpenAjax.subscribe("OpenAjax", "onload", function(){
if(dojo._inFlightCount == 0){
dojo._modulesLoaded();
}
});

OpenAjax.subscribe("OpenAjax", "onunload", function(){
dojo.unloaded();
});
*/
} //if (typeof window != 'undefined')

//Register any module paths set up in djConfig. Need to do this
//in the hostenvs since hostenv_browser can read djConfig from a
//script tag's attribute.
(function(){
var mp = dojo.config["modulePaths"];
if(mp){
for(var param in mp){
dojo.registerModulePath(param, mp[param]);
}
}
})();

//Load debug code if necessary.
if(dojo.config.isDebug){
dojo.require("dojo._firebug.firebug");
}

if(dojo.config.debugAtAllCosts){
dojo.config.useXDomain = true;
dojo.require("dojo._base._loader.loader_xd");
dojo.require("dojo._base._loader.loader_debug");
dojo.require("dojo.i18n");
}

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 !!arguments.length && it != null && (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
return; // Boolean
}
=====*/

dojo.isFunction = (function(){
var _isFunction = function(/*anything*/ it){
return it && (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().
// returns:
// If it walks like a duck and quicks like a duck, return `true`
var d = dojo;
return it && it !== undefined && // Boolean
// 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));
}

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.thud == undefined; // by definition
// | thinger.thud == "xyzzy"; // mixed in from props
// | foo.bar = "thonk";
// | thinger.bar == "thonk"; // still delegated to foo's bar
}
=====*/

dojo.delegate = dojo._delegate = (function(){
// boodman/crockford delegation w/ cornford optimization
function TMP(){};
return function(obj, props){
TMP.prototype = obj;
var tmp = new TMP();
if(props){
dojo._mixin(tmp, props);
}
return tmp; // Object
}
})();

/*=====
dojo._toArray = function(obj, offset, startWith){
// summary:
// Converts an array-like object (i.e. arguments, DOMCollection) to an
// array. Returns a new Array with the elements of obj.
// obj: Object
// the object to "arrayify". We expect the object to have, at a
// minimum, a length property which corresponds to integer-indexed
// properties.
// offset: Number?
// the location in obj to start iterating from. Defaults to 0.
// Optional.
// startWith: Array?
// 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.
}
=====*/

(function(){
var efficient = function(obj, offset, startWith){
return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
};

var slow = function(obj, offset, startWith){
var arr = startWith||[]; 
for(var x = offset || 0; x < obj.length; x++){ 
arr.push(obj[x]); 
} 
return arr;
};

dojo._toArray = (!dojo.isIE) ? efficient : function(obj){
return ((obj.item) ? slow : efficient).apply(this, arguments);
};

})();

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.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

--> --------------------

--> maximum size reached

--> --------------------