Subversion Repositories Applications.papyrus

/*
        Copyright (c) 2004-2006, 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/community/licensing.shtml
*/

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
//                      - allowQueryConfig: false
//                      - baseScriptUri: ""
//                      - baseRelativePath: ""
//                      - libraryScriptUri: ""
//                      - iePreventClobber: false
//                      - ieClobberMinimal: true
//                      - locale: undefined
//                      - extraLocale: undefined
//                      - preventBackButtonFix: true
//                      - searchIds: []
//                      - parseWidgets: true
// TODOC: HOW TO DOC THESE VARIABLES?
// TODOC: IS THIS A COMPLETE LIST?
// 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.
// TODOC: is this still true?  Release notes for 0.3 indicated they could be set after load.
//


//TODOC:  HOW TO DOC THIS?
// @global: dj_global
// summary:
//              an alias for the top-level global object in the host environment
//              (e.g., the window object in a browser).
// description:
//              Refer to 'dj_global' rather than referring to window to ensure your
//              code runs correctly in contexts other than web browsers (eg: Rhino on a server).
var dj_global = this;

//TODOC:  HOW TO DOC THIS?
// @global: dj_currentContext
// summary:
//              Private global context object. Where 'dj_global' always refers to the boot-time
//    global context, 'dj_currentContext' can be modified for temporary context shifting.
//    dojo.global() returns dj_currentContext.
// description:
//              Refer to dojo.global() rather than referring to dj_global to ensure your
//              code runs correctly in managed contexts.
var dj_currentContext = this;


// ****************************************************************
// global public utils
// TODOC: DO WE WANT TO NOTE THAT THESE ARE GLOBAL PUBLIC UTILS?
// ****************************************************************

function dj_undef(/*String*/ name, /*Object?*/ object){
        //summary: Returns true if 'name' is defined on 'object' (or globally if 'object' is null).
        //description: Note that 'defined' and 'exists' are not the same concept.
        return (typeof (object || dj_currentContext)[name] == "undefined");     // Boolean
}

// make sure djConfig is defined
if(dj_undef("djConfig", this)){
        var djConfig = {};
}

//TODOC:  HOW TO DOC THIS?
// dojo is the root variable of (almost all) our public symbols -- make sure it is defined.
if(dj_undef("dojo", this)){
        var dojo = {};
}

dojo.global = function(){
        // 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).
        return dj_currentContext;
}

// 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: 0, minor: 4, patch: 3, flag: "",
        revision: Number("$Rev: 8617 $".match(/[0-9]+/)[0]),
        toString: function(){
                with(dojo.version){
                        return major + "." + minor + "." + patch + flag + " (" + revision + ")";        // String
                }
        }
}

dojo.evalProp = function(/*String*/ name, /*Object*/ object, /*Boolean?*/ create){
        // summary: Returns 'object[name]'.  If not defined and 'create' is true, will return a new Object.
        // description:
        //              Returns null if 'object[name]' is not defined and 'create' is not true.
        //              Note: 'defined' and 'exists' are not the same concept.
        if((!object)||(!name)) return undefined; // undefined
        if(!dj_undef(name, object)) return object[name]; // mixed
        return (create ? (object[name]={}) : undefined);        // mixed
}

dojo.parseObjPath = function(/*String*/ path, /*Object?*/ context, /*Boolean?*/ create){
        // summary: Parse string path to an object, and return corresponding object reference and property name.
        // description:
        //              Returns an object with two properties, 'obj' and 'prop'.
        //              'obj[prop]' is the reference indicated by 'path'.
        // path: Path to an object, in the form "A.B.C".
        // context: Object to use as root of path.  Defaults to 'dojo.global()'.
        // create: If true, Objects will be created at any point along the 'path' that is undefined.
        var object = (context || dojo.global());
        var names = path.split('.');
        var prop = names.pop();
        for (var i=0,l=names.length;i<l && object;i++){
                object = dojo.evalProp(names[i], object, create);
        }
        return {obj: object, prop: prop};       // Object: {obj: Object, prop: String}
}

dojo.evalObjPath = function(/*String*/ path, /*Boolean?*/ create){
        // summary: Return the value of object at 'path' in the global scope, without using 'eval()'.
        // path: Path to an object, in the form "A.B.C".
        // create: If true, Objects will be created at any point along the 'path' that is undefined.
        if(typeof path != "string"){
                return dojo.global();
        }
        // fast path for no periods
        if(path.indexOf('.') == -1){
                return dojo.evalProp(path, dojo.global(), create);              // mixed
        }

        //MOW: old 'with' syntax was confusing and would throw an error if parseObjPath returned null.
        var ref = dojo.parseObjPath(path, dojo.global(), create);
        if(ref){
                return dojo.evalProp(ref.prop, ref.obj, create);        // mixed
        }
        return null;
}

dojo.errorToString = function(/*Error*/ exception){
        // summary: Return an exception's 'message', 'description' or text.

        // TODO: overriding Error.prototype.toString won't accomplish this?
        //              ... since natively generated Error objects do not always reflect such things?
        if(!dj_undef("message", exception)){
                return exception.message;               // String
        }else if(!dj_undef("description", exception)){
                return exception.description;   // String
        }else{
                return exception;                               // Error
        }
}

dojo.raise = function(/*String*/ message, /*Error?*/ exception){
        // summary: Common point for raising exceptions in Dojo to enable logging.
        //      Throws an error message with text of 'exception' if provided, or
        //      rethrows exception object.

        if(exception){
                message = message + ": "+dojo.errorToString(exception);
        }else{
                message = dojo.errorToString(message);
        }

        // print the message to the user if hostenv.println is defined
        try { if(djConfig.isDebug){ dojo.hostenv.println("FATAL exception raised: "+message); } } catch (e) {}

        throw exception || Error(message);
}

//Stub functions so things don't break.
//TODOC:  HOW TO DOC THESE?
dojo.debug = function(){};
dojo.debugShallow = function(obj){};
dojo.profile = { start: function(){}, end: function(){}, stop: function(){}, dump: function(){} };

function dj_eval(/*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.
        return dj_global.eval ? dj_global.eval(scriptFragment) : eval(scriptFragment);  // mixed
}

dojo.unimplemented = function(/*String*/ funcname, /*String?*/ extra){
        // summary: Throw an exception because some function is not implemented.
        // extra: Text to append to the exception message.
        var message = "'" + funcname + "' not implemented";
        if (extra != null) { message += " " + extra; }
        dojo.raise(message);
}

dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
        // summary: Log a debug message to indicate that a behavior has been deprecated.
        // extra: Text to append to the message.
        // removal: Text to indicate when in the future the behavior will be removed.
        var message = "DEPRECATED: " + behaviour;
        if(extra){ message += " " + extra; }
        if(removal){ message += " -- will be removed in version: " + removal; }
        dojo.debug(message);
}

dojo.render = (function(){
        //TODOC: HOW TO DOC THIS?
        // summary: Details rendering support, OS and browser of the current environment.
        // TODOC: is this something many folks will interact with?  If so, we should doc the structure created...
        function vscaffold(prefs, names){
                var tmp = {
                        capable: false,
                        support: {
                                builtin: false,
                                plugin: false
                        },
                        prefixes: prefs
                };
                for(var i=0; i<names.length; i++){
                        tmp[names[i]] = false;
                }
                return tmp;
        }

        return {
                name: "",
                ver: dojo.version,
                os: { win: false, linux: false, osx: false },
                html: vscaffold(["html"], ["ie", "opera", "khtml", "safari", "moz"]),
                svg: vscaffold(["svg"], ["corel", "adobe", "batik"]),
                vml: vscaffold(["vml"], ["ie"]),
                swf: vscaffold(["Swf", "Flash", "Mm"], ["mm"]),
                swt: vscaffold(["Swt"], ["ibm"])
        };
})();

// ****************************************************************
// dojo.hostenv methods that must be defined in hostenv_*.js
// ****************************************************************

/**
 * The interface definining the interaction with the EcmaScript host environment.
*/

/*
 * None of these methods should ever be called directly by library users.
 * Instead public methods such as loadModule should be called instead.
 */
dojo.hostenv = (function(){
        // TODOC:  HOW TO DOC THIS?
        // summary: Provides encapsulation of behavior that changes across different 'host environments'
        //                      (different browsers, server via Rhino, etc).
        // description: None of these methods should ever be called directly by library users.
        //                              Use public methods such as 'loadModule' instead.

        // default configuration options
        var config = {
                isDebug: false,
                allowQueryConfig: false,
                baseScriptUri: "",
                baseRelativePath: "",
                libraryScriptUri: "",
                iePreventClobber: false,
                ieClobberMinimal: true,
                preventBackButtonFix: true,
                delayMozLoadingFix: false,
                searchIds: [],
                parseWidgets: true
        };

        if (typeof djConfig == "undefined") { djConfig = config; }
        else {
                for (var option in config) {
                        if (typeof djConfig[option] == "undefined") {
                                djConfig[option] = config[option];
                        }
                }
        }

        return {
                name_: '(unset)',
                version_: '(unset)',


                getName: function(){
                        // sumary: Return the name of the host environment.
                        return this.name_;      // String
                },


                getVersion: function(){
                        // summary: Return the version of the hostenv.
                        return this.version_; // String
                },

                getText: function(/*String*/ uri){
                        // summary:     Read the plain/text contents at the specified 'uri'.
                        // description:
                        //                      If 'getText()' is not implemented, then it is necessary to override
                        //                      'loadUri()' with an implementation that doesn't rely on it.

                        dojo.unimplemented('getText', "uri=" + uri);
                }
        };
})();


dojo.hostenv.getBaseScriptUri = function(){
        // summary: Return the base script uri that other scripts are found relative to.
        // TODOC: HUH?  This comment means nothing to me.  What other scripts? Is this the path to other dojo libraries?
        //              MAYBE:  Return the base uri to scripts in the dojo library.      ???
        // return: Empty string or a path ending in '/'.
        if(djConfig.baseScriptUri.length){
                return djConfig.baseScriptUri;
        }

        // MOW: Why not:
        //                      uri = djConfig.libraryScriptUri || djConfig.baseRelativePath
        //              ??? Why 'new String(...)'
        var uri = new String(djConfig.libraryScriptUri||djConfig.baseRelativePath);
        if (!uri) { dojo.raise("Nothing returned by getLibraryScriptUri(): " + uri); }

        // MOW: uri seems to not be actually used.  Seems to be hard-coding to djConfig.baseRelativePath... ???
        var lastslash = uri.lastIndexOf('/');           // MOW ???
        djConfig.baseScriptUri = djConfig.baseRelativePath;
        return djConfig.baseScriptUri;  // String
}

/*
 * loader.js - A bootstrap module.  Runs before the hostenv_*.js file. Contains all of the package loading methods.
 */

//A semi-colon is at the start of the line because after doing a build, this function definition
//get compressed onto the same line as the last line in bootstrap1.js. That list line is just a
//curly bracket, and the browser complains about that syntax. The semicolon fixes it. Putting it
//here instead of at the end of bootstrap1.js, since it is more of an issue for this file, (using
//the closure), and bootstrap1.js could change in the future.
;(function(){
        //Additional properties for dojo.hostenv
        var _addHostEnv = {
                pkgFileName: "__package__",
        
                // for recursion protection
                loading_modules_: {},
                loaded_modules_: {},
                addedToLoadingCount: [],
                removedFromLoadingCount: [],
        
                inFlightCount: 0,
        
                // FIXME: it should be possible to pull module prefixes in from djConfig
                modulePrefixes_: {
                        dojo: {name: "dojo", value: "src"}
                },

                setModulePrefix: function(/*String*/module, /*String*/prefix){
                        // summary: establishes module/prefix pair
                        this.modulePrefixes_[module] = {name: module, value: prefix};
                },

                moduleHasPrefix: function(/*String*/module){
                        // summary: checks to see if module has been established
                        var mp = this.modulePrefixes_;
                        return Boolean(mp[module] && mp[module].value); // Boolean
                },

                getModulePrefix: function(/*String*/module){
                        // summary: gets the prefix associated with module
                        if(this.moduleHasPrefix(module)){
                                return this.modulePrefixes_[module].value; // String
                        }
                        return module; // String
                },

                getTextStack: [],
                loadUriStack: [],
                loadedUris: [],
        
                //WARNING: This variable is referenced by packages outside of bootstrap: FloatingPane.js and undo/browser.js
                post_load_: false,
                
                //Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
                modulesLoadedListeners: [],
                unloadListeners: [],
                loadNotifying: false
        };
        
        //Add all of these properties to dojo.hostenv
        for(var param in _addHostEnv){
                dojo.hostenv[param] = _addHostEnv[param];
        }
})();

dojo.hostenv.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.
//
//      For now, we do not have an implementation of a true search path.  We
//      consider only the single base script uri, as returned by getBaseScriptUri().
//
// 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;
        if(relpath.charAt(0) == '/' || relpath.match(/^\w+:/)){
                // dojo.raise("relpath '" + relpath + "'; must be relative");
                uri = relpath;
        }else{
                uri = this.getBaseScriptUri() + relpath;
        }
        if(djConfig.cacheBust && dojo.render.html.capable){
                uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,"");
        }
        try{
                return !module ? this.loadUri(uri, cb) : this.loadUriAndCheck(uri, module, cb); // Boolean
        }catch(e){
                dojo.debug(e);
                return false; // Boolean
        }
}

dojo.hostenv.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.loadedUris[uri]){
                return true; // Boolean
        }
        var contents = this.getText(uri, null, true);
        if(!contents){ return false; } // Boolean
        this.loadedUris[uri] = true;
        if(cb){ contents = '('+contents+')'; }
        var value = dj_eval(contents);
        if(cb){ cb(value); }
        return true; // Boolean
}

// FIXME: probably need to add logging to this method
dojo.hostenv.loadUriAndCheck = function(/*String (URL)*/uri, /*String*/moduleName, /*Function?*/cb){
        // summary: calls loadUri then findModule and returns true if both succeed
        var ok = true;
        try{
                ok = this.loadUri(uri, cb);
        }catch(e){
                dojo.debug("failed loading ", uri, " with error: ", e);
        }
        return Boolean(ok && this.findModule(moduleName, false)); // Boolean
}

dojo.loaded = function(){ }
dojo.unloaded = function(){ }

dojo.hostenv.loaded = function(){
        this.loadNotifying = true;
        this.post_load_ = true;
        var mll = this.modulesLoadedListeners;
        for(var x=0; x<mll.length; x++){
                mll[x]();
        }

        //Clear listeners so new ones can be added
        //For other xdomain package loads after the initial load.
        this.modulesLoadedListeners = [];
        this.loadNotifying = false;

        dojo.loaded();
}

dojo.hostenv.unloaded = function(){
        var mll = this.unloadListeners;
        while(mll.length){
                (mll.pop())();
        }
        dojo.unloaded();
}

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.)
//
// usage:
//      dojo.addOnLoad(functionPointer)
//      dojo.addOnLoad(object, "functionName")

        var dh = dojo.hostenv;
        if(arguments.length == 1) {
                dh.modulesLoadedListeners.push(obj);
        } else if(arguments.length > 1) {
                dh.modulesLoadedListeners.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(dh.post_load_ && dh.inFlightCount == 0 && !dh.loadNotifying){
                dh.callLoaded();
        }
}

dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
// summary: registers a function to be triggered when the page unloads
//
// usage:
//      dojo.addOnLoad(functionPointer)
//      dojo.addOnLoad(object, "functionName")
        var dh = dojo.hostenv;
        if(arguments.length == 1){
                dh.unloadListeners.push(obj);
        } else if(arguments.length > 1) {
                dh.unloadListeners.push(function() {
                        obj[functionName]();
                });
        }
}

dojo.hostenv.modulesLoaded = function(){
        if(this.post_load_){ return; }
        if(this.loadUriStack.length==0 && this.getTextStack.length==0){
                if(this.inFlightCount > 0){ 
                        dojo.debug("files still in flight!");
                        return;
                }
                dojo.hostenv.callLoaded();
        }
}

dojo.hostenv.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"] && dojo.render.html.opera)){
                setTimeout("dojo.hostenv.loaded();", 0);
        }else{
                dojo.hostenv.loaded();
        }
}

dojo.hostenv.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.hostenv._global_omit_module_check = false;
dojo.hostenv.loadModule = function(/*String*/moduleName, /*Boolean?*/exactOnly, /*Boolean?*/omitModuleCheck){
// summary:
//      loads a Javascript module from the appropriate URI
//
// 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,
//      followed by "A.js".
//      
//      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.hostenv.loadModule("A.B")) {
//            ...
//         }
//      
//      And to import just the leaf symbol:
//      
//         var B = dojo.hostenv.loadModule("A.B");
//         ...
//      
//      dj_load is an alias for dojo.hostenv.loadModule

        if(!moduleName){ return; }
        omitModuleCheck = this._global_omit_module_check || omitModuleCheck;
        var module = this.findModule(moduleName, false);
        if(module){
                return module;
        }

        // protect against infinite recursion from mutual dependencies
        if(dj_undef(moduleName, this.loading_modules_)){
                this.addedToLoadingCount.push(moduleName);
        }
        this.loading_modules_[moduleName] = 1;

        // convert periods to slashes
        var relpath = moduleName.replace(/\./g, '/') + '.js';

        var nsyms = moduleName.split(".");
        
        // this line allowed loading of a module manifest as if it were a namespace
        // it's an interesting idea, but shouldn't be combined with 'namespaces' proper
        // and leads to unwanted dependencies
        // the effect can be achieved in other (albeit less-flexible) ways now, so I am
        // removing this pending further design work
        // perhaps we can explicitly define this idea of a 'module manifest', and subclass
        // 'namespace manifest' from that
        //dojo.getNamespace(nsyms[0]);

        var syms = this.getModuleSymbols(moduleName);
        var startedRelative = ((syms[0].charAt(0) != '/') && !syms[0].match(/^\w+:/));
        var last = syms[syms.length - 1];
        var ok;
        // figure out if we're looking for a full package, if so, we want to do
        // things slightly diffrently
        if(last=="*"){
                moduleName = nsyms.slice(0, -1).join('.');
                while(syms.length){
                        syms.pop();
                        syms.push(this.pkgFileName);
                        relpath = syms.join("/") + '.js';
                        if(startedRelative && relpath.charAt(0)=="/"){
                                relpath = relpath.slice(1);
                        }
                        ok = this.loadPath(relpath, !omitModuleCheck ? moduleName : null);
                        if(ok){ break; }
                        syms.pop();
                }
        }else{
                relpath = syms.join("/") + '.js';
                moduleName = nsyms.join('.');
                var modArg = !omitModuleCheck ? moduleName : null;
                ok = this.loadPath(relpath, modArg);
                if(!ok && !exactOnly){
                        syms.pop();
                        while(syms.length){
                                relpath = syms.join('/') + '.js';
                                ok = this.loadPath(relpath, modArg);
                                if(ok){ break; }
                                syms.pop();
                                relpath = syms.join('/') + '/'+this.pkgFileName+'.js';
                                if(startedRelative && relpath.charAt(0)=="/"){
                                        relpath = relpath.slice(1);
                                }
                                ok = this.loadPath(relpath, modArg);
                                if(ok){ break; }
                        }
                }

                if(!ok && !omitModuleCheck){
                        dojo.raise("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.findModule(moduleName, false);
                if(!module){
                        dojo.raise("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'"); 
                }
        }

        return module;
}

dojo.hostenv.startPackage = function(/*String*/packageName){
// summary:
//      Creates a JavaScript package
//
// description:
//      startPackage("A.B") follows the path, and at each level creates a new empty
//      object or uses what already exists. It returns the result.
//
// packageName: the package to be created as a String in dot notation

        //Make sure we have a string.
        var fullPkgName = String(packageName);
        var strippedPkgName = fullPkgName;

        var syms = packageName.split(/\./);
        if(syms[syms.length-1]=="*"){
                syms.pop();
                strippedPkgName = syms.join(".");
        }
        var evaledPkg = dojo.evalObjPath(strippedPkgName, true);
        this.loaded_modules_[fullPkgName] = evaledPkg;
        this.loaded_modules_[strippedPkgName] = evaledPkg;
        
        return evaledPkg; // Object
}

dojo.hostenv.findModule = function(/*String*/moduleName, /*Boolean?*/mustExist){
// summary:
//      Returns the Object representing the module, if it exists, otherwise null.
//
// moduleName A fully qualified module including package name, like 'A.B'.
// mustExist Optional, default false. throw instead of returning null
//      if the module does not currently exist.

        var lmn = String(moduleName);

        if(this.loaded_modules_[lmn]){
                return this.loaded_modules_[lmn]; // Object
        }

        if(mustExist){
                dojo.raise("no loaded module named '" + moduleName + "'");
        }
        return null; // null
}

//Start of old bootstrap2:

dojo.kwCompoundRequire = 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.hostenv.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.kwCompoundRequire({
//              browser: [
//                      ["foo.bar.baz", true, true], // an example that passes multiple args to loadModule()
//                      "foo.sample.*",
//                      "foo.test,
//              ],
//              default: [ "foo.sample.*" ],
//              common: [ "really.important.module.*" ]
//      });

        var common = modMap["common"]||[];
        var result = modMap[dojo.hostenv.name_] ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);

        for(var x=0; x<result.length; x++){
                var curr = result[x];
                if(curr.constructor == Array){
                        dojo.hostenv.loadModule.apply(dojo.hostenv, curr);
                }else{
                        dojo.hostenv.loadModule(curr);
                }
        }
}

dojo.require = function(/*String*/ resourceName){
        // summary
        //      Ensure that the given resource (ie, javascript
        //      source file) has been loaded.
        // description
        //      dojo.require() is similar to C's #include command or java's "import" command.
        //      You call dojo.require() to pull in the resources (ie, javascript source files)
        //      that define the functions you are using. 
        //
        //      Note that in the case of a build, many resources have already been included
        //      into dojo.js (ie, many of the javascript source files have been compressed and
        //      concatened into dojo.js), so many dojo.require() calls will simply return
        //      without downloading anything.
        dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
}

dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
        // summary
        //      If the condition is true then call dojo.require() for the specified resource
        var arg0 = arguments[0];
        if((arg0 === true)||(arg0=="common")||(arg0 && dojo.render[arg0].capable)){
                var args = [];
                for (var i = 1; i < arguments.length; i++) { args.push(arguments[i]); }
                dojo.require.apply(dojo, args);
        }
}

dojo.requireAfterIf = dojo.requireIf;

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, dojo/src/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.html.common"), in addition to registering that common.js
        //      is a resource for the dojo.html module, will ensure that the dojo.html javascript object
        //      exists, so that calls like dojo.html.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.
        return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
}

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. 
        return dojo.hostenv.setModulePrefix(module, prefix);
}

if(djConfig["modulePaths"]){
        for(var param in djConfig["modulePaths"]){
                dojo.registerModulePath(param, djConfig["modulePaths"][param]);
        }
}

dojo.setModulePrefix = function(/*String*/module, /*String*/prefix){
        // summary: maps a module name to a path
        dojo.deprecated('dojo.setModulePrefix("' + module + '", "' + prefix + '")', "replaced by dojo.registerModulePath", "0.5");
        return dojo.registerModulePath(module, prefix);
}

dojo.exists = function(/*Object*/obj, /*String*/name){
        // 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
        var p = name.split(".");
        for(var i = 0; i < p.length; i++){
                if(!obj[p[i]]){ return false; } // Boolean
                obj = obj[p[i]];
        }
        return true; // Boolean
}

// Localization routines

dojo.hostenv.normalizeLocale = function(/*String?*/locale){
//      summary:
//              Returns canonical form of locale, as used by Dojo.  All variants are case-insensitive and are separated by '-'
//              as specified in RFC 3066. If no locale is specified, the user agent's default is returned.

        var result = locale ? locale.toLowerCase() : dojo.locale;
        if(result == "root"){
                result = "ROOT";
        }
        return result;// String
};

dojo.hostenv.searchLocalePath = function(/*String*/locale, /*Boolean*/down, /*Function*/searchFunc){
//      summary:
//              A helper method to assist in searching for locale-based resources.  Will iterate through
//              the variants of a particular locale, either up or down, executing a callback function.
//              For example, "en-us" and true will try "en-us" followed by "en" and finally "ROOT".

        locale = dojo.hostenv.normalizeLocale(locale);

        var elements = locale.split('-');
        var searchlist = [];
        for(var i = elements.length; i > 0; i--){
                searchlist.push(elements.slice(0, i).join('-'));
        }
        searchlist.push(false);
        if(down){searchlist.reverse();}

        for(var j = searchlist.length - 1; j >= 0; j--){
                var loc = searchlist[j] || "ROOT";
                var stop = searchFunc(loc);
                if(stop){ break; }
        }
}

//These two functions are placed outside of preloadLocalizations
//So that the xd loading can use/override them.
dojo.hostenv.localesGenerated /***BUILD:localesGenerated***/; // value will be inserted here at build time, if necessary

dojo.hostenv.registerNlsPrefix = function(){
// summary:
//      Register module "nls" to point where Dojo can find pre-built localization files
        dojo.registerModulePath("nls","nls");   
}

dojo.hostenv.preloadLocalizations = function(){
// summary:
//      Load built, flattened resource bundles, if available for all locales used in the page.
//      Execute only once.  Note that this is a no-op unless there is a build.

        if(dojo.hostenv.localesGenerated){
                dojo.hostenv.registerNlsPrefix();

                function preload(locale){
                        locale = dojo.hostenv.normalizeLocale(locale);
                        dojo.hostenv.searchLocalePath(locale, true, function(loc){
                                for(var i=0; i<dojo.hostenv.localesGenerated.length;i++){
                                        if(dojo.hostenv.localesGenerated[i] == loc){
                                                dojo["require"]("nls.dojo_"+loc);
                                                return true; // Boolean
                                        }
                                }
                                return false; // Boolean
                        });
                }
                preload();
                var extra = djConfig.extraLocale||[];
                for(var i=0; i<extra.length; i++){
                        preload(extra[i]);
                }
        }
        dojo.hostenv.preloadLocalizations = function(){};
}

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.

        dojo.hostenv.preloadLocalizations();
        var targetLocale = dojo.hostenv.normalizeLocale(locale);
        var bundlePackage = [moduleName, "nls", bundleName].join(".");
//NOTE: When loading these resources, the packaging does not match what is on disk.  This is an
// implementation detail, as this is just a private data structure to hold the loaded resources.
// e.g. tests/hello/nls/en-us/salutations.js is loaded as the object tests.hello.nls.salutations.en_us={...}
// The structure on disk is intended to be most convenient for developers and translators, but in memory
// it is more logical and efficient to store in a different order.  Locales cannot use dashes, since the
// resulting path will not evaluate as valid JS, so we translate them to underscores.
        
        //Find the best-match locale to load if we have available flat locales.
        var bestLocale = "";
        if(availableFlatLocales){
                var flatLocales = availableFlatLocales.split(",");
                for(var i = 0; i < flatLocales.length; i++){
                        //Locale must match from start of string.
                        if(targetLocale.indexOf(flatLocales[i]) == 0){
                                if(flatLocales[i].length > bestLocale.length){
                                        bestLocale = flatLocales[i];
                                }
                        }
                }
                if(!bestLocale){
                        bestLocale = "ROOT";
                }               
        }

        //See if the desired locale is already loaded.
        var tempLocale = availableFlatLocales ? bestLocale : targetLocale;
        var bundle = dojo.hostenv.findModule(bundlePackage);
        var localizedBundle = null;
        if(bundle){
                if(djConfig.localizationComplete && bundle._built){return;}
                var jsLoc = tempLocale.replace('-', '_');
                var translationPackage = bundlePackage+"."+jsLoc;
                localizedBundle = dojo.hostenv.findModule(translationPackage);
        }

        if(!localizedBundle){
                bundle = dojo.hostenv.startPackage(bundlePackage);
                var syms = dojo.hostenv.getModuleSymbols(moduleName);
                var modpath = syms.concat("nls").join("/");
                var parent;

                dojo.hostenv.searchLocalePath(tempLocale, availableFlatLocales, function(loc){
                        var jsLoc = loc.replace('-', '_');
                        var translationPackage = bundlePackage + "." + jsLoc;
                        var loaded = false;
                        if(!dojo.hostenv.findModule(translationPackage)){
                                // Mark loaded whether it's found or not, so that further load attempts will not be made
                                dojo.hostenv.startPackage(translationPackage);
                                var module = [modpath];
                                if(loc != "ROOT"){module.push(loc);}
                                module.push(bundleName);
                                var filespec = module.join("/") + '.js';
                                loaded = dojo.hostenv.loadPath(filespec, null, function(hash){
                                        // Use singleton with prototype to point to parent bundle, then mix-in result from loadPath
                                        var clazz = function(){};
                                        clazz.prototype = parent;
                                        bundle[jsLoc] = new clazz();
                                        for(var j in hash){ bundle[jsLoc][j] = hash[j]; }
                                });
                        }else{
                                loaded = true;
                        }
                        if(loaded && bundle[jsLoc]){
                                parent = bundle[jsLoc];
                        }else{
                                bundle[jsLoc] = parent;
                        }
                        
                        if(availableFlatLocales){
                                //Stop the locale path searching if we know the availableFlatLocales, since
                                //the first call to this function will load the only bundle that is needed.
                                return true;
                        }
                });
        }

        //Save the best locale bundle as the target locale bundle when we know the
        //the available bundles.
        if(availableFlatLocales && targetLocale != bestLocale){
                bundle[targetLocale.replace('-', '_')] = bundle[bestLocale.replace('-', '_')];
        }
};

(function(){
        // If other locales are used, dojo.requireLocalization should load them as well, by default.
        // Override dojo.requireLocalization to do load the default bundle, then iterate through the
        // extraLocale list and load those translations as well, unless a particular locale was requested.

        var extra = djConfig.extraLocale;
        if(extra){
                if(!extra instanceof Array){
                        extra = [extra];
                }

                var req = dojo.requireLocalization;
                dojo.requireLocalization = function(m, b, locale, availableFlatLocales){
                        req(m,b,locale, availableFlatLocales);
                        if(locale){return;}
                        for(var i=0; i<extra.length; i++){
                                req(m,b,extra[i], availableFlatLocales);
                        }
                };
        }
})();

};

if(typeof window != 'undefined'){

        // attempt to figure out the path to dojo if it isn't set in the config
        (function(){
                // before we get any further with the config options, try to pick them out
                // of the URL. Most of this code is from NW
                if(djConfig.allowQueryConfig){
                        var baseUrl = document.location.toString(); // FIXME: use location.query instead?
                        var params = baseUrl.split("?", 2);
                        if(params.length > 1){
                                var paramStr = params[1];
                                var pairs = paramStr.split("&");
                                for(var x in pairs){
                                        var sp = pairs[x].split("=");
                                        // FIXME: is this eval dangerous?
                                        if((sp[0].length > 9)&&(sp[0].substr(0, 9) == "djConfig.")){
                                                var opt = sp[0].substr(9);
                                                try{
                                                        djConfig[opt]=eval(sp[1]);
                                                }catch(e){
                                                        djConfig[opt]=sp[1];
                                                }
                                        }
                                }
                        }
                }

                if(
                        ((djConfig["baseScriptUri"] == "")||(djConfig["baseRelativePath"] == "")) && 
                        (document && document.getElementsByTagName)
                ){
                        var scripts = document.getElementsByTagName("script");
                        var rePkg = /(__package__|dojo|bootstrap1)\.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) {
                                        var root = src.substring(0, m.index);
                                        if(src.indexOf("bootstrap1") > -1) { root += "../"; }
                                        if(!this["djConfig"]) { djConfig = {}; }
                                        if(djConfig["baseScriptUri"] == "") { djConfig["baseScriptUri"] = root; }
                                        if(djConfig["baseRelativePath"] == "") { djConfig["baseRelativePath"] = root; }
                                        break;
                                }
                        }
                }

                // fill in the rendering support information in dojo.render.*
                var dr = dojo.render;
                var drh = dojo.render.html;
                var drs = dojo.render.svg;
                var dua = (drh.UA = navigator.userAgent);
                var dav = (drh.AV = navigator.appVersion);
                var t = true;
                var f = false;
                drh.capable = t;
                drh.support.builtin = t;

                dr.ver = parseFloat(drh.AV);
                dr.os.mac = dav.indexOf("Macintosh") >= 0;
                dr.os.win = dav.indexOf("Windows") >= 0;
                // could also be Solaris or something, but it's the same browser
                dr.os.linux = dav.indexOf("X11") >= 0;

                drh.opera = dua.indexOf("Opera") >= 0;
                drh.khtml = (dav.indexOf("Konqueror") >= 0)||(dav.indexOf("Safari") >= 0);
                drh.safari = dav.indexOf("Safari") >= 0;
                var geckoPos = dua.indexOf("Gecko");
                drh.mozilla = drh.moz = (geckoPos >= 0)&&(!drh.khtml);
                if (drh.mozilla) {
                        // gecko version is YYYYMMDD
                        drh.geckoVersion = dua.substring(geckoPos + 6, geckoPos + 14);
                }
                drh.ie = (document.all)&&(!drh.opera);
                drh.ie50 = drh.ie && dav.indexOf("MSIE 5.0")>=0;
                drh.ie55 = drh.ie && dav.indexOf("MSIE 5.5")>=0;
                drh.ie60 = drh.ie && dav.indexOf("MSIE 6.0")>=0;
                drh.ie70 = drh.ie && dav.indexOf("MSIE 7.0")>=0;

                var cm = document["compatMode"];
                drh.quirks = (cm == "BackCompat")||(cm == "QuirksMode")||drh.ie55||drh.ie50;

                // TODO: is the HTML LANG attribute relevant?
                dojo.locale = dojo.locale || (drh.ie ? navigator.userLanguage : navigator.language).toLowerCase();

                dr.vml.capable=drh.ie;
                drs.capable = f;
                drs.support.plugin = f;
                drs.support.builtin = f;
                var tdoc = window["document"];
                var tdi = tdoc["implementation"];

                if((tdi)&&(tdi["hasFeature"])&&(tdi.hasFeature("org.w3c.dom.svg", "1.0"))){
                        drs.capable = t;
                        drs.support.builtin = t;
                        drs.support.plugin = f;
                }
                // webkits after 420 support SVG natively. The test string is "AppleWebKit/420+"
                if(drh.safari){
                        var tmp = dua.split("AppleWebKit/")[1];
                        var ver = parseFloat(tmp.split(" ")[0]);
                        if(ver >= 420){
                                drs.capable = t;
                                drs.support.builtin = t;
                                drs.support.plugin = f;
                        }
                }else{
                }
        })();

        dojo.hostenv.startPackage("dojo.hostenv");

        dojo.render.name = dojo.hostenv.name_ = 'browser';
        dojo.hostenv.searchIds = [];

        // These are in order of decreasing likelihood; this will change in time.
        dojo.hostenv._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];

        dojo.hostenv.getXmlhttpObject = function(){
                // summary: does the work of portably generating a new XMLHTTPRequest object.
                var http = null;
                var last_e = null;
                try{ http = new XMLHttpRequest(); }catch(e){}
                if(!http){
                        for(var i=0; i<3; ++i){
                                var progid = dojo.hostenv._XMLHTTP_PROGIDS[i];
                                try{
                                        http = new ActiveXObject(progid);
                                }catch(e){
                                        last_e = e;
                                }

                                if(http){
                                        dojo.hostenv._XMLHTTP_PROGIDS = [progid];  // so faster next time
                                        break;
                                }
                        }

                        /*if(http && !http.toString) {
                                http.toString = function() { "[object XMLHttpRequest]"; }
                        }*/
                }

                if(!http){
                        return dojo.raise("XMLHTTP not available", last_e);
                }

                return http; // XMLHTTPRequest instance
        }

        dojo.hostenv._blockAsync = false;
        dojo.hostenv.getText = function(uri, async_cb, 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.
                // async_cb:
                //              If not specified, load synchronously. If specified, load
                //              asynchronously, and use async_cb as the progress handler which
                //              takes the xmlhttp object as its argument. If async_cb, this
                //              function returns null.
                // fail_ok:
                //              Default false. If fail_ok and !async_cb and loading fails,
                //              return null instead of throwing.

                // need to block async callbacks from snatching this thread as the result
                // of an async callback might call another sync XHR, this hangs khtml forever
                // hostenv._blockAsync must also be checked in BrowserIO's watchInFlight()
                // NOTE: must be declared before scope switches ie. this.getXmlhttpObject()
                if(!async_cb){ this._blockAsync = true; }

                var http = this.getXmlhttpObject();

                function isDocumentOk(http){
                        var stat = http["status"];
                        // allow a 304 use cache, needed in konq (is this compliant with the http spec?)
                        return Boolean((!stat)||((200 <= stat)&&(300 > stat))||(stat==304));
                }

                if(async_cb){
                        var _this = this, timer = null, gbl = dojo.global();
                        var xhr = dojo.evalObjPath("dojo.io.XMLHTTPTransport");
                        http.onreadystatechange = function(){
                                if(timer){ gbl.clearTimeout(timer); timer = null; }
                                if(_this._blockAsync || (xhr && xhr._blockAsync)){
                                        timer = gbl.setTimeout(function () { http.onreadystatechange.apply(this); }, 10);
                                }else{
                                        if(4==http.readyState){
                                                if(isDocumentOk(http)){
                                                        // dojo.debug("LOADED URI: "+uri);
                                                        async_cb(http.responseText);
                                                }
                                        }
                                }
                        }
                }

                http.open('GET', uri, async_cb ? true : false);
                try{
                        http.send(null);
                        if(async_cb){
                                return null;
                        }
                        if(!isDocumentOk(http)){
                                var err = Error("Unable to load "+uri+" status:"+ http.status);
                                err.status = http.status;
                                err.responseText = http.responseText;
                                throw err;
                        }
                }catch(e){
                        this._blockAsync = false;
                        if((fail_ok)&&(!async_cb)){
                                return null;
                        }else{
                                throw e;
                        }
                }

                this._blockAsync = false;
                return http.responseText; // String
        }

        dojo.hostenv.defaultDebugContainerId = 'dojoDebug';
        dojo.hostenv._println_buffer = [];
        dojo.hostenv._println_safe = false;
        dojo.hostenv.println = function(/*String*/line){
                // summary:
                //              prints the provided line to whatever logging container is
                //              available. If the page isn't loaded yet, the line may be added
                //              to a buffer for printing later.
                if(!dojo.hostenv._println_safe){
                        dojo.hostenv._println_buffer.push(line);
                }else{
                        try {
                                var console = document.getElementById(djConfig.debugContainerId ?
                                        djConfig.debugContainerId : dojo.hostenv.defaultDebugContainerId);
                                if(!console) { console = dojo.body(); }

                                var div = document.createElement("div");
                                div.appendChild(document.createTextNode(line));
                                console.appendChild(div);
                        } catch (e) {
                                try{
                                        // safari needs the output wrapped in an element for some reason
                                        document.write("<div>" + line + "</div>");
                                }catch(e2){
                                        window.status = line;
                                }
                        }
                }
        }

        dojo.addOnLoad(function(){
                dojo.hostenv._println_safe = true;
                while(dojo.hostenv._println_buffer.length > 0){
                        dojo.hostenv.println(dojo.hostenv._println_buffer.shift());
                }
        });

        function dj_addNodeEvtHdlr(/*DomNode*/node, /*String*/evtName, /*Function*/fp){
                // summary:
                //              non-destructively adds the specified function to the node's
                //              evtName handler.
                // node: the DomNode to add the handler to
                // evtName: should be in the form "click" for "onclick" handlers
                var oldHandler = node["on"+evtName] || function(){};
                node["on"+evtName] = function(){
                        fp.apply(node, arguments);
                        oldHandler.apply(node, arguments);
                }
                return true;
        }

        dojo.hostenv._djInitFired = false;
        //      BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/)
        function dj_load_init(e){
                dojo.hostenv._djInitFired = true;
                // allow multiple calls, only first one will take effect
                // A bug in khtml calls events callbacks for document for event which isnt supported
                // for example a created contextmenu event calls DOMContentLoaded, workaround
                var type = (e && e.type) ? e.type.toLowerCase() : "load";
                if(arguments.callee.initialized || (type!="domcontentloaded" && type!="load")){ return; }
                arguments.callee.initialized = true;
                if(typeof(_timer) != 'undefined'){
                        clearInterval(_timer);
                        delete _timer;
                }

                var initFunc = function(){
                        //perform initialization
                        if(dojo.render.html.ie){
                                dojo.hostenv.makeWidgets();
                        }
                };

                if(dojo.hostenv.inFlightCount == 0){
                        initFunc();
                        dojo.hostenv.modulesLoaded();
                }else{
                        //This else case should be xdomain loading.
                        //Make sure this is the first thing in the load listener array.
                        //Part of the dojo.addOnLoad guarantee is that when the listeners are notified,
                        //It means the DOM (or page) has loaded and that widgets have been parsed.
                        dojo.hostenv.modulesLoadedListeners.unshift(initFunc);
                }
        }

        //      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.render.html.opera || (dojo.render.html.moz && (djConfig["enableMozDomContentLoaded"] === true))){
                        document.addEventListener("DOMContentLoaded", dj_load_init, 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", dj_load_init, null);
        }

        //      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.render.html.ie && dojo.render.os.win){
                document.attachEvent("onreadystatechange", function(e){
                        if(document.readyState == "complete"){
                                dj_load_init();
                        }
                });
        }

        if (/(WebKit|khtml)/i.test(navigator.userAgent)) { // sniff
                var _timer = setInterval(function() {
                        if (/loaded|complete/.test(document.readyState)) {
                                dj_load_init(); // call the onload handler
                        }
                }, 10);
        }
        //      END DOMContentLoaded

        // IE WebControl hosted in an application can fire "beforeunload" and "unload"
        // events when control visibility changes, causing Dojo to unload too soon. The
        // following code fixes the problem
        // Reference: http://support.microsoft.com/default.aspx?scid=kb;en-us;199155
        if(dojo.render.html.ie){
                dj_addNodeEvtHdlr(window, "beforeunload", function(){
                        dojo.hostenv._unloading = true;
                        window.setTimeout(function() {
                                dojo.hostenv._unloading = false;
                        }, 0);
                });
        }

        dj_addNodeEvtHdlr(window, "unload", function(){
                dojo.hostenv.unloaded();
                if((!dojo.render.html.ie)||(dojo.render.html.ie && dojo.hostenv._unloading)){
                        dojo.hostenv.unloaded();
                }
        });

        dojo.hostenv.makeWidgets = function(){
                // you can put searchIds in djConfig and dojo.hostenv at the moment
                // we should probably eventually move to one or the other
                var sids = [];
                if(djConfig.searchIds && djConfig.searchIds.length > 0) {
                        sids = sids.concat(djConfig.searchIds);
                }
                if(dojo.hostenv.searchIds && dojo.hostenv.searchIds.length > 0) {
                        sids = sids.concat(dojo.hostenv.searchIds);
                }

                if((djConfig.parseWidgets)||(sids.length > 0)){
                        if(dojo.evalObjPath("dojo.widget.Parse")){
                                // we must do this on a delay to avoid:
                                //      http://www.shaftek.org/blog/archives/000212.html
                                // (IE bug)
                                        var parser = new dojo.xml.Parse();
                                        if(sids.length > 0){
                                                for(var x=0; x<sids.length; x++){
                                                        var tmpNode = document.getElementById(sids[x]);
                                                        if(!tmpNode){ continue; }
                                                        var frag = parser.parseElement(tmpNode, null, true);
                                                        dojo.widget.getParser().createComponents(frag);
                                                }
                                        }else if(djConfig.parseWidgets){
                                                var frag  = parser.parseElement(dojo.body(), null, true);
                                                dojo.widget.getParser().createComponents(frag);
                                        }
                        }
                }
        }

        dojo.addOnLoad(function(){
                if(!dojo.render.html.ie) {
                        dojo.hostenv.makeWidgets();
                }
        });

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

        // stub, over-ridden by debugging code. This will at least keep us from
        // breaking when it's not included
        dojo.hostenv.writeIncludes = function(){}

        //TODOC:  HOW TO DOC THIS?
        // @global: dj_currentDocument
        // summary:
        //              Current document object. 'dj_currentDocument' can be modified for temporary context shifting.
        // description:
        //    dojo.doc() returns dojo.currentDocument.
        //              Refer to dojo.doc() rather than referring to 'window.document' to ensure your
        //              code runs correctly in managed contexts.
        if(!dj_undef("document", this)){
                dj_currentDocument = this.document;
        }

        dojo.doc = function(){
                // summary:
                //              return the document object associated with the dojo.global()
                return dj_currentDocument;
        }

        dojo.body = function(){
                // summary:
                //              return the body object associated with dojo.doc()
                // Note: document.body is not defined for a strict xhtml document
                return dojo.doc().body || dojo.doc().getElementsByTagName("body")[0];
        }

        dojo.byId = function(/*String*/id, /*DocumentElement*/doc){
                // summary:
                //              similar to other library's "$" function, takes a string
                //              representing a DOM id or a DomNode and returns the
                //              corresponding DomNode. If a Node is passed, this function is a
                //              no-op. Returns a single DOM node or null, working around
                //              several browser-specific bugs to do so.
                // id: DOM id or DOM Node
                // doc:
                //              optional, defaults to the current value of dj_currentDocument.
                //              Can be used to retreive node references from other documents.
                if((id)&&((typeof id == "string")||(id instanceof String))){
                        if(!doc){ doc = dj_currentDocument; }
                        var ele = doc.getElementById(id);
                        // workaround bug in IE and Opera 8.2 where getElementById returns wrong element
                        if(ele && (ele.id != id) && doc.all){
                                ele = null;
                                // get all matching elements with this id
                                eles = doc.all[id];
                                if(eles){
                                        // if more than 1, choose first with the correct id
                                        if(eles.length){
                                                for(var i=0; i<eles.length; i++){
                                                        if(eles[i].id == id){
                                                                ele = eles[i];
                                                                break;
                                                        }
                                                }
                                        // return 1 and only element
                                        }else{
                                                ele = eles;
                                        }
                                }
                        }
                        return ele; // DomNode
                }
                return id; // DomNode
        }

        dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
                // summary:
                //              changes the behavior of many core Dojo functions that deal with
                //              namespace and DOM lookup, changing them to work in a new global
                //              context. The varibles dj_currentContext and dj_currentDocument
                //              are modified as a result of calling this function.
                dj_currentContext = globalObject;
                dj_currentDocument = globalDocument;
        };

        dojo._fireCallback = function(callback, context, cbArguments){
                if((context)&&((typeof callback == "string")||(callback instanceof String))){
                        callback=context[callback];
                }
                return (context ? callback.apply(context, cbArguments || [ ]) : callback());
        }

        dojo.withGlobal = function(/*Object*/globalObject, /*Function*/callback, /*Object?*/thisObject, /*Array?*/cbArguments){
                // summary:
                //              Call callback with globalObject as dojo.global() and globalObject.document
                //              as dojo.doc(). If provided, globalObject will be executed in the context of
                //              object thisObject
                // description:
                //              When callback() returns or throws an error, the dojo.global() and dojo.doc() will
                //              be restored to its previous state.
                var rval;
                var oldGlob = dj_currentContext;
                var oldDoc = dj_currentDocument;
                try{
                        dojo.setContext(globalObject, globalObject.document);
                        rval = dojo._fireCallback(callback, thisObject, cbArguments);
                }finally{
                        dojo.setContext(oldGlob, oldDoc);
                }
                return rval;
        }

        dojo.withDoc = function (/*Object*/documentObject, /*Function*/callback, /*Object?*/thisObject, /*Array?*/cbArguments) {
                // summary:
                //              Call callback with documentObject as dojo.doc(). If provided, callback will be executed
                //              in the context of object thisObject
                // description:
                //              When callback() returns or throws an error, the dojo.doc() will
                //              be restored to its previous state.
                var rval;
                var oldDoc = dj_currentDocument;
                try{
                        dj_currentDocument = documentObject;
                        rval = dojo._fireCallback(callback, thisObject, cbArguments);
                }finally{
                        dj_currentDocument = oldDoc;
                }
                return rval;
        }

} //if (typeof window != 'undefined')

//Load debug code if necessary.
dojo.requireIf((djConfig["isDebug"] || djConfig["debugAtAllCosts"]), "dojo.debug");

//window.widget is for Dashboard detection
//The full conditionals are spelled out to avoid issues during builds.
//Builds may be looking for require/requireIf statements and processing them.
dojo.requireIf(djConfig["debugAtAllCosts"] && !window.widget && !djConfig["useXDomain"], "dojo.browser_debug");
dojo.requireIf(djConfig["debugAtAllCosts"] && !window.widget && djConfig["useXDomain"], "dojo.browser_debug_xd");

dojo.provide("dojo.string.common");

dojo.string.trim = function(/* string */str, /* integer? */wh){
        //      summary
        //      Trim whitespace from str.  If wh > 0, trim from start, if wh < 0, trim from end, else both
        if(!str.replace){ return str; }
        if(!str.length){ return str; }
        var re = (wh > 0) ? (/^\s+/) : (wh < 0) ? (/\s+$/) : (/^\s+|\s+$/g);
        return str.replace(re, "");     //      string
}

dojo.string.trimStart = function(/* string */str) {
        //      summary
        //      Trim whitespace at the beginning of 'str'
        return dojo.string.trim(str, 1);        //      string
}

dojo.string.trimEnd = function(/* string */str) {
        //      summary
        //      Trim whitespace at the end of 'str'
        return dojo.string.trim(str, -1);
}

dojo.string.repeat = function(/* string */str, /* integer */count, /* string? */separator) {
        //      summary
        //      Return 'str' repeated 'count' times, optionally placing 'separator' between each rep
        var out = "";
        for(var i = 0; i < count; i++) {
                out += str;
                if(separator && i < count - 1) {
                        out += separator;
                }
        }
        return out;     //      string
}

dojo.string.pad = function(/* string */str, /* integer */len/*=2*/, /* string */ c/*='0'*/, /* integer */dir/*=1*/) {
        //      summary
        //      Pad 'str' to guarantee that it is at least 'len' length with the character 'c' at either the 
        //      start (dir=1) or end (dir=-1) of the string
        var out = String(str);
        if(!c) {
                c = '0';
        }
        if(!dir) {
                dir = 1;
        }
        while(out.length < len) {
                if(dir > 0) {
                        out = c + out;
                } else {
                        out += c;
                }
        }
        return out;     //      string
}

dojo.string.padLeft = function(/* string */str, /* integer */len, /* string */c) {
        //      summary
        //      same as dojo.string.pad(str, len, c, 1)
        return dojo.string.pad(str, len, c, 1); //      string
}

dojo.string.padRight = function(/* string */str, /* integer */len, /* string */c) {
        //      summary
        //      same as dojo.string.pad(str, len, c, -1)
        return dojo.string.pad(str, len, c, -1);        //      string
}

dojo.provide("dojo.string");


dojo.provide("dojo.lang.common");

dojo.lang.inherits = function(/*Function*/subclass, /*Function*/superclass){
        // summary: Set up inheritance between two classes.
        if(!dojo.lang.isFunction(superclass)){ 
                dojo.raise("dojo.inherits: superclass argument ["+superclass+"] must be a function (subclass: ["+subclass+"']");
        }
        subclass.prototype = new superclass();
        subclass.prototype.constructor = subclass;
        subclass.superclass = superclass.prototype;
        // DEPRECATED: super is a reserved word, use 'superclass'
        subclass['super'] = superclass.prototype;
}

dojo.lang._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.protoype
                if((typeof tobj[x] == "undefined") || (tobj[x] != props[x])){
                        obj[x] = props[x];
                }
        }
        // IE doesn't recognize custom toStrings in for..in
        if(dojo.render.html.ie 
                && (typeof(props["toString"]) == "function")
                && (props["toString"] != obj["toString"])
                && (props["toString"] != tobj["toString"]))
        {
                obj.toString = props.toString;
        }
        return obj; // Object
}

dojo.lang.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++){
                dojo.lang._mixin(obj, arguments[i]);
        }
        return obj; // Object
}

dojo.lang.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.lang._mixin(constructor.prototype, arguments[i]);
        }
        return constructor; // Object
}

// Promote to dojo module
dojo.inherits = dojo.lang.inherits;
//dojo.lang._mixin = dojo.lang._mixin;
dojo.mixin = dojo.lang.mixin;
dojo.extend = dojo.lang.extend;

dojo.lang.find = function(      /*Array*/               array, 
                                                        /*Object*/              value,
                                                        /*Boolean?*/    identity,
                                                        /*Boolean?*/    findLast){
        // summary:     
        //              Return the index of value in array, returning -1 if not found.
        // array: just what you think
        // value: the value to locate
        // identity: 
        //              If true, matches with identity comparison (===). If false, uses
        //              normal comparison (==).
        // findLast: 
        //              If true, returns index of last instance of value.
        // examples:
        //              find(array, value[, identity [findLast]]) // recommended
        //              find(value, array[, identity [findLast]]) // deprecated
                                                        
        // support both (array, value) and (value, array)
        if(!dojo.lang.isArrayLike(array) && dojo.lang.isArrayLike(value)) {
                dojo.deprecated('dojo.lang.find(value, array)', 'use dojo.lang.find(array, value) instead', "0.5");
                var temp = array;
                array = value;
                value = temp;
        }
        var isString = dojo.lang.isString(array);
        if(isString) { array = array.split(""); }

        if(findLast) {
                var step = -1;
                var i = array.length - 1;
                var end = -1;
        } else {
                var step = 1;
                var i = 0;
                var end = array.length;
        }
        if(identity){
                while(i != end) {
                        if(array[i] === value){ return i; }
                        i += step;
                }
        }else{
                while(i != end) {
                        if(array[i] == value){ return i; }
                        i += step;
                }
        }
        return -1;      // number
}

dojo.lang.indexOf = dojo.lang.find;

dojo.lang.findLast = function(/*Array*/array, /*Object*/value, /*boolean?*/identity){
        // summary:
        //              Return index of last occurance of value in array, returning -1 if
        //              not found. This is a shortcut for dojo.lang.find() with a true
        //              value for its "findLast" parameter.
        // identity:
        //              If true, matches with identity comparison (===). If false, uses
        //              normal comparison (==).
        return dojo.lang.find(array, value, identity, true); // number
}

dojo.lang.lastIndexOf = dojo.lang.findLast;

dojo.lang.inArray = function(array /*Array*/, value /*Object*/){
        // summary:     Return true if value is present in array.
        return dojo.lang.find(array, value) > -1; // boolean
}

/**
 * Partial implmentation of is* functions from
 * http://www.crockford.com/javascript/recommend.html
 * NOTE: some of these may not be the best thing to use in all situations
 * as they aren't part of core JS and therefore can't work in every case.
 * See WARNING messages inline for tips.
 *
 * The following is* functions are fairly "safe"
 */

dojo.lang.isObject = function(/*anything*/ it){
        // summary:     Return true if it is an Object, Array or Function.
        if(typeof it == "undefined"){ return false; }
        return (typeof it == "object" || it === null || dojo.lang.isArray(it) || dojo.lang.isFunction(it)); // Boolean
}

dojo.lang.isArray = function(/*anything*/ it){
        // summary:     Return true if it is an Array.
        return (it && it instanceof Array || typeof it == "array"); // Boolean
}

dojo.lang.isArrayLike = function(/*anything*/ it){
        // summary:     
        //              Return true if it can be used as an array (i.e. is an object with
        //              an integer length property).
        if((!it)||(dojo.lang.isUndefined(it))){ return false; }
        if(dojo.lang.isString(it)){ return false; }
        if(dojo.lang.isFunction(it)){ return false; } // keeps out built-in constructors (Number, String, ...) which have length properties
        if(dojo.lang.isArray(it)){ return true; }
        // form node itself is ArrayLike, but not always iterable. Use form.elements instead.
        if((it.tagName)&&(it.tagName.toLowerCase()=='form')){ return false; }
        if(dojo.lang.isNumber(it.length) && isFinite(it.length)){ return true; }
        return false; // Boolean
}

dojo.lang.isFunction = function(/*anything*/ it){
        // summary:     Return true if it is a Function.
        return (it instanceof Function || typeof it == "function"); // Boolean
};

(function(){
        // webkit treats NodeList as a function, which is bad
        if((dojo.render.html.capable)&&(dojo.render.html["safari"])){
                dojo.lang.isFunction = function(/*anything*/ it){
                        if((typeof(it) == "function") && (it == "[object NodeList]")) { return false; }
                        return (it instanceof Function || typeof it == "function"); // Boolean
                }
        }
})();

dojo.lang.isString = function(/*anything*/ it){
        // summary:     Return true if it is a String.
        return (typeof it == "string" || it instanceof String);
}

dojo.lang.isAlien = function(/*anything*/ it){
        // summary: Return true if it is not a built-in function. False if not.
        if(!it){ return false; }
        return !dojo.lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
}

dojo.lang.isBoolean = function(/*anything*/ it){
        // summary:     Return true if it is a Boolean.
        return (it instanceof Boolean || typeof it == "boolean"); // Boolean
}

/**
 * The following is***() functions are somewhat "unsafe". Fortunately,
 * there are workarounds the the language provides and are mentioned
 * in the WARNING messages.
 *
 */
dojo.lang.isNumber = function(/*anything*/ it){
        // summary:     Return true if it is a number.
        // description: 
        //              WARNING - In most cases, isNaN(it) is sufficient to determine whether or not
        //              something is a number or can be used as such. For example, a number or string
        //              can be used interchangably when accessing array items (array["1"] is the same as
        //              array[1]) and isNaN will return false for both values ("1" and 1). However,
        //              isNumber("1")  will return false, which is generally not too useful.
        //              Also, isNumber(NaN) returns true, again, this isn't generally useful, but there
        //              are corner cases (like when you want to make sure that two things are really
        //              the same type of thing). That is really where isNumber "shines".
        //
        // Recommendation - Use isNaN(it) when possible
        
        return (it instanceof Number || typeof it == "number"); // Boolean
}

/*
 * FIXME: Should isUndefined go away since it is error prone?
 */
dojo.lang.isUndefined = function(/*anything*/ it){
        // summary: Return true if it is not defined.
        // description: 
        //              WARNING - In some cases, isUndefined will not behave as you
        //              might expect. If you do isUndefined(foo) and there is no earlier
        //              reference to foo, an error will be thrown before isUndefined is
        //              called. It behaves correctly if you scope yor object first, i.e.
        //              isUndefined(foo.bar) where foo is an object and bar isn't a
        //              property of the object.
        //
        // Recommendation - Use typeof foo == "undefined" when possible

        return ((typeof(it) == "undefined")&&(it == undefined)); // Boolean
}

// end Crockford functions

dojo.provide("dojo.lang.extras");



dojo.lang.setTimeout = function(/*Function*/func, /*int*/delay /*, ...*/){
        // summary:
        //              Sets a timeout in milliseconds to execute a function in a given
        //              context with optional arguments.
        // usage:
        //              dojo.lang.setTimeout(Object context, function func, number delay[, arg1[, ...]]);
        //              dojo.lang.setTimeout(function func, number delay[, arg1[, ...]]);

        var context = window, argsStart = 2;
        if(!dojo.lang.isFunction(func)){
                context = func;
                func = delay;
                delay = arguments[2];
                argsStart++;
        }

        if(dojo.lang.isString(func)){
                func = context[func];
        }
        
        var args = [];
        for (var i = argsStart; i < arguments.length; i++){
                args.push(arguments[i]);
        }
        return dojo.global().setTimeout(function(){ func.apply(context, args); }, delay); // int
}

dojo.lang.clearTimeout = function(/*int*/timer){
        // summary: clears timer by number from the execution queue

        // FIXME:
        //              why do we have this function? It's not portable outside of browser
        //              environments and it's a stupid wrapper on something that browsers
        //              provide anyway.
        dojo.global().clearTimeout(timer);
}

dojo.lang.getNameInObj = function(/*Object*/ns, /*unknown*/item){
        // summary: 
        //              looks for a value in the object ns with a value matching item and
        //              returns the property name
        // ns: if null, dj_global is used
        // item: value to return a name for
        if(!ns){ ns = dj_global; }

        for(var x in ns){
                if(ns[x] === item){
                        return new String(x); // String
                }
        }
        return null; // null
}

dojo.lang.shallowCopy = function(/*Object*/obj, /*Boolean?*/deep){
        // summary:
        //              copies object obj one level deep, or full depth if deep is true
        var i, ret;     

        if(obj === null){ /*obj: null*/ return null; } // null
        
        if(dojo.lang.isObject(obj)){
                // obj: Object  
                ret = new obj.constructor();
                for(i in obj){
                        if(dojo.lang.isUndefined(ret[i])){
                                ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i];
                        }
                }
        }else if(dojo.lang.isArray(obj)){
                // obj: Array
                ret = [];
                for(i=0; i<obj.length; i++){
                        ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i];
                }
        }else{
                // obj: Object
                ret = obj;
        }

        return ret; // Object
}

dojo.lang.firstValued = function(/* ... */){
        // summary: Return the first argument that isn't undefined

        for(var i = 0; i < arguments.length; i++){
                if(typeof arguments[i] != "undefined"){
                        return arguments[i]; // Object
                }
        }
        return undefined; // undefined
}

dojo.lang.getObjPathValue = function(/*String*/objpath, /*Object?*/context, /*Boolean?*/create){
        // summary:
        //              Gets a value from a reference specified as a string descriptor,
        //              (e.g. "A.B") in the given context.
        // context: if not specified, dj_global is used
        // create: if true, undefined objects in the path are created.
        with(dojo.parseObjPath(objpath, context, create)){
                return dojo.evalProp(prop, obj, create); // Object
        }
}

dojo.lang.setObjPathValue = function(/*String*/objpath, /*anything*/value, /*Object?*/context, /*Boolean?*/create){
        // summary:
        //              Sets a value on a reference specified as a string descriptor.
        //              (e.g. "A.B") in the given context. This is similar to straight
        //              assignment, except that the object structure in question can
        //              optionally be created if it does not exist.
        //      context: if not specified, dj_global is used
        //      create: if true, undefined objects in the path are created.

        // FIXME: why is this function valuable? It should be scheduled for
        // removal on the grounds that dojo.parseObjPath does most of it's work and
        // is more straightforward and has fewer dependencies. Also, the order of
        // arguments is bone-headed. "context" should clearly come after "create".
        // *sigh*
        dojo.deprecated("dojo.lang.setObjPathValue", "use dojo.parseObjPath and the '=' operator", "0.6");

        if(arguments.length < 4){
                create = true;
        }
        with(dojo.parseObjPath(objpath, context, create)){
                if(obj && (create || (prop in obj))){
                        obj[prop] = value;
                }
        }
}

dojo.provide("dojo.io.common");



/******************************************************************************
 *      Notes about dojo.io design:
 *      
 *      The dojo.io.* package has the unenviable task of making a lot of different
 *      types of I/O feel natural, despite a universal lack of good (or even
 *      reasonable!) I/O capability in the host environment. So lets pin this down
 *      a little bit further.
 *
 *      Rhino:
 *              perhaps the best situation anywhere. Access to Java classes allows you
 *              to do anything one might want in terms of I/O, both synchronously and
 *              async. Can open TCP sockets and perform low-latency client/server
 *              interactions. HTTP transport is available through Java HTTP client and
 *              server classes. Wish it were always this easy.
 *
 *      xpcshell:
 *              XPCOM for I/O.
 *
 *      spidermonkey:
 *              S.O.L.
 *
 *      Browsers:
 *              Browsers generally do not provide any useable filesystem access. We are
 *              therefore limited to HTTP for moving information to and from Dojo
 *              instances living in a browser.
 *
 *              XMLHTTP:
 *                      Sync or async, allows reading of arbitrary text files (including
 *                      JS, which can then be eval()'d), writing requires server
 *                      cooperation and is limited to HTTP mechanisms (POST and GET).
 *
 *              <iframe> hacks:
 *                      iframe document hacks allow browsers to communicate asynchronously
 *                      with a server via HTTP POST and GET operations. With significant
 *                      effort and server cooperation, low-latency data transit between
 *                      client and server can be acheived via iframe mechanisms (repubsub).
 *
 *              SVG:
 *                      Adobe's SVG viewer implements helpful primitives for XML-based
 *                      requests, but receipt of arbitrary text data seems unlikely w/o
 *                      <![CDATA[]]> sections.
 *
 *
 *      A discussion between Dylan, Mark, Tom, and Alex helped to lay down a lot
 *      the IO API interface. A transcript of it can be found at:
 *              http://dojotoolkit.org/viewcvs/viewcvs.py/documents/irc/irc_io_api_log.txt?rev=307&view=auto
 *      
 *      Also referenced in the design of the API was the DOM 3 L&S spec:
 *              http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save.html
 ******************************************************************************/

// a map of the available transport options. Transports should add themselves
// by calling add(name)
dojo.io.transports = [];
dojo.io.hdlrFuncNames = [ "load", "error", "timeout" ]; // we're omitting a progress() event for now

dojo.io.Request = function(/*String*/ url, /*String*/ mimetype, /*String*/ transport, /*String or Boolean*/ changeUrl){
// summary:
//              Constructs a Request object that is used by dojo.io.bind().
// description:
//              dojo.io.bind() will create one of these for you if
//              you call dojo.io.bind() with an plain object containing the bind parameters.
//              This method can either take the arguments specified, or an Object containing all of the parameters that you
//              want to use to create the dojo.io.Request (similar to how dojo.io.bind() is called.
//              The named parameters to this constructor represent the minimum set of parameters need
        if((arguments.length == 1)&&(arguments[0].constructor == Object)){
                this.fromKwArgs(arguments[0]);
        }else{
                this.url = url;
                if(mimetype){ this.mimetype = mimetype; }
                if(transport){ this.transport = transport; }
                if(arguments.length >= 4){ this.changeUrl = changeUrl; }
        }
}

dojo.lang.extend(dojo.io.Request, {

        /** The URL to hit */
        url: "",
        
        /** The mime type used to interrpret the response body */
        mimetype: "text/plain",
        
        /** The HTTP method to use */
        method: "GET",
        
        /** An Object containing key-value pairs to be included with the request */
        content: undefined, // Object
        
        /** The transport medium to use */
        transport: undefined, // String
        
        /** If defined the URL of the page is physically changed */
        changeUrl: undefined, // String
        
        /** A form node to use in the request */
        formNode: undefined, // HTMLFormElement
        
        /** Whether the request should be made synchronously */
        sync: false,
        
        bindSuccess: false,

        /** Cache/look for the request in the cache before attempting to request?
         *  NOTE: this isn't a browser cache, this is internal and would only cache in-page
         */
        useCache: false,

        /** Prevent the browser from caching this by adding a query string argument to the URL */
        preventCache: false,

        jsonFilter: function(value){
                if(     (this.mimetype == "text/json-comment-filtered")||
                        (this.mimetype == "application/json-comment-filtered")
                ){
                        var cStartIdx = value.indexOf("\/*");
                        var cEndIdx = value.lastIndexOf("*\/");
                        if((cStartIdx == -1)||(cEndIdx == -1)){
                                dojo.debug("your JSON wasn't comment filtered!"); // FIXME: throw exception instead?
                                return "";
                        }
                        return value.substring(cStartIdx+2, cEndIdx);
                }
                dojo.debug("please consider using a mimetype of text/json-comment-filtered to avoid potential security issues with JSON endpoints");
                return value;
        },
        
        // events stuff
        load: function(/*String*/type, /*Object*/data, /*Object*/transportImplementation, /*Object*/kwArgs){
                // summary:
                //              Called on successful completion of a bind.
                //              type: String
                //                              A string with value "load"
                //              data: Object
                //                              The object representing the result of the bind. The actual structure
                //                              of the data object will depend on the mimetype that was given to bind
                //                              in the bind arguments.
                //              transportImplementation: Object
                //                              The object that implements a particular transport. Structure is depedent
                //                              on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the
                //                              XMLHttpRequest object from the browser.
                //              kwArgs: Object
                //                              Object that contains the request parameters that were given to the
                //                              bind call. Useful for storing and retrieving state from when bind
                //                              was called.
        },
        error: function(/*String*/type, /*Object*/error, /*Object*/transportImplementation, /*Object*/kwArgs){
                // summary:
                //              Called when there is an error with a bind.
                //              type: String
                //                              A string with value "error"
                //              error: Object
                //                              The error object. Should be a dojo.io.Error object, but not guaranteed.
                //              transportImplementation: Object
                //                              The object that implements a particular transport. Structure is depedent
                //                              on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the
                //                              XMLHttpRequest object from the browser.
                //              kwArgs: Object
                //                              Object that contains the request parameters that were given to the
                //                              bind call. Useful for storing and retrieving state from when bind
                //                              was called.
        },
        timeout: function(/*String*/type, /*Object*/empty, /*Object*/transportImplementation, /*Object*/kwArgs){
                // summary:
                //              Called when there is an error with a bind. Only implemented in certain transports at this time.
                //              type: String
                //                              A string with value "timeout"
                //              empty: Object
                //                              Should be null. Just a spacer argument so that load, error, timeout and handle have the
                //                              same signatures.
                //              transportImplementation: Object
                //                              The object that implements a particular transport. Structure is depedent
                //                              on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the
                //                              XMLHttpRequest object from the browser. May be null for the timeout case for
                //                              some transports.
                //              kwArgs: Object
                //                              Object that contains the request parameters that were given to the
                //                              bind call. Useful for storing and retrieving state from when bind
                //                              was called.
        },
        handle: function(/*String*/type, /*Object*/data, /*Object*/transportImplementation, /*Object*/kwArgs){
                // summary:
                //              The handle method can be defined instead of defining separate load, error and timeout
                //              callbacks.
                //              type: String
                //                              A string with the type of callback: "load", "error", or "timeout".
                //              data: Object
                //                              See the above callbacks for what this parameter could be.
                //              transportImplementation: Object
                //                              The object that implements a particular transport. Structure is depedent
                //                              on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the
                //                              XMLHttpRequest object from the browser.
                //              kwArgs: Object
                //                              Object that contains the request parameters that were given to the
                //                              bind call. Useful for storing and retrieving state from when bind
                //                              was called.     
        },

        //FIXME: change IframeIO.js to use timeouts?
        // The number of seconds to wait until firing a timeout callback.
        // If it is zero, that means, don't do a timeout check.
        timeoutSeconds: 0,
        
        // the abort method needs to be filled in by the transport that accepts the
        // bind() request
        abort: function(){ },
        
        // backButton: function(){ },
        // forwardButton: function(){ },

        fromKwArgs: function(/*Object*/ kwArgs){
                // summary:
                //              Creates a dojo.io.Request from a simple object (kwArgs object).

                // normalize args
                if(kwArgs["url"]){ kwArgs.url = kwArgs.url.toString(); }
                if(kwArgs["formNode"]) { kwArgs.formNode = dojo.byId(kwArgs.formNode); }
                if(!kwArgs["method"] && kwArgs["formNode"] && kwArgs["formNode"].method) {
                        kwArgs.method = kwArgs["formNode"].method;
                }
                
                // backwards compatibility
                if(!kwArgs["handle"] && kwArgs["handler"]){ kwArgs.handle = kwArgs.handler; }
                if(!kwArgs["load"] && kwArgs["loaded"]){ kwArgs.load = kwArgs.loaded; }
                if(!kwArgs["changeUrl"] && kwArgs["changeURL"]) { kwArgs.changeUrl = kwArgs.changeURL; }

                // encoding fun!
                kwArgs.encoding = dojo.lang.firstValued(kwArgs["encoding"], djConfig["bindEncoding"], "");

                kwArgs.sendTransport = dojo.lang.firstValued(kwArgs["sendTransport"], djConfig["ioSendTransport"], false);

                var isFunction = dojo.lang.isFunction;
                for(var x=0; x<dojo.io.hdlrFuncNames.length; x++){
                        var fn = dojo.io.hdlrFuncNames[x];
                        if(kwArgs[fn] && isFunction(kwArgs[fn])){ continue; }
                        if(kwArgs["handle"] && isFunction(kwArgs["handle"])){
                                kwArgs[fn] = kwArgs.handle;
                        }
                        // handler is aliased above, shouldn't need this check
                        /* else if(dojo.lang.isObject(kwArgs.handler)){
                                if(isFunction(kwArgs.handler[fn])){
                                        kwArgs[fn] = kwArgs.handler[fn]||kwArgs.handler["handle"]||function(){};
                                }
                        }*/
                }
                dojo.lang.mixin(this, kwArgs);
        }

});

dojo.io.Error = function(/*String*/ msg, /*String*/ type, /*Number*/num){
        // summary:
        //              Constructs an object representing a bind error.
        this.message = msg;
        this.type =  type || "unknown"; // must be one of "io", "parse", "unknown"
        this.number = num || 0; // per-substrate error number, not normalized
}

dojo.io.transports.addTransport = function(/*String*/name){
        // summary:
        //              Used to register transports that can support bind calls.
        this.push(name);
        // FIXME: do we need to handle things that aren't direct children of the
        // dojo.io module? (say, dojo.io.foo.fooTransport?)
        this[name] = dojo.io[name];
}

// binding interface, the various implementations register their capabilities
// and the bind() method dispatches
dojo.io.bind = function(/*dojo.io.Request or Object*/request){
        // summary:
        //              Binding interface for IO. Loading different IO transports, like
        //              dojo.io.BrowserIO or dojo.io.IframeIO, will register with bind
        //              to handle particular types of bind calls.
        //              request: Object
        //                              Object containing bind arguments. This object is converted to
        //                              a dojo.io.Request object, and that request object is the return
        //                              value for this method.
        if(!(request instanceof dojo.io.Request)){
                try{
                        request = new dojo.io.Request(request);
                }catch(e){ dojo.debug(e); }
        }

        // if the request asks for a particular implementation, use it
        var tsName = "";
        if(request["transport"]){
                tsName = request["transport"];
                if(!this[tsName]){
                        dojo.io.sendBindError(request, "No dojo.io.bind() transport with name '"
                                + request["transport"] + "'.");
                        return request; //dojo.io.Request
                }
                if(!this[tsName].canHandle(request)){
                        dojo.io.sendBindError(request, "dojo.io.bind() transport with name '"
                                + request["transport"] + "' cannot handle this type of request.");
                        return request; //dojo.io.Request
                }
        }else{
                // otherwise we do our best to auto-detect what available transports
                // will handle 
                for(var x=0; x<dojo.io.transports.length; x++){
                        var tmp = dojo.io.transports[x];
                        if((this[tmp])&&(this[tmp].canHandle(request))){
                                tsName = tmp;
                                break;
                        }
                }
                if(tsName == ""){
                        dojo.io.sendBindError(request, "None of the loaded transports for dojo.io.bind()"
                                + " can handle the request.");
                        return request; //dojo.io.Request
                }
        }
        this[tsName].bind(request);
        request.bindSuccess = true;
        return request; //dojo.io.Request
}

dojo.io.sendBindError = function(/* Object */request, /* String */message){
        // summary:
        //              Used internally by dojo.io.bind() to return/raise a bind error.

        //Need to be careful since not all hostenvs support setTimeout.
        if((typeof request.error == "function" || typeof request.handle == "function")
                && (typeof setTimeout == "function" || typeof setTimeout == "object")){
                var errorObject = new dojo.io.Error(message);
                setTimeout(function(){
                        request[(typeof request.error == "function") ? "error" : "handle"]("error", errorObject, null, request);
                }, 50);
        }else{
                dojo.raise(message);
        }
}

dojo.io.queueBind = function(/*dojo.io.Request or Object*/request){
        // summary:
        //              queueBind will use dojo.io.bind() but guarantee that only one bind
        //              call is handled at a time.
        // description:
        //              If queueBind is called while a bind call
        //              is in process, it will queue up the other calls to bind and call them
        //              in order as bind calls complete.
        //              request: Object
        //                      Same sort of request object as used for dojo.io.bind().
        if(!(request instanceof dojo.io.Request)){
                try{
                        request = new dojo.io.Request(request);
                }catch(e){ dojo.debug(e); }
        }

        // make sure we get called if/when we get a response
        var oldLoad = request.load;
        request.load = function(){
                dojo.io._queueBindInFlight = false;
                var ret = oldLoad.apply(this, arguments);
                dojo.io._dispatchNextQueueBind();
                return ret;
        }

        var oldErr = request.error;
        request.error = function(){
                dojo.io._queueBindInFlight = false;
                var ret = oldErr.apply(this, arguments);
                dojo.io._dispatchNextQueueBind();
                return ret;
        }

        dojo.io._bindQueue.push(request);
        dojo.io._dispatchNextQueueBind();
        return request; //dojo.io.Request
}

dojo.io._dispatchNextQueueBind = function(){
        // summary:
        //      Private method used by dojo.io.queueBind().
        if(!dojo.io._queueBindInFlight){
                dojo.io._queueBindInFlight = true;
                if(dojo.io._bindQueue.length > 0){
                        dojo.io.bind(dojo.io._bindQueue.shift());
                }else{
                        dojo.io._queueBindInFlight = false;
                }
        }
}
dojo.io._bindQueue = [];
dojo.io._queueBindInFlight = false;

dojo.io.argsFromMap = function(/*Object*/map, /*String?*/encoding, /*String?*/last){
        // summary:
        //              Converts name/values pairs in the map object to an URL-encoded string
        //              with format of name1=value1&name2=value2...
        //              map: Object
        //                      Object that has the contains the names and values.
        //              encoding: String?
        //                      String to specify how to encode the name and value. If the encoding string
        //                      contains "utf" (case-insensitive), then encodeURIComponent is used. Otherwise
        //                      dojo.string.encodeAscii is used.
        //              last: String?
        //                      The last parameter in the list. Helps with final string formatting?
        var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii;
        var mapped = [];
        var control = new Object();
        for(var name in map){
                var domap = function(elt){
                        var val = enc(name)+"="+enc(elt);
                        mapped[(last == name) ? "push" : "unshift"](val);
                }
                if(!control[name]){
                        var value = map[name];
                        // FIXME: should be isArrayLike?
                        if (dojo.lang.isArray(value)){
                                dojo.lang.forEach(value, domap);
                        }else{
                                domap(value);
                        }
                }
        }
        return mapped.join("&"); //String
}

dojo.io.setIFrameSrc = function(/*DOMNode*/ iframe, /*String*/ src, /*Boolean*/ replace){
        //summary:
        //              Sets the URL that is loaded in an IFrame. The replace parameter indicates whether
        //              location.replace() should be used when changing the location of the iframe.
        try{
                var r = dojo.render.html;
                // dojo.debug(iframe);
                if(!replace){
                        if(r.safari){
                                iframe.location = src;
                        }else{
                                frames[iframe.name].location = src;
                        }
                }else{
                        // Fun with DOM 0 incompatibilities!
                        var idoc;
                        if(r.ie){
                                idoc = iframe.contentWindow.document;
                        }else if(r.safari){
                                idoc = iframe.document;
                        }else{ //  if(r.moz){
                                idoc = iframe.contentWindow;
                        }

                        //For Safari (at least 2.0.3) and Opera, if the iframe
                        //has just been created but it doesn't have content
                        //yet, then iframe.document may be null. In that case,
                        //use iframe.location and return.
                        if(!idoc){
                                iframe.location = src;
                                return;
                        }else{
                                idoc.location.replace(src);
                        }
                }
        }catch(e){ 
                dojo.debug(e); 
                dojo.debug("setIFrameSrc: "+e); 
        }
}

/*
dojo.io.sampleTranport = new function(){
        this.canHandle = function(kwArgs){
                // canHandle just tells dojo.io.bind() if this is a good transport to
                // use for the particular type of request.
                if(     
                        (
                                (kwArgs["mimetype"] == "text/plain") ||
                                (kwArgs["mimetype"] == "text/html") ||
                                (kwArgs["mimetype"] == "text/javascript")
                        )&&(
                                (kwArgs["method"] == "get") ||
                                ( (kwArgs["method"] == "post") && (!kwArgs["formNode"]) )
                        )
                ){
                        return true;
                }

                return false;
        }

        this.bind = function(kwArgs){
                var hdlrObj = {};

                // set up a handler object
                for(var x=0; x<dojo.io.hdlrFuncNames.length; x++){
                        var fn = dojo.io.hdlrFuncNames[x];
                        if(typeof kwArgs.handler == "object"){
                                if(typeof kwArgs.handler[fn] == "function"){
                                        hdlrObj[fn] = kwArgs.handler[fn]||kwArgs.handler["handle"];
                                }
                        }else if(typeof kwArgs[fn] == "function"){
                                hdlrObj[fn] = kwArgs[fn];
                        }else{
                                hdlrObj[fn] = kwArgs["handle"]||function(){};
                        }
                }

                // build a handler function that calls back to the handler obj
                var hdlrFunc = function(evt){
                        if(evt.type == "onload"){
                                hdlrObj.load("load", evt.data, evt);
                        }else if(evt.type == "onerr"){
                                var errObj = new dojo.io.Error("sampleTransport Error: "+evt.msg);
                                hdlrObj.error("error", errObj);
                        }
                }

                // the sample transport would attach the hdlrFunc() when sending the
                // request down the pipe at this point
                var tgtURL = kwArgs.url+"?"+dojo.io.argsFromMap(kwArgs.content);
                // sampleTransport.sendRequest(tgtURL, hdlrFunc);
        }

        dojo.io.transports.addTransport("sampleTranport");
}
*/

dojo.provide("dojo.lang.array");



// FIXME: Is this worthless since you can do: if(name in obj)
// is this the right place for this?

dojo.lang.mixin(dojo.lang, {
        has: function(/*Object*/obj, /*String*/name){
                // summary: is there a property with the passed name in obj?
                try{
                        return typeof obj[name] != "undefined"; // Boolean
                }catch(e){ return false; } // Boolean
        },

        isEmpty: function(/*Object*/obj){
                // summary:
                //              can be used to determine if the passed object is "empty". In
                //              the case of array-like objects, the length, property is
                //              examined, but for other types of objects iteration is used to
                //              examine the iterable "surface area" to determine if any
                //              non-prototypal properties have been assigned. This iteration is
                //              prototype-extension safe.
                if(dojo.lang.isObject(obj)){
                        var tmp = {};
                        var count = 0;
                        for(var x in obj){
                                if(obj[x] && (!tmp[x])){
                                        count++;
                                        break;
                                } 
                        }
                        return count == 0; // boolean
                }else if(dojo.lang.isArrayLike(obj) || dojo.lang.isString(obj)){
                        return obj.length == 0; // boolean
                }
        },

        map: function(/*Array*/arr, /*Object|Function*/obj, /*Function?*/unary_func){
                // summary:
                //              returns a new array constituded from the return values of
                //              passing each element of arr into unary_func. The obj parameter
                //              may be passed to enable the passed function to be called in
                //              that scope. In environments that support JavaScript 1.6, this
                //              function is a passthrough to the built-in map() function
                //              provided by Array instances. For details on this, see:
                //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:map
                // examples:
                //              dojo.lang.map([1, 2, 3, 4], function(item){ return item+1 });
                //              // returns [2, 3, 4, 5]
                var isString = dojo.lang.isString(arr);
                if(isString){
                        // arr: String
                        arr = arr.split("");
                }
                if(dojo.lang.isFunction(obj)&&(!unary_func)){
                        unary_func = obj;
                        obj = dj_global;
                }else if(dojo.lang.isFunction(obj) && unary_func){
                        // ff 1.5 compat
                        var tmpObj = obj;
                        obj = unary_func;
                        unary_func = tmpObj;
                }
                if(Array.map){
                        var outArr = Array.map(arr, unary_func, obj);
                }else{
                        var outArr = [];
                        for(var i=0;i<arr.length;++i){
                                outArr.push(unary_func.call(obj, arr[i]));
                        }
                }
                if(isString) {
                        return outArr.join(""); // String
                } else {
                        return outArr; // Array
                }
        },

        reduce: function(/*Array*/arr, initialValue, /*Object|Function*/obj, /*Function*/binary_func){
                // summary:
                //              similar to Python's builtin reduce() function. The result of
                //              the previous computation is passed as the first argument to
                //              binary_func along with the next value from arr. The result of
                //              this call is used along with the subsequent value from arr, and
                //              this continues until arr is exhausted. The return value is the
                //              last result. The "obj" and "initialValue" parameters may be
                //              safely omitted and the order of obj and binary_func may be
                //              reversed. The default order of the obj and binary_func argument
                //              will probably be reversed in a future release, and this call
                //              order is supported today.
                // examples:
                //              dojo.lang.reduce([1, 2, 3, 4], function(last, next){ return last+next});
                //              returns 10
                var reducedValue = initialValue;
                if(arguments.length == 2){
                        binary_func = initialValue;
                        reducedValue = arr[0];
                        arr = arr.slice(1);
                }else if(arguments.length == 3){
                        if(dojo.lang.isFunction(obj)){
                                binary_func = obj;
                                obj = null;
                        }
                }else{
                        // un-fsck the default order
                        // FIXME:
                        //              could be wrong for some strange function object cases. Not
                        //              sure how to test for them.
                        if(dojo.lang.isFunction(obj)){
                                var tmp = binary_func;
                                binary_func = obj;
                                obj = tmp;
                        }
                }

                var ob = obj || dj_global;
                dojo.lang.map(arr, 
                        function(val){
                                reducedValue = binary_func.call(ob, reducedValue, val);
                        }
                );
                return reducedValue;
        },

        forEach: function(/*Array*/anArray, /*Function*/callback, /*Object?*/thisObject){
                // summary:
                //              for every item in anArray, call callback with that item as its
                //              only parameter. Return values are ignored. This funciton
                //              corresponds (and wraps) the JavaScript 1.6 forEach method. For
                //              more details, see:
                //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:forEach
                if(dojo.lang.isString(anArray)){
                        // anArray: String
                        anArray = anArray.split(""); 
                }
                if(Array.forEach){
                        Array.forEach(anArray, callback, thisObject);
                }else{
                        // FIXME: there are several ways of handilng thisObject. Is dj_global always the default context?
                        if(!thisObject){
                                thisObject=dj_global;
                        }
                        for(var i=0,l=anArray.length; i<l; i++){ 
                                callback.call(thisObject, anArray[i], i, anArray);
                        }
                }
        },

        _everyOrSome: function(/*Boolean*/every, /*Array*/arr, /*Function*/callback, /*Object?*/thisObject){
                if(dojo.lang.isString(arr)){ 
                        //arr: String
                        arr = arr.split(""); 
                }
                if(Array.every){
                        return Array[ every ? "every" : "some" ](arr, callback, thisObject);
                }else{
                        if(!thisObject){
                                thisObject = dj_global;
                        }
                        for(var i=0,l=arr.length; i<l; i++){
                                var result = callback.call(thisObject, arr[i], i, arr);
                                if(every && !result){
                                        return false; // Boolean
                                }else if((!every)&&(result)){
                                        return true; // Boolean
                                }
                        }
                        return Boolean(every); // Boolean
                }
        },

        every: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){
                // summary:
                //              determines whether or not every item in the array satisfies the
                //              condition implemented by callback. thisObject may be used to
                //              scope the call to callback. The function signature is derived
                //              from the JavaScript 1.6 Array.every() function. More
                //              information on this can be found here:
                //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every
                // examples:
                //              dojo.lang.every([1, 2, 3, 4], function(item){ return item>1; });
                //              // returns false
                //              dojo.lang.every([1, 2, 3, 4], function(item){ return item>0; });
                //              // returns true 
                return this._everyOrSome(true, arr, callback, thisObject); // Boolean
        },

        some: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){
                // summary:
                //              determines whether or not any item in the array satisfies the
                //              condition implemented by callback. thisObject may be used to
                //              scope the call to callback. The function signature is derived
                //              from the JavaScript 1.6 Array.some() function. More
                //              information on this can be found here:
                //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some
                // examples:
                //              dojo.lang.some([1, 2, 3, 4], function(item){ return item>1; });
                //              // returns true
                //              dojo.lang.some([1, 2, 3, 4], function(item){ return item<1; });
                //              // returns false
                return this._everyOrSome(false, arr, callback, thisObject); // Boolean
        },

        filter: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){
                // summary:
                //              returns a new Array with those items from arr that match the
                //              condition implemented by callback.thisObject may be used to
                //              scope the call to callback. The function signature is derived
                //              from the JavaScript 1.6 Array.filter() function, although
                //              special accomidation is made in our implementation for strings.
                //              More information on the JS 1.6 API can be found here:
                //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:filter
                // examples:
                //              dojo.lang.some([1, 2, 3, 4], function(item){ return item>1; });
                //              // returns [2, 3, 4]
                var isString = dojo.lang.isString(arr);
                if(isString){ /*arr: String*/arr = arr.split(""); }
                var outArr;
                if(Array.filter){
                        outArr = Array.filter(arr, callback, thisObject);
                }else{
                        if(!thisObject){
                                if(arguments.length >= 3){ dojo.raise("thisObject doesn't exist!"); }
                                thisObject = dj_global;
                        }

                        outArr = [];
                        for(var i = 0; i < arr.length; i++){
                                if(callback.call(thisObject, arr[i], i, arr)){
                                        outArr.push(arr[i]);
                                }
                        }
                }
                if(isString){
                        return outArr.join(""); // String
                } else {
                        return outArr; // Array
                }
        },

        unnest: function(/* ... */){
                // summary:
                //              Creates a 1-D array out of all the arguments passed,
                //              unravelling any array-like objects in the process
                // usage:
                //              unnest(1, 2, 3) ==> [1, 2, 3]
                //              unnest(1, [2, [3], [[[4]]]]) ==> [1, 2, 3, 4]

                var out = [];
                for(var i = 0; i < arguments.length; i++){
                        if(dojo.lang.isArrayLike(arguments[i])){
                                var add = dojo.lang.unnest.apply(this, arguments[i]);
                                out = out.concat(add);
                        }else{
                                out.push(arguments[i]);
                        }
                }
                return out; // Array
        },

        toArray: function(/*Object*/arrayLike, /*Number*/startOffset){
                // summary:
                //              Converts an array-like object (i.e. arguments, DOMCollection)
                //              to an array. Returns a new Array object.
                var array = [];
                for(var i = startOffset||0; i < arrayLike.length; i++){
                        array.push(arrayLike[i]);
                }
                return array; // Array
        }
});

dojo.provide("dojo.lang.func");


dojo.lang.hitch = function(/*Object*/thisObject, /*Function|String*/method /*, ...*/){
        // summary: 
        //              Returns a function that will only ever execute in the a given scope
        //              (thisObject). 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. Note that the order of arguments may be
        //              reversed in a future version.
        // thisObject: the scope to run the method in
        // method:
        //              a function to be "bound" to thisObject or the name of the method in
        //              thisObject to be used as the basis for the binding
        // usage:
        //              dojo.lang.hitch(foo, "bar")(); // runs foo.bar() in the scope of foo
        //              dojo.lang.hitch(foo, myFunction); // returns a function that runs myFunction in the scope of foo

        var args = [];
        for(var x=2; x<arguments.length; x++){
                args.push(arguments[x]);
        }
        var fcn = (dojo.lang.isString(method) ? thisObject[method] : method) || function(){};
        return function(){
                var ta = args.concat([]); // make a copy
                for(var x=0; x<arguments.length; x++){
                        ta.push(arguments[x]);
                }
                return fcn.apply(thisObject, ta); // Function
                // return fcn.apply(thisObject, arguments); // Function
        };
}

dojo.lang.anonCtr = 0;
dojo.lang.anon = {};

dojo.lang.nameAnonFunc = function(/*Function*/anonFuncPtr, /*Object*/thisObj, /*Boolean*/searchForNames){
        // summary:
        //              Creates a reference to anonFuncPtr in thisObj with a completely
        //              unique name. The new name is returned as a String.  If
        //              searchForNames is true, an effort will be made to locate an
        //              existing reference to anonFuncPtr in thisObj, and if one is found,
        //              the existing name will be returned instead. The default is for
        //              searchForNames to be false.
        var nso = (thisObj|| dojo.lang.anon);
        if( (searchForNames) ||
                ((dj_global["djConfig"])&&(djConfig["slowAnonFuncLookups"] == true)) ){
                for(var x in nso){
                        try{
                                if(nso[x] === anonFuncPtr){
                                        return x;
                                }
                        }catch(e){} // window.external fails in IE embedded in Eclipse (Eclipse bug #151165)
                }
        }
        var ret = "__"+dojo.lang.anonCtr++;
        while(typeof nso[ret] != "undefined"){
                ret = "__"+dojo.lang.anonCtr++;
        }
        nso[ret] = anonFuncPtr;
        return ret; // String
}

dojo.lang.forward = function(funcName){
        // summary:
        //              Returns a function that forwards a method call to
        //              this.funcName(...).  Unlike dojo.lang.hitch(), the "this" scope is
        //              not fixed on a single object. Ported from MochiKit.
        return function(){
                return this[funcName].apply(this, arguments);
        }; // Function
}

dojo.lang.curry = function(thisObj, func /* args ... */){
        // summary:
        //              similar to the curry() method found in many functional programming
        //              environments, this function returns an "argument accumulator"
        //              function, bound to a particular scope, and "primed" with a variable
        //              number of arguments. The curry method is unique in that it returns
        //              a function that may return other "partial" function which can be
        //              called repeatedly. New functions are returned until the arity of
        //              the original function is reached, at which point the underlying
        //              function (func) is called in the scope thisObj with all of the
        //              accumulated arguments (plus any extras) in positional order.
        // examples:
        //              assuming a function defined like this:
        //                      var foo = {
        //                              bar: function(arg1, arg2, arg3){
        //                                      dojo.debug.apply(dojo, arguments);
        //                              }
        //                      };
        //              
        //              dojo.lang.curry() can be used most simply in this way:
        //              
        //                      tmp = dojo.lang.curry(foo, foo.bar, "arg one", "thinger");
        //                      tmp("blah", "this is superfluous");
        //                      // debugs: "arg one thinger blah this is superfluous"
        //                      tmp("blah");
        //                      // debugs: "arg one thinger blah"
        //                      tmp();
        //                      // returns a function exactly like tmp that expects one argument
        //
        //              other intermittent functions could be created until the 3
        //              positional arguments are filled:
        //
        //                      tmp = dojo.lang.curry(foo, foo.bar, "arg one");
        //                      tmp2 = tmp("arg two");
        //                      tmp2("blah blah");
        //                      // debugs: "arg one arg two blah blah"
        //                      tmp2("oy");
        //                      // debugs: "arg one arg two oy"
        //
        //              curry() can also be used to call the function if enough arguments
        //              are passed in the initial invocation:
        //
        //                      dojo.lang.curry(foo, foo.bar, "one", "two", "three", "four");
        //                      // debugs: "one two three four"
        //                      dojo.lang.curry(foo, foo.bar, "one", "two", "three");
        //                      // debugs: "one two three"


        // FIXME: the order of func and thisObj should be changed!!!
        var outerArgs = [];
        thisObj = thisObj||dj_global;
        if(dojo.lang.isString(func)){
                func = thisObj[func];
        }
        for(var x=2; x<arguments.length; x++){
                outerArgs.push(arguments[x]);
        }
        // since the event system replaces the original function with a new
        // join-point runner with an arity of 0, we check to see if it's left us
        // any clues about the original arity in lieu of the function's actual
        // length property
        var ecount = (func["__preJoinArity"]||func.length) - outerArgs.length;
        // borrowed from svend tofte
        function gather(nextArgs, innerArgs, expected){
                var texpected = expected;
                var totalArgs = innerArgs.slice(0); // copy
                for(var x=0; x<nextArgs.length; x++){
                        totalArgs.push(nextArgs[x]);
                }
                // check the list of provided nextArgs to see if it, plus the
                // number of innerArgs already supplied, meets the total
                // expected.
                expected = expected-nextArgs.length;
                if(expected<=0){
                        var res = func.apply(thisObj, totalArgs);
                        expected = texpected;
                        return res;
                }else{
                        return function(){
                                return gather(arguments,// check to see if we've been run
                                                                                // with enough args
                                                        totalArgs,      // a copy
                                                        expected);      // how many more do we need to run?;
                        };
                }
        }
        return gather([], outerArgs, ecount);
}

dojo.lang.curryArguments = function(/*Object*/thisObj, /*Function*/func, /*Array*/args, /*Integer, optional*/offset){
        // summary:
        //              similar to dojo.lang.curry(), except that a list of arguments to
        //              start the curry with may be provided as an array instead of as
        //              positional arguments. An offset may be specified from the 0 index
        //              to skip some elements in args.
        var targs = [];
        var x = offset||0;
        for(x=offset; x<args.length; x++){
                targs.push(args[x]); // ensure that it's an arr
        }
        return dojo.lang.curry.apply(dojo.lang, [thisObj, func].concat(targs));
}

dojo.lang.tryThese = function(/*...*/){
        // summary:
        //              executes each function argument in turn, returning the return value
        //              from the first one which does not throw an exception in execution.
        //              Any number of functions may be passed.
        for(var x=0; x<arguments.length; x++){
                try{
                        if(typeof arguments[x] == "function"){
                                var ret = (arguments[x]());
                                if(ret){
                                        return ret;
                                }
                        }
                }catch(e){
                        dojo.debug(e);
                }
        }
}

dojo.lang.delayThese = function(/*Array*/farr, /*Function, optional*/cb, /*Integer*/delay, /*Function, optional*/onend){
        // summary:
        //              executes a series of functions contained in farr, but spaces out
        //              calls to each function by the millisecond delay provided. If cb is
        //              provided, it will be called directly after each item in farr is
        //              called and if onend is passed, it will be called when all items
        //              have completed executing.

        /**
         * alternate: (array funcArray, function callback, function onend)
         * alternate: (array funcArray, function callback)
         * alternate: (array funcArray)
         */
        if(!farr.length){ 
                if(typeof onend == "function"){
                        onend();
                }
                return;
        }
        if((typeof delay == "undefined")&&(typeof cb == "number")){
                delay = cb;
                cb = function(){};
        }else if(!cb){
                cb = function(){};
                if(!delay){ delay = 0; }
        }
        setTimeout(function(){
                (farr.shift())();
                cb();
                dojo.lang.delayThese(farr, cb, delay, onend);
        }, delay);
}

dojo.provide("dojo.string.extras");





//TODO: should we use ${} substitution syntax instead, like widgets do?
dojo.string.substituteParams = function(/*string*/template, /* object - optional or ... */hash){
// summary:
//      Performs parameterized substitutions on a string. Throws an exception if any parameter is unmatched.
//
// description:
//      For example,
//              dojo.string.substituteParams("File '%{0}' is not found in directory '%{1}'.","foo.html","/temp");
//      returns
//              "File 'foo.html' is not found in directory '/temp'."
//
// template: the original string template with %{values} to be replaced
// hash: name/value pairs (type object) to provide substitutions.  Alternatively, substitutions may be
//      included as arguments 1..n to this function, corresponding to template parameters 0..n-1

        var map = (typeof hash == 'object') ? hash : dojo.lang.toArray(arguments, 1);

        return template.replace(/\%\{(\w+)\}/g, function(match, key){
                if(typeof(map[key]) != "undefined" && map[key] != null){
                        return map[key];
                }
                dojo.raise("Substitution not found: " + key);
        }); // string
};

dojo.string.capitalize = function(/*string*/str){
// summary:
//      Uppercases the first letter of each word

        if(!dojo.lang.isString(str)){ return ""; }
        if(arguments.length == 0){ str = this; }

        var words = str.split(' ');
        for(var i=0; i<words.length; i++){
                words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
        }
        return words.join(" "); // string
}

dojo.string.isBlank = function(/*string*/str){
// summary:
//      Return true if the entire string is whitespace characters

        if(!dojo.lang.isString(str)){ return true; }
        return (dojo.string.trim(str).length == 0); // boolean
}

//FIXME: not sure exactly what encodeAscii is trying to do, or if it's working right
dojo.string.encodeAscii = function(/*string*/str){
        if(!dojo.lang.isString(str)){ return str; } // unknown
        var ret = "";
        var value = escape(str);
        var match, re = /%u([0-9A-F]{4})/i;
        while((match = value.match(re))){
                var num = Number("0x"+match[1]);
                var newVal = escape("&#" + num + ";");
                ret += value.substring(0, match.index) + newVal;
                value = value.substring(match.index+match[0].length);
        }
        ret += value.replace(/\+/g, "%2B");
        return ret; // string
}

dojo.string.escape = function(/*string*/type, /*string*/str){
// summary:
//      Adds escape sequences for special characters according to the convention of 'type'
//
// type: one of xml|html|xhtml|sql|regexp|regex|javascript|jscript|js|ascii
// str: the string to be escaped

        var args = dojo.lang.toArray(arguments, 1);
        switch(type.toLowerCase()){
                case "xml":
                case "html":
                case "xhtml":
                        return dojo.string.escapeXml.apply(this, args); // string
                case "sql":
                        return dojo.string.escapeSql.apply(this, args); // string
                case "regexp":
                case "regex":
                        return dojo.string.escapeRegExp.apply(this, args); // string
                case "javascript":
                case "jscript":
                case "js":
                        return dojo.string.escapeJavaScript.apply(this, args); // string
                case "ascii":
                        // so it's encode, but it seems useful
                        return dojo.string.encodeAscii.apply(this, args); // string
                default:
                        return str; // string
        }
}

dojo.string.escapeXml = function(/*string*/str, /*boolean*/noSingleQuotes){
//summary:
//      Adds escape sequences for special characters in XML: &<>"'
//  Optionally skips escapes for single quotes

        str = str.replace(/&/gm, "&amp;").replace(/</gm, "&lt;")
                .replace(/>/gm, "&gt;").replace(/"/gm, "&quot;");
        if(!noSingleQuotes){ str = str.replace(/'/gm, "&#39;"); }
        return str; // string
}

dojo.string.escapeSql = function(/*string*/str){
//summary:
//      Adds escape sequences for single quotes in SQL expressions

        return str.replace(/'/gm, "''"); //string
}

dojo.string.escapeRegExp = function(/*string*/str){
//summary:
//      Adds escape sequences for special characters in regular expressions

        return str.replace(/\\/gm, "\\\\").replace(/([\f\b\n\t\r[\^$|?*+(){}])/gm, "\\$1"); // string
}

//FIXME: should this one also escape backslash?
dojo.string.escapeJavaScript = function(/*string*/str){
//summary:
//      Adds escape sequences for single and double quotes as well
//      as non-visible characters in JavaScript string literal expressions

        return str.replace(/(["'\f\b\n\t\r])/gm, "\\$1"); // string
}

//FIXME: looks a lot like escapeJavaScript, just adds quotes? deprecate one?
dojo.string.escapeString = function(/*string*/str){
//summary:
//      Adds escape sequences for non-visual characters, double quote and backslash
//      and surrounds with double quotes to form a valid string literal.
        return ('"' + str.replace(/(["\\])/g, '\\$1') + '"'
                ).replace(/[\f]/g, "\\f"
                ).replace(/[\b]/g, "\\b"
                ).replace(/[\n]/g, "\\n"
                ).replace(/[\t]/g, "\\t"
                ).replace(/[\r]/g, "\\r"); // string
}

// TODO: make an HTML version
dojo.string.summary = function(/*string*/str, /*number*/len){
// summary:
//      Truncates 'str' after 'len' characters and appends periods as necessary so that it ends with "..."

        if(!len || str.length <= len){
                return str; // string
        }

        return str.substring(0, len).replace(/\.+$/, "") + "..."; // string
}

dojo.string.endsWith = function(/*string*/str, /*string*/end, /*boolean*/ignoreCase){
// summary:
//      Returns true if 'str' ends with 'end'

        if(ignoreCase){
                str = str.toLowerCase();
                end = end.toLowerCase();
        }
        if((str.length - end.length) < 0){
                return false; // boolean
        }
        return str.lastIndexOf(end) == str.length - end.length; // boolean
}

dojo.string.endsWithAny = function(/*string*/str /* , ... */){
// summary:
//      Returns true if 'str' ends with any of the arguments[2 -> n]

        for(var i = 1; i < arguments.length; i++) {
                if(dojo.string.endsWith(str, arguments[i])) {
                        return true; // boolean
                }
        }
        return false; // boolean
}

dojo.string.startsWith = function(/*string*/str, /*string*/start, /*boolean*/ignoreCase){
// summary:
//      Returns true if 'str' starts with 'start'

        if(ignoreCase) {
                str = str.toLowerCase();
                start = start.toLowerCase();
        }
        return str.indexOf(start) == 0; // boolean
}

dojo.string.startsWithAny = function(/*string*/str /* , ... */){
// summary:
//      Returns true if 'str' starts with any of the arguments[2 -> n]

        for(var i = 1; i < arguments.length; i++) {
                if(dojo.string.startsWith(str, arguments[i])) {
                        return true; // boolean
                }
        }
        return false; // boolean
}

dojo.string.has = function(/*string*/str /* , ... */) {
// summary:
//      Returns true if 'str' contains any of the arguments 2 -> n

        for(var i = 1; i < arguments.length; i++) {
                if(str.indexOf(arguments[i]) > -1){
                        return true; // boolean
                }
        }
        return false; // boolean
}

dojo.string.normalizeNewlines = function(/*string*/text, /*string? (\n or \r)*/newlineChar){
// summary:
//      Changes occurences of CR and LF in text to CRLF, or if newlineChar is provided as '\n' or '\r',
//      substitutes newlineChar for occurrences of CR/LF and CRLF

        if (newlineChar == "\n"){
                text = text.replace(/\r\n/g, "\n");
                text = text.replace(/\r/g, "\n");
        } else if (newlineChar == "\r"){
                text = text.replace(/\r\n/g, "\r");
                text = text.replace(/\n/g, "\r");
        }else{
                text = text.replace(/([^\r])\n/g, "$1\r\n").replace(/\r([^\n])/g, "\r\n$1");
        }
        return text; // string
}

dojo.string.splitEscaped = function(/*string*/str, /*string of length=1*/charac){
// summary:
//      Splits 'str' into an array separated by 'charac', but skips characters escaped with a backslash

        var components = [];
        for (var i = 0, prevcomma = 0; i < str.length; i++){
                if (str.charAt(i) == '\\'){ i++; continue; }
                if (str.charAt(i) == charac){
                        components.push(str.substring(prevcomma, i));
                        prevcomma = i + 1;
                }
        }
        components.push(str.substr(prevcomma));
        return components; // array
}

dojo.provide("dojo.dom");

dojo.dom.ELEMENT_NODE                  = 1;
dojo.dom.ATTRIBUTE_NODE                = 2;
dojo.dom.TEXT_NODE                     = 3;
dojo.dom.CDATA_SECTION_NODE            = 4;
dojo.dom.ENTITY_REFERENCE_NODE         = 5;
dojo.dom.ENTITY_NODE                   = 6;
dojo.dom.PROCESSING_INSTRUCTION_NODE   = 7;
dojo.dom.COMMENT_NODE                  = 8;
dojo.dom.DOCUMENT_NODE                 = 9;
dojo.dom.DOCUMENT_TYPE_NODE            = 10;
dojo.dom.DOCUMENT_FRAGMENT_NODE        = 11;
dojo.dom.NOTATION_NODE                 = 12;
        
dojo.dom.dojoml = "http://www.dojotoolkit.org/2004/dojoml";

/**
 *      comprehensive list of XML namespaces
**/
dojo.dom.xmlns = {
        //      summary
        //      aliases for various common XML namespaces
        svg : "http://www.w3.org/2000/svg",
        smil : "http://www.w3.org/2001/SMIL20/",
        mml : "http://www.w3.org/1998/Math/MathML",
        cml : "http://www.xml-cml.org",
        xlink : "http://www.w3.org/1999/xlink",
        xhtml : "http://www.w3.org/1999/xhtml",
        xul : "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
        xbl : "http://www.mozilla.org/xbl",
        fo : "http://www.w3.org/1999/XSL/Format",
        xsl : "http://www.w3.org/1999/XSL/Transform",
        xslt : "http://www.w3.org/1999/XSL/Transform",
        xi : "http://www.w3.org/2001/XInclude",
        xforms : "http://www.w3.org/2002/01/xforms",
        saxon : "http://icl.com/saxon",
        xalan : "http://xml.apache.org/xslt",
        xsd : "http://www.w3.org/2001/XMLSchema",
        dt: "http://www.w3.org/2001/XMLSchema-datatypes",
        xsi : "http://www.w3.org/2001/XMLSchema-instance",
        rdf : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
        rdfs : "http://www.w3.org/2000/01/rdf-schema#",
        dc : "http://purl.org/dc/elements/1.1/",
        dcq: "http://purl.org/dc/qualifiers/1.0",
        "soap-env" : "http://schemas.xmlsoap.org/soap/envelope/",
        wsdl : "http://schemas.xmlsoap.org/wsdl/",
        AdobeExtensions : "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
};

dojo.dom.isNode = function(/* object */wh){
        //      summary:
        //              checks to see if wh is actually a node.
        if(typeof Element == "function") {
                try {
                        return wh instanceof Element;   //      boolean
                } catch(e) {}
        } else {
                // best-guess
                return wh && !isNaN(wh.nodeType);       //      boolean
        }
}

dojo.dom.getUniqueId = function(){
        //      summary:
        //              returns a unique string for use with any DOM element
        var _document = dojo.doc();
        do {
                var id = "dj_unique_" + (++arguments.callee._idIncrement);
        }while(_document.getElementById(id));
        return id;      //      string
}
dojo.dom.getUniqueId._idIncrement = 0;

dojo.dom.firstElement = dojo.dom.getFirstChildElement = function(/* Element */parentNode, /* string? */tagName){
        //      summary:
        //              returns the first child element matching tagName
        var node = parentNode.firstChild;
        while(node && node.nodeType != dojo.dom.ELEMENT_NODE){
                node = node.nextSibling;
        }
        if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
                node = dojo.dom.nextElement(node, tagName);
        }
        return node;    //      Element
}

dojo.dom.lastElement = dojo.dom.getLastChildElement = function(/* Element */parentNode, /* string? */tagName){
        //      summary:
        //              returns the last child element matching tagName
        var node = parentNode.lastChild;
        while(node && node.nodeType != dojo.dom.ELEMENT_NODE) {
                node = node.previousSibling;
        }
        if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
                node = dojo.dom.prevElement(node, tagName);
        }
        return node;    //      Element
}

dojo.dom.nextElement = dojo.dom.getNextSiblingElement = function(/* Node */node, /* string? */tagName){
        //      summary:
        //              returns the next sibling element matching tagName
        if(!node) { return null; }
        do {
                node = node.nextSibling;
        } while(node && node.nodeType != dojo.dom.ELEMENT_NODE);

        if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
                return dojo.dom.nextElement(node, tagName);
        }
        return node;    //      Element
}

dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement = function(/* Node */node, /* string? */tagName){
        //      summary:
        //              returns the previous sibling element matching tagName
        if(!node) { return null; }
        if(tagName) { tagName = tagName.toLowerCase(); }
        do {
                node = node.previousSibling;
        } while(node && node.nodeType != dojo.dom.ELEMENT_NODE);

        if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
                return dojo.dom.prevElement(node, tagName);
        }
        return node;    //      Element
}

// TODO: hmph
/*this.forEachChildTag = function(node, unaryFunc) {
        var child = this.getFirstChildTag(node);
        while(child) {
                if(unaryFunc(child) == "break") { break; }
                child = this.getNextSiblingTag(child);
        }
}*/

dojo.dom.moveChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){
        //      summary:
        //              Moves children from srcNode to destNode and returns the count of
        //              children moved; will trim off text nodes if trim == true
        var count = 0;
        if(trim) {
                while(srcNode.hasChildNodes() &&
                        srcNode.firstChild.nodeType == dojo.dom.TEXT_NODE) {
                        srcNode.removeChild(srcNode.firstChild);
                }
                while(srcNode.hasChildNodes() &&
                        srcNode.lastChild.nodeType == dojo.dom.TEXT_NODE) {
                        srcNode.removeChild(srcNode.lastChild);
                }
        }
        while(srcNode.hasChildNodes()){
                destNode.appendChild(srcNode.firstChild);
                count++;
        }
        return count;   //      number
}

dojo.dom.copyChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){
        //      summary:
        //              Copies children from srcNde to destNode and returns the count of
        //              children copied; will trim off text nodes if trim == true
        var clonedNode = srcNode.cloneNode(true);
        return this.moveChildren(clonedNode, destNode, trim);   //      number
}

dojo.dom.replaceChildren = function(/*Element*/node, /*Node*/newChild){
        //      summary:
        //              Removes all children of node and appends newChild. All the existing
        //              children will be destroyed.
        // FIXME: what if newChild is an array-like object?
        var nodes = [];
        if(dojo.render.html.ie){
                for(var i=0;i<node.childNodes.length;i++){
                        nodes.push(node.childNodes[i]);
                }
        }
        dojo.dom.removeChildren(node);
        node.appendChild(newChild);
        for(var i=0;i<nodes.length;i++){
                dojo.dom.destroyNode(nodes[i]);
        }
}

dojo.dom.removeChildren = function(/*Element*/node){
        //      summary:
        //              removes all children from node and returns the count of children removed.
        //              The children nodes are not destroyed. Be sure to call destroyNode on them
        //              after they are not used anymore.
        var count = node.childNodes.length;
        while(node.hasChildNodes()){ dojo.dom.removeNode(node.firstChild); }
        return count; // int
}

dojo.dom.replaceNode = function(/*Element*/node, /*Element*/newNode){
        //      summary:
        //              replaces node with newNode and returns a reference to the removed node.
        //              To prevent IE memory leak, call destroyNode on the returned node when
        //              it is no longer needed.
        return node.parentNode.replaceChild(newNode, node); // Node
}

dojo.dom.destroyNode = function(/*Node*/node){
        // summary:
        //              destroy a node (it can not be used any more). For IE, this is the
        //              right function to call to prevent memory leaks. While for other
        //              browsers, this is identical to dojo.dom.removeNode
        if(node.parentNode){
                node = dojo.dom.removeNode(node);
        }
        if(node.nodeType != 3){ // ingore TEXT_NODE
                if(dojo.evalObjPath("dojo.event.browser.clean", false)){
                        dojo.event.browser.clean(node);
                }
                if(dojo.render.html.ie){
                        node.outerHTML=''; //prevent ugly IE mem leak associated with Node.removeChild (ticket #1727)
                }
        }
}

dojo.dom.removeNode = function(/*Node*/node){
        // summary:
        //              if node has a parent, removes node from parent and returns a
        //              reference to the removed child.
        //              To prevent IE memory leak, call destroyNode on the returned node when
        //              it is no longer needed.
        //      node:
        //              the node to remove from its parent.

        if(node && node.parentNode){
                // return a ref to the removed child
                return node.parentNode.removeChild(node); //Node
        }
}

dojo.dom.getAncestors = function(/*Node*/node, /*function?*/filterFunction, /*boolean?*/returnFirstHit){
        //      summary:
        //              returns all ancestors matching optional filterFunction; will return
        //              only the first if returnFirstHit
        var ancestors = [];
        var isFunction = (filterFunction && (filterFunction instanceof Function || typeof filterFunction == "function"));
        while(node){
                if(!isFunction || filterFunction(node)){
                        ancestors.push(node);
                }
                if(returnFirstHit && ancestors.length > 0){ 
                        return ancestors[0];    //      Node
                }
                
                node = node.parentNode;
        }
        if(returnFirstHit){ return null; }
        return ancestors;       //      array
}

dojo.dom.getAncestorsByTag = function(/*Node*/node, /*String*/tag, /*boolean?*/returnFirstHit){
        //      summary:
        //              returns all ancestors matching tag (as tagName), will only return
        //              first one if returnFirstHit
        tag = tag.toLowerCase();
        return dojo.dom.getAncestors(node, function(el){
                return ((el.tagName)&&(el.tagName.toLowerCase() == tag));
        }, returnFirstHit);     //      Node || array
}

dojo.dom.getFirstAncestorByTag = function(/*Node*/node, /*string*/tag){
        //      summary:
        //              Returns first ancestor of node with tag tagName
        return dojo.dom.getAncestorsByTag(node, tag, true);     //      Node
}

dojo.dom.isDescendantOf = function(/* Node */node, /* Node */ancestor, /* boolean? */guaranteeDescendant){
        //      summary
        //      Returns boolean if node is a descendant of ancestor
        // guaranteeDescendant allows us to be a "true" isDescendantOf function
        if(guaranteeDescendant && node) { node = node.parentNode; }
        while(node) {
                if(node == ancestor){ 
                        return true;    //      boolean
                }
                node = node.parentNode;
        }
        return false;   //      boolean
}

dojo.dom.innerXML = function(/*Node*/node){
        //      summary:
        //              Implementation of MS's innerXML function.
        if(node.innerXML){
                return node.innerXML;   //      string
        }else if (node.xml){
                return node.xml;                //      string
        }else if(typeof XMLSerializer != "undefined"){
                return (new XMLSerializer()).serializeToString(node);   //      string
        }
}

dojo.dom.createDocument = function(){
        //      summary:
        //              cross-browser implementation of creating an XML document object.
        var doc = null;
        var _document = dojo.doc();

        if(!dj_undef("ActiveXObject")){
                var prefixes = [ "MSXML2", "Microsoft", "MSXML", "MSXML3" ];
                for(var i = 0; i<prefixes.length; i++){
                        try{
                                doc = new ActiveXObject(prefixes[i]+".XMLDOM");
                        }catch(e){ /* squelch */ };

                        if(doc){ break; }
                }
        }else if((_document.implementation)&&
                (_document.implementation.createDocument)){
                doc = _document.implementation.createDocument("", "", null);
        }
        
        return doc;     //      DOMDocument
}

dojo.dom.createDocumentFromText = function(/*string*/str, /*string?*/mimetype){
        //      summary:
        //              attempts to create a Document object based on optional mime-type,
        //              using str as the contents of the document
        if(!mimetype){ mimetype = "text/xml"; }
        if(!dj_undef("DOMParser")){
                var parser = new DOMParser();
                return parser.parseFromString(str, mimetype);   //      DOMDocument
        }else if(!dj_undef("ActiveXObject")){
                var domDoc = dojo.dom.createDocument();
                if(domDoc){
                        domDoc.async = false;
                        domDoc.loadXML(str);
                        return domDoc;  //      DOMDocument
                }else{
                        dojo.debug("toXml didn't work?");
                }
        /*
        }else if((dojo.render.html.capable)&&(dojo.render.html.safari)){
                // FIXME: this doesn't appear to work!
                // from: http://web-graphics.com/mtarchive/001606.php
                // var xml = '<?xml version="1.0"?>'+str;
                var mtype = "text/xml";
                var xml = '<?xml version="1.0"?>'+str;
                var url = "data:"+mtype+";charset=utf-8,"+encodeURIComponent(xml);
                var req = new XMLHttpRequest();
                req.open("GET", url, false);
                req.overrideMimeType(mtype);
                req.send(null);
                return req.responseXML;
        */
        }else{
                var _document = dojo.doc();
                if(_document.createElement){
                        // FIXME: this may change all tags to uppercase!
                        var tmp = _document.createElement("xml");
                        tmp.innerHTML = str;
                        if(_document.implementation && _document.implementation.createDocument){
                                var xmlDoc = _document.implementation.createDocument("foo", "", null);
                                for(var i = 0; i < tmp.childNodes.length; i++) {
                                        xmlDoc.importNode(tmp.childNodes.item(i), true);
                                }
                                return xmlDoc;  //      DOMDocument
                        }
                        // FIXME: probably not a good idea to have to return an HTML fragment
                        // FIXME: the tmp.doc.firstChild is as tested from IE, so it may not
                        // work that way across the board
                        return ((tmp.document)&&
                                (tmp.document.firstChild ?  tmp.document.firstChild : tmp));    //      DOMDocument
                }
        }
        return null;
}

dojo.dom.prependChild = function(/*Element*/node, /*Element*/parent){
        //      summary:
        //              prepends node to parent's children nodes
        if(parent.firstChild) {
                parent.insertBefore(node, parent.firstChild);
        } else {
                parent.appendChild(node);
        }
        return true;    //      boolean
}

dojo.dom.insertBefore = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){
        //      summary:
        //              Try to insert node before ref
        if(     (force != true)&&
                (node === ref || node.nextSibling === ref)){ return false; }
        var parent = ref.parentNode;
        parent.insertBefore(node, ref);
        return true;    //      boolean
}

dojo.dom.insertAfter = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){
        //      summary:
        //              Try to insert node after ref
        var pn = ref.parentNode;
        if(ref == pn.lastChild){
                if((force != true)&&(node === ref)){
                        return false;   //      boolean
                }
                pn.appendChild(node);
        }else{
                return this.insertBefore(node, ref.nextSibling, force); //      boolean
        }
        return true;    //      boolean
}

dojo.dom.insertAtPosition = function(/*Node*/node, /*Node*/ref, /*string*/position){
        //      summary:
        //              attempt to insert node in relation to ref based on position
        if((!node)||(!ref)||(!position)){ 
                return false;   //      boolean 
        }
        switch(position.toLowerCase()){
                case "before":
                        return dojo.dom.insertBefore(node, ref);        //      boolean
                case "after":
                        return dojo.dom.insertAfter(node, ref);         //      boolean
                case "first":
                        if(ref.firstChild){
                                return dojo.dom.insertBefore(node, ref.firstChild);     //      boolean
                        }else{
                                ref.appendChild(node);
                                return true;    //      boolean
                        }
                        break;
                default: // aka: last
                        ref.appendChild(node);
                        return true;    //      boolean
        }
}

dojo.dom.insertAtIndex = function(/*Node*/node, /*Element*/containingNode, /*number*/insertionIndex){
        //      summary:
        //              insert node into child nodes nodelist of containingNode at
        //              insertionIndex. insertionIndex should be between 0 and 
        //              the number of the childNodes in containingNode. insertionIndex
        //              specifys after how many childNodes in containingNode the node
        //              shall be inserted. If 0 is given, node will be appended to 
        //              containingNode.
        var siblingNodes = containingNode.childNodes;

        // if there aren't any kids yet, just add it to the beginning

        if (!siblingNodes.length || siblingNodes.length == insertionIndex){
                containingNode.appendChild(node);
                return true;    //      boolean
        }

        if(insertionIndex == 0){
                return dojo.dom.prependChild(node, containingNode);     //      boolean
        }
        // otherwise we need to walk the childNodes
        // and find our spot

        return dojo.dom.insertAfter(node, siblingNodes[insertionIndex-1]);      //      boolean
}
        
dojo.dom.textContent = function(/*Node*/node, /*string*/text){
        //      summary:
        //              implementation of the DOM Level 3 attribute; scan node for text
        if (arguments.length>1) {
                var _document = dojo.doc();
                dojo.dom.replaceChildren(node, _document.createTextNode(text));
                return text;    //      string
        } else {
                if(node.textContent != undefined){ //FF 1.5
                        return node.textContent;        //      string
                }
                var _result = "";
                if (node == null) { return _result; }
                for (var i = 0; i < node.childNodes.length; i++) {
                        switch (node.childNodes[i].nodeType) {
                                case 1: // ELEMENT_NODE
                                case 5: // ENTITY_REFERENCE_NODE
                                        _result += dojo.dom.textContent(node.childNodes[i]);
                                        break;
                                case 3: // TEXT_NODE
                                case 2: // ATTRIBUTE_NODE
                                case 4: // CDATA_SECTION_NODE
                                        _result += node.childNodes[i].nodeValue;
                                        break;
                                default:
                                        break;
                        }
                }
                return _result; //      string
        }
}

dojo.dom.hasParent = function(/*Node*/node){
        //      summary:
        //              returns whether or not node is a child of another node.
        return Boolean(node && node.parentNode && dojo.dom.isNode(node.parentNode));    //      boolean
}

/**
 * Examples:
 *
 * myFooNode = <foo />
 * isTag(myFooNode, "foo"); // returns "foo"
 * isTag(myFooNode, "bar"); // returns ""
 * isTag(myFooNode, "FOO"); // returns ""
 * isTag(myFooNode, "hey", "foo", "bar"); // returns "foo"
**/
dojo.dom.isTag = function(/* Node */node /* ... */){
        //      summary:
        //              determines if node has any of the provided tag names and returns
        //              the tag name that matches, empty string otherwise.
        if(node && node.tagName) {
                for(var i=1; i<arguments.length; i++){
                        if(node.tagName==String(arguments[i])){
                                return String(arguments[i]);    //      string
                        }
                }
        }
        return "";      //      string
}

dojo.dom.setAttributeNS = function(     /*Element*/elem, /*string*/namespaceURI, 
                                                                        /*string*/attrName, /*string*/attrValue){
        //      summary:
        //              implementation of DOM2 setAttributeNS that works cross browser.
        if(elem == null || ((elem == undefined)&&(typeof elem == "undefined"))){
                dojo.raise("No element given to dojo.dom.setAttributeNS");
        }
        
        if(!((elem.setAttributeNS == undefined)&&(typeof elem.setAttributeNS == "undefined"))){ // w3c
                elem.setAttributeNS(namespaceURI, attrName, attrValue);
        }else{ // IE
                // get a root XML document
                var ownerDoc = elem.ownerDocument;
                var attribute = ownerDoc.createNode(
                        2, // node type
                        attrName,
                        namespaceURI
                );
                
                // set value
                attribute.nodeValue = attrValue;
                
                // attach to element
                elem.setAttributeNode(attribute);
        }
}

dojo.provide("dojo.undo.browser");


try{
        if((!djConfig["preventBackButtonFix"])&&(!dojo.hostenv.post_load_)){
                document.write("<iframe style='border: 0px; width: 1px; height: 1px; position: absolute; bottom: 0px; right: 0px; visibility: visible;' name='djhistory' id='djhistory' src='" + (djConfig["dojoIframeHistoryUrl"] || dojo.hostenv.getBaseScriptUri()+'iframe_history.html') + "'></iframe>");
        }
}catch(e){/* squelch */}

if(dojo.render.html.opera){
        dojo.debug("Opera is not supported with dojo.undo.browser, so back/forward detection will not work.");
}

dojo.undo.browser = {
        initialHref: (!dj_undef("window")) ? window.location.href : "",
        initialHash: (!dj_undef("window")) ? window.location.hash : "",

        moveForward: false,
        historyStack: [],
        forwardStack: [],
        historyIframe: null,
        bookmarkAnchor: null,
        locationTimer: null,

        /**
         * 
         */
        setInitialState: function(/*Object*/args){
                //summary: Sets the state object and back callback for the very first page that is loaded.
                //description: It is recommended that you call this method as part of an event listener that is registered via
                //dojo.addOnLoad().
                //args: Object
                //              See the addToHistory() function for the list of valid args properties.
                this.initialState = this._createState(this.initialHref, args, this.initialHash);
        },

        //FIXME: Would like to support arbitrary back/forward jumps. Have to rework iframeLoaded among other things.
        //FIXME: is there a slight race condition in moz using change URL with the timer check and when
        //       the hash gets set? I think I have seen a back/forward call in quick succession, but not consistent.
        addToHistory: function(args){
                //summary: adds a state object (args) to the history list. You must set
                //djConfig.preventBackButtonFix = false to use dojo.undo.browser.

                //args: Object
                //              args can have the following properties:
                //              To support getting back button notifications, the object argument should implement a
                //              function called either "back", "backButton", or "handle". The string "back" will be
                //              passed as the first and only argument to this callback.
                //              - To support getting forward button notifications, the object argument should implement a
                //              function called either "forward", "forwardButton", or "handle". The string "forward" will be
                //              passed as the first and only argument to this callback.
                //              - If you want the browser location string to change, define "changeUrl" on the object. If the
                //              value of "changeUrl" is true, then a unique number will be appended to the URL as a fragment
                //              identifier (http://some.domain.com/path#uniquenumber). If it is any other value that does
                //              not evaluate to false, that value will be used as the fragment identifier. For example,
                //              if changeUrl: 'page1', then the URL will look like: http://some.domain.com/path#page1
                //              Full example:
                //              dojo.undo.browser.addToHistory({
                //                back: function() { alert('back pressed'); },
                //                forward: function() { alert('forward pressed'); },
                //                changeUrl: true
                //              });
                //
                //      BROWSER NOTES:
                //  Safari 1.2: 
                //      back button "works" fine, however it's not possible to actually
                //      DETECT that you've moved backwards by inspecting window.location.
                //      Unless there is some other means of locating.
                //      FIXME: perhaps we can poll on history.length?
                //      Safari 2.0.3+ (and probably 1.3.2+):
                //      works fine, except when changeUrl is used. When changeUrl is used,
                //      Safari jumps all the way back to whatever page was shown before
                //      the page that uses dojo.undo.browser support.
                //      IE 5.5 SP2:
                //      back button behavior is macro. It does not move back to the
                //      previous hash value, but to the last full page load. This suggests
                //      that the iframe is the correct way to capture the back button in
                //      these cases.
                //      Don't test this page using local disk for MSIE. MSIE will not create 
                //      a history list for iframe_history.html if served from a file: URL. 
                //      The XML served back from the XHR tests will also not be properly 
                //      created if served from local disk. Serve the test pages from a web 
                //      server to test in that browser.
                //      IE 6.0:
                //      same behavior as IE 5.5 SP2
                //      Firefox 1.0+:
                //      the back button will return us to the previous hash on the same
                //      page, thereby not requiring an iframe hack, although we do then
                //      need to run a timer to detect inter-page movement.

                //If addToHistory is called, then that means we prune the
                //forward stack -- the user went back, then wanted to
                //start a new forward path.
                this.forwardStack = []; 

                var hash = null;
                var url = null;
                if(!this.historyIframe){
                        if(djConfig["useXDomain"] && !djConfig["dojoIframeHistoryUrl"]){
                                dojo.debug("dojo.undo.browser: When using cross-domain Dojo builds,"
                                        + " please save iframe_history.html to your domain and set djConfig.dojoIframeHistoryUrl"
                                        + " to the path on your domain to iframe_history.html");
                        }
                        this.historyIframe = window.frames["djhistory"];
                }
                if(!this.bookmarkAnchor){
                        this.bookmarkAnchor = document.createElement("a");
                        dojo.body().appendChild(this.bookmarkAnchor);
                        this.bookmarkAnchor.style.display = "none";
                }
                if(args["changeUrl"]){
                        hash = "#"+ ((args["changeUrl"]!==true) ? args["changeUrl"] : (new Date()).getTime());
                        
                        //If the current hash matches the new one, just replace the history object with
                        //this new one. It doesn't make sense to track different state objects for the same
                        //logical URL. This matches the browser behavior of only putting in one history
                        //item no matter how many times you click on the same #hash link, at least in Firefox
                        //and Safari, and there is no reliable way in those browsers to know if a #hash link
                        //has been clicked on multiple times. So making this the standard behavior in all browsers
                        //so that dojo.undo.browser's behavior is the same in all browsers.
                        if(this.historyStack.length == 0 && this.initialState.urlHash == hash){
                                this.initialState = this._createState(url, args, hash);
                                return;
                        }else if(this.historyStack.length > 0 && this.historyStack[this.historyStack.length - 1].urlHash == hash){
                                this.historyStack[this.historyStack.length - 1] = this._createState(url, args, hash);
                                return;
                        }

                        this.changingUrl = true;
                        setTimeout("window.location.href = '"+hash+"'; dojo.undo.browser.changingUrl = false;", 1);
                        this.bookmarkAnchor.href = hash;
                        
                        if(dojo.render.html.ie){
                                url = this._loadIframeHistory();

                                var oldCB = args["back"]||args["backButton"]||args["handle"];

                                //The function takes handleName as a parameter, in case the
                                //callback we are overriding was "handle". In that case,
                                //we will need to pass the handle name to handle.
                                var tcb = function(handleName){
                                        if(window.location.hash != ""){
                                                setTimeout("window.location.href = '"+hash+"';", 1);
                                        }
                                        //Use apply to set "this" to args, and to try to avoid memory leaks.
                                        oldCB.apply(this, [handleName]);
                                }
                
                                //Set interceptor function in the right place.
                                if(args["back"]){
                                        args.back = tcb;
                                }else if(args["backButton"]){
                                        args.backButton = tcb;
                                }else if(args["handle"]){
                                        args.handle = tcb;
                                }
                
                                var oldFW = args["forward"]||args["forwardButton"]||args["handle"];
                
                                //The function takes handleName as a parameter, in case the
                                //callback we are overriding was "handle". In that case,
                                //we will need to pass the handle name to handle.
                                var tfw = function(handleName){
                                        if(window.location.hash != ""){
                                                window.location.href = hash;
                                        }
                                        if(oldFW){ // we might not actually have one
                                                //Use apply to set "this" to args, and to try to avoid memory leaks.
                                                oldFW.apply(this, [handleName]);
                                        }
                                }

                                //Set interceptor function in the right place.
                                if(args["forward"]){
                                        args.forward = tfw;
                                }else if(args["forwardButton"]){
                                        args.forwardButton = tfw;
                                }else if(args["handle"]){
                                        args.handle = tfw;
                                }

                        }else if(dojo.render.html.moz){
                                // start the timer
                                if(!this.locationTimer){
                                        this.locationTimer = setInterval("dojo.undo.browser.checkLocation();", 200);
                                }
                        }
                }else{
                        url = this._loadIframeHistory();
                }

                this.historyStack.push(this._createState(url, args, hash));
        },

        checkLocation: function(){
                //summary: private method. Do not call this directly.
                if (!this.changingUrl){
                        var hsl = this.historyStack.length;

                        if((window.location.hash == this.initialHash||window.location.href == this.initialHref)&&(hsl == 1)){
                                // FIXME: could this ever be a forward button?
                                // we can't clear it because we still need to check for forwards. Ugg.
                                // clearInterval(this.locationTimer);
                                this.handleBackButton();
                                return;
                        }
                        
                        // first check to see if we could have gone forward. We always halt on
                        // a no-hash item.
                        if(this.forwardStack.length > 0){
                                if(this.forwardStack[this.forwardStack.length-1].urlHash == window.location.hash){
                                        this.handleForwardButton();
                                        return;
                                }
                        }
        
                        // ok, that didn't work, try someplace back in the history stack
                        if((hsl >= 2)&&(this.historyStack[hsl-2])){
                                if(this.historyStack[hsl-2].urlHash==window.location.hash){
                                        this.handleBackButton();
                                        return;
                                }
                        }
                }
        },

        iframeLoaded: function(evt, ifrLoc){
                //summary: private method. Do not call this directly.
                if(!dojo.render.html.opera){
                        var query = this._getUrlQuery(ifrLoc.href);
                        if(query == null){ 
                                // alert("iframeLoaded");
                                // we hit the end of the history, so we should go back
                                if(this.historyStack.length == 1){
                                        this.handleBackButton();
                                }
                                return;
                        }
                        if(this.moveForward){
                                // we were expecting it, so it's not either a forward or backward movement
                                this.moveForward = false;
                                return;
                        }
        
                        //Check the back stack first, since it is more likely.
                        //Note that only one step back or forward is supported.
                        if(this.historyStack.length >= 2 && query == this._getUrlQuery(this.historyStack[this.historyStack.length-2].url)){
                                this.handleBackButton();
                        }
                        else if(this.forwardStack.length > 0 && query == this._getUrlQuery(this.forwardStack[this.forwardStack.length-1].url)){
                                this.handleForwardButton();
                        }
                }
        },

        handleBackButton: function(){
                //summary: private method. Do not call this directly.

                //The "current" page is always at the top of the history stack.
                var current = this.historyStack.pop();
                if(!current){ return; }
                var last = this.historyStack[this.historyStack.length-1];
                if(!last && this.historyStack.length == 0){
                        last = this.initialState;
                }
                if (last){
                        if(last.kwArgs["back"]){
                                last.kwArgs["back"]();
                        }else if(last.kwArgs["backButton"]){
                                last.kwArgs["backButton"]();
                        }else if(last.kwArgs["handle"]){
                                last.kwArgs.handle("back");
                        }
                }
                this.forwardStack.push(current);
        },

        handleForwardButton: function(){
                //summary: private method. Do not call this directly.

                var last = this.forwardStack.pop();
                if(!last){ return; }
                if(last.kwArgs["forward"]){
                        last.kwArgs.forward();
                }else if(last.kwArgs["forwardButton"]){
                        last.kwArgs.forwardButton();
                }else if(last.kwArgs["handle"]){
                        last.kwArgs.handle("forward");
                }
                this.historyStack.push(last);
        },

        _createState: function(url, args, hash){
                //summary: private method. Do not call this directly.

                return {"url": url, "kwArgs": args, "urlHash": hash};   //Object
        },

        _getUrlQuery: function(url){
                //summary: private method. Do not call this directly.
                var segments = url.split("?");
                if (segments.length < 2){
                        return null; //null
                }
                else{
                        return segments[1]; //String
                }
        },
        
        _loadIframeHistory: function(){
                //summary: private method. Do not call this directly.
                var url = (djConfig["dojoIframeHistoryUrl"] || dojo.hostenv.getBaseScriptUri()+'iframe_history.html')
                        + "?" + (new Date()).getTime();
                this.moveForward = true;
                dojo.io.setIFrameSrc(this.historyIframe, url, false);   
                return url; //String
        }
}

dojo.provide("dojo.io.BrowserIO");








if(!dj_undef("window")) {

dojo.io.checkChildrenForFile = function(/*DOMNode*/node){
        //summary: Checks any child nodes of node for an input type="file" element.
        var hasFile = false;
        var inputs = node.getElementsByTagName("input");
        dojo.lang.forEach(inputs, function(input){
                if(hasFile){ return; }
                if(input.getAttribute("type")=="file"){
                        hasFile = true;
                }
        });
        return hasFile; //boolean
}

dojo.io.formHasFile = function(/*DOMNode*/formNode){
        //summary: Just calls dojo.io.checkChildrenForFile().
        return dojo.io.checkChildrenForFile(formNode); //boolean
}

dojo.io.updateNode = function(/*DOMNode*/node, /*String or Object*/urlOrArgs){
        //summary: Updates a DOMnode with the result of a dojo.io.bind() call.
        //node: DOMNode
        //urlOrArgs: String or Object
        //              Either a String that has an URL, or an object containing dojo.io.bind()
        //              arguments.
        node = dojo.byId(node);
        var args = urlOrArgs;
        if(dojo.lang.isString(urlOrArgs)){
                args = { url: urlOrArgs };
        }
        args.mimetype = "text/html";
        args.load = function(t, d, e){
                while(node.firstChild){
                        dojo.dom.destroyNode(node.firstChild);
                }
                node.innerHTML = d;
        };
        dojo.io.bind(args);
}

dojo.io.formFilter = function(/*DOMNode*/node) {
        //summary: Returns true if the node is an input element that is enabled, has
        //a name, and whose type is one of the following values: ["file", "submit", "image", "reset", "button"]
        var type = (node.type||"").toLowerCase();
        return !node.disabled && node.name
                && !dojo.lang.inArray(["file", "submit", "image", "reset", "button"], type); //boolean
}

// TODO: Move to htmlUtils
dojo.io.encodeForm = function(/*DOMNode*/formNode, /*String?*/encoding, /*Function?*/formFilter){
        //summary: Converts the names and values of form elements into an URL-encoded
        //string (name=value&name=value...).
        //formNode: DOMNode
        //encoding: String?
        //              The encoding to use for the values. Specify a string that starts with
        //              "utf" (for instance, "utf8"), to use encodeURIComponent() as the encoding
        //              function. Otherwise, dojo.string.encodeAscii will be used.
        //formFilter: Function?
        //      A function used to filter out form elements. The element node will be passed
        //      to the formFilter function, and a boolean result is expected (true indicating
        //      indicating that the element should have its name/value included in the output).
        //      If no formFilter is specified, then dojo.io.formFilter() will be used.
        if((!formNode)||(!formNode.tagName)||(!formNode.tagName.toLowerCase() == "form")){
                dojo.raise("Attempted to encode a non-form element.");
        }
        if(!formFilter) { formFilter = dojo.io.formFilter; }
        var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii;
        var values = [];

        for(var i = 0; i < formNode.elements.length; i++){
                var elm = formNode.elements[i];
                if(!elm || elm.tagName.toLowerCase() == "fieldset" || !formFilter(elm)) { continue; }
                var name = enc(elm.name);
                var type = elm.type.toLowerCase();

                if(type == "select-multiple"){
                        for(var j = 0; j < elm.options.length; j++){
                                if(elm.options[j].selected) {
                                        values.push(name + "=" + enc(elm.options[j].value));
                                }
                        }
                }else if(dojo.lang.inArray(["radio", "checkbox"], type)){
                        if(elm.checked){
                                values.push(name + "=" + enc(elm.value));
                        }
                }else{
                        values.push(name + "=" + enc(elm.value));
                }
        }

        // now collect input type="image", which doesn't show up in the elements array
        var inputs = formNode.getElementsByTagName("input");
        for(var i = 0; i < inputs.length; i++) {
                var input = inputs[i];
                if(input.type.toLowerCase() == "image" && input.form == formNode
                        && formFilter(input)) {
                        var name = enc(input.name);
                        values.push(name + "=" + enc(input.value));
                        values.push(name + ".x=0");
                        values.push(name + ".y=0");
                }
        }
        return values.join("&") + "&"; //String
}

dojo.io.FormBind = function(/*DOMNode or Object*/args) {
        //summary: constructor for a dojo.io.FormBind object. See the Dojo Book for
        //some information on usage: http://manual.dojotoolkit.org/WikiHome/DojoDotBook/Book23
        //args: DOMNode or Object
        //              args can either be the DOMNode for a form element, or an object containing
        //              dojo.io.bind() arguments, one of which should be formNode with the value of
        //              a form element DOMNode.
        this.bindArgs = {};

        if(args && args.formNode) {
                this.init(args);
        } else if(args) {
                this.init({formNode: args});
        }
}
dojo.lang.extend(dojo.io.FormBind, {
        form: null,

        bindArgs: null,

        clickedButton: null,

        init: function(/*DOMNode or Object*/args) {
                //summary: Internal function called by the dojo.io.FormBind() constructor
                //do not call this method directly.
                var form = dojo.byId(args.formNode);

                if(!form || !form.tagName || form.tagName.toLowerCase() != "form") {
                        throw new Error("FormBind: Couldn't apply, invalid form");
                } else if(this.form == form) {
                        return;
                } else if(this.form) {
                        throw new Error("FormBind: Already applied to a form");
                }

                dojo.lang.mixin(this.bindArgs, args);
                this.form = form;

                this.connect(form, "onsubmit", "submit");

                for(var i = 0; i < form.elements.length; i++) {
                        var node = form.elements[i];
                        if(node && node.type && dojo.lang.inArray(["submit", "button"], node.type.toLowerCase())) {
                                this.connect(node, "onclick", "click");
                        }
                }

                var inputs = form.getElementsByTagName("input");
                for(var i = 0; i < inputs.length; i++) {
                        var input = inputs[i];
                        if(input.type.toLowerCase() == "image" && input.form == form) {
                                this.connect(input, "onclick", "click");
                        }
                }
        },

        onSubmit: function(/*DOMNode*/form) {
                //summary: Function used to verify that the form is OK to submit.
                //Override this function if you want specific form validation done.
                return true; //boolean
        },

        submit: function(/*Event*/e) {
                //summary: internal function that is connected as a listener to the
                //form's onsubmit event.
                e.preventDefault();
                if(this.onSubmit(this.form)) {
                        dojo.io.bind(dojo.lang.mixin(this.bindArgs, {
                                formFilter: dojo.lang.hitch(this, "formFilter")
                        }));
                }
        },

        click: function(/*Event*/e) {
                //summary: internal method that is connected as a listener to the
                //form's elements whose click event can submit a form.
                var node = e.currentTarget;
                if(node.disabled) { return; }
                this.clickedButton = node;
        },

        formFilter: function(/*DOMNode*/node) {
                //summary: internal function used to know which form element values to include
                //              in the dojo.io.bind() request.
                var type = (node.type||"").toLowerCase();
                var accept = false;
                if(node.disabled || !node.name) {
                        accept = false;
                } else if(dojo.lang.inArray(["submit", "button", "image"], type)) {
                        if(!this.clickedButton) { this.clickedButton = node; }
                        accept = node == this.clickedButton;
                } else {
                        accept = !dojo.lang.inArray(["file", "submit", "reset", "button"], type);
                }
                return accept; //boolean
        },

        // in case you don't have dojo.event.* pulled in
        connect: function(/*Object*/srcObj, /*Function*/srcFcn, /*Function*/targetFcn) {
                //summary: internal function used to connect event listeners to form elements
                //that trigger events. Used in case dojo.event is not loaded.
                if(dojo.evalObjPath("dojo.event.connect")) {
                        dojo.event.connect(srcObj, srcFcn, this, targetFcn);
                } else {
                        var fcn = dojo.lang.hitch(this, targetFcn);
                        srcObj[srcFcn] = function(e) {
                                if(!e) { e = window.event; }
                                if(!e.currentTarget) { e.currentTarget = e.srcElement; }
                                if(!e.preventDefault) { e.preventDefault = function() { window.event.returnValue = false; } }
                                fcn(e);
                        }
                }
        }
});

dojo.io.XMLHTTPTransport = new function(){
        //summary: The object that implements the dojo.io.bind transport for XMLHttpRequest.
        var _this = this;

        var _cache = {}; // FIXME: make this public? do we even need to?
        this.useCache = false; // if this is true, we'll cache unless kwArgs.useCache = false
        this.preventCache = false; // if this is true, we'll always force GET requests to cache

        // FIXME: Should this even be a function? or do we just hard code it in the next 2 functions?
        function getCacheKey(url, query, method) {
                return url + "|" + query + "|" + method.toLowerCase();
        }

        function addToCache(url, query, method, http) {
                _cache[getCacheKey(url, query, method)] = http;
        }

        function getFromCache(url, query, method) {
                return _cache[getCacheKey(url, query, method)];
        }

        this.clearCache = function() {
                _cache = {};
        }

        // moved successful load stuff here
        function doLoad(kwArgs, http, url, query, useCache) {
                if(     ((http.status>=200)&&(http.status<300))||       // allow any 2XX response code
                        (http.status==304)||                                            // get it out of the cache
                        (http.status==1223)||                                           // Internet Explorer mangled the status code
                        (location.protocol=="file:" && (http.status==0 || http.status==undefined))||
                        (location.protocol=="chrome:" && (http.status==0 || http.status==undefined))
                ){
                        var ret;
                        if(kwArgs.method.toLowerCase() == "head"){
                                var headers = http.getAllResponseHeaders();
                                ret = {};
                                ret.toString = function(){ return headers; }
                                var values = headers.split(/[\r\n]+/g);
                                for(var i = 0; i < values.length; i++) {
                                        var pair = values[i].match(/^([^:]+)\s*:\s*(.+)$/i);
                                        if(pair) {
                                                ret[pair[1]] = pair[2];
                                        }
                                }
                        }else if(kwArgs.mimetype == "text/javascript"){
                                try{
                                        ret = dj_eval(http.responseText);
                                }catch(e){
                                        dojo.debug(e);
                                        dojo.debug(http.responseText);
                                        ret = null;
                                }
                        }else if(kwArgs.mimetype.substr(0, 9) == "text/json" || kwArgs.mimetype.substr(0, 16) == "application/json"){
                                try{
                                        ret = dj_eval("("+kwArgs.jsonFilter(http.responseText)+")");
                                }catch(e){
                                        dojo.debug(e);
                                        dojo.debug(http.responseText);
                                        ret = false;
                                }
                        }else if((kwArgs.mimetype == "application/xml")||
                                                (kwArgs.mimetype == "text/xml")){
                                ret = http.responseXML;
                                if(!ret || typeof ret == "string" || !http.getResponseHeader("Content-Type")) {
                                        ret = dojo.dom.createDocumentFromText(http.responseText);
                                }
                        }else{
                                ret = http.responseText;
                        }

                        if(useCache){ // only cache successful responses
                                addToCache(url, query, kwArgs.method, http);
                        }
                        kwArgs[(typeof kwArgs.load == "function") ? "load" : "handle"]("load", ret, http, kwArgs);
                }else{
                        var errObj = new dojo.io.Error("XMLHttpTransport Error: "+http.status+" "+http.statusText);
                        kwArgs[(typeof kwArgs.error == "function") ? "error" : "handle"]("error", errObj, http, kwArgs);
                }
        }

        // set headers (note: Content-Type will get overriden if kwArgs.contentType is set)
        function setHeaders(http, kwArgs){
                if(kwArgs["headers"]) {
                        for(var header in kwArgs["headers"]) {
                                if(header.toLowerCase() == "content-type" && !kwArgs["contentType"]) {
                                        kwArgs["contentType"] = kwArgs["headers"][header];
                                } else {
                                        http.setRequestHeader(header, kwArgs["headers"][header]);
                                }
                        }
                }
        }

        this.inFlight = [];
        this.inFlightTimer = null;

        this.startWatchingInFlight = function(){
                //summary: internal method used to trigger a timer to watch all inflight
                //XMLHttpRequests.
                if(!this.inFlightTimer){
                        // setInterval broken in mozilla x86_64 in some circumstances, see
                        // https://bugzilla.mozilla.org/show_bug.cgi?id=344439
                        // using setTimeout instead
                        this.inFlightTimer = setTimeout("dojo.io.XMLHTTPTransport.watchInFlight();", 10);
                }
        }

        this.watchInFlight = function(){
                //summary: internal method that checks each inflight XMLHttpRequest to see
                //if it has completed or if the timeout situation applies.
                var now = null;
                // make sure sync calls stay thread safe, if this callback is called during a sync call
                // and this results in another sync call before the first sync call ends the browser hangs
                if(!dojo.hostenv._blockAsync && !_this._blockAsync){
                        for(var x=this.inFlight.length-1; x>=0; x--){
                                try{
                                        var tif = this.inFlight[x];
                                        if(!tif || tif.http._aborted || !tif.http.readyState){
                                                this.inFlight.splice(x, 1); continue; 
                                        }
                                        if(4==tif.http.readyState){
                                                // remove it so we can clean refs
                                                this.inFlight.splice(x, 1);
                                                doLoad(tif.req, tif.http, tif.url, tif.query, tif.useCache);
                                        }else if (tif.startTime){
                                                //See if this is a timeout case.
                                                if(!now){
                                                        now = (new Date()).getTime();
                                                }
                                                if(tif.startTime + (tif.req.timeoutSeconds * 1000) < now){
                                                        //Stop the request.
                                                        if(typeof tif.http.abort == "function"){
                                                                tif.http.abort();
                                                        }
                
                                                        // remove it so we can clean refs
                                                        this.inFlight.splice(x, 1);
                                                        tif.req[(typeof tif.req.timeout == "function") ? "timeout" : "handle"]("timeout", null, tif.http, tif.req);
                                                }
                                        }
                                }catch(e){
                                        try{
                                                var errObj = new dojo.io.Error("XMLHttpTransport.watchInFlight Error: " + e);
                                                tif.req[(typeof tif.req.error == "function") ? "error" : "handle"]("error", errObj, tif.http, tif.req);
                                        }catch(e2){
                                                dojo.debug("XMLHttpTransport error callback failed: " + e2);
                                        }
                                }
                        }
                }

                clearTimeout(this.inFlightTimer);
                if(this.inFlight.length == 0){
                        this.inFlightTimer = null;
                        return;
                }
                this.inFlightTimer = setTimeout("dojo.io.XMLHTTPTransport.watchInFlight();", 10);
        }

        var hasXmlHttp = dojo.hostenv.getXmlhttpObject() ? true : false;
        this.canHandle = function(/*dojo.io.Request*/kwArgs){
                //summary: Tells dojo.io.bind() if this is a good transport to
                //use for the particular type of request. This type of transport cannot
                //handle forms that have an input type="file" element.

                // FIXME: we need to determine when form values need to be
                // multi-part mime encoded and avoid using this transport for those
                // requests.
                var mlc = kwArgs["mimetype"].toLowerCase()||"";
                return hasXmlHttp
                        && (
                                (
                                        dojo.lang.inArray([
                                                "text/plain", "text/html", "application/xml", 
                                                "text/xml", "text/javascript"
                                                ], mlc
                                        )
                                ) || (
                                        mlc.substr(0, 9) == "text/json" || mlc.substr(0, 16) == "application/json"
                                )
                        )
                        && !( kwArgs["formNode"] && dojo.io.formHasFile(kwArgs["formNode"]) ); //boolean
        }

        this.multipartBoundary = "45309FFF-BD65-4d50-99C9-36986896A96F";        // unique guid as a boundary value for multipart posts

        this.bind = function(/*dojo.io.Request*/kwArgs){
                //summary: function that sends the request to the server.

                //This function will attach an abort() function to the kwArgs dojo.io.Request object,
                //so if you need to abort the request, you can call that method on the request object.
                //The following are acceptable properties in kwArgs (in addition to the
                //normal dojo.io.Request object properties).
                //url: String: URL the server URL to use for the request.
                //method: String: the HTTP method to use (GET, POST, etc...).
                //mimetype: Specifies what format the result data should be given to the load/handle callback. Valid values are:
                //              text/javascript, text/json, application/json, application/xml, text/xml. Any other mimetype will give back a text
                //              string.
                //transport: String: specify "XMLHTTPTransport" to force the use of this XMLHttpRequest transport.
                //headers: Object: The object property names and values will be sent as HTTP request header
                //              names and values.
                //sendTransport: boolean: If true, then dojo.transport=xmlhttp will be added to the request.
                //encoding: String: The type of encoding to use when dealing with the content kwArgs property.
                //content: Object: The content object is converted into a name=value&name=value string, by
                //              using dojo.io.argsFromMap(). The encoding kwArgs property is passed to dojo.io.argsFromMap()
                //              for use in encoding the names and values. The resulting string is added to the request.
                //formNode: DOMNode: a form element node. This should not normally be used. Use new dojo.io.FormBind() instead.
                //              If formNode is used, then the names and values of the form elements will be converted
                //              to a name=value&name=value string and added to the request. The encoding kwArgs property is used
                //              to encode the names and values.
                //postContent: String: Raw name=value&name=value string to be included as part of the request.
                //back or backButton: Function: A function to be called if the back button is pressed. If this kwArgs property
                //              is used, then back button support via dojo.undo.browser will be used. See notes for dojo.undo.browser on usage.
                //              You need to set djConfig.preventBackButtonFix = false to enable back button support.
                //changeUrl: boolean or String: Used as part of back button support. See notes for dojo.undo.browser on usage.
                //user: String: The user name. Used in conjuction with password. Passed to XMLHttpRequest.open().
                //password: String: The user's password. Used in conjuction with user. Passed to XMLHttpRequest.open().
                //file: Object or Array of Objects: an object simulating a file to be uploaded. file objects should have the following properties:
                //              name or fileName: the name of the file
                //              contentType: the MIME content type for the file.
                //              content: the actual content of the file.
                //multipart: boolean: indicates whether this should be a multipart mime request. If kwArgs.file exists, then this
                //              property is set to true automatically.
                //sync: boolean: if true, then a synchronous XMLHttpRequest call is done,
                //              if false (the default), then an asynchronous call is used.
                //preventCache: boolean: If true, then a cache busting parameter is added to the request URL.
                //              default value is false.
                //useCache: boolean: If true, then XMLHttpTransport will keep an internal cache of the server
                //              response and use that response if a similar request is done again.
                //              A similar request is one that has the same URL, query string and HTTP method value.
                //              default is false.
                if(!kwArgs["url"]){
                        // are we performing a history action?
                        if( !kwArgs["formNode"]
                                && (kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"] || kwArgs["watchForURL"])
                                && (!djConfig.preventBackButtonFix)) {
        dojo.deprecated("Using dojo.io.XMLHTTPTransport.bind() to add to browser history without doing an IO request",
                                        "Use dojo.undo.browser.addToHistory() instead.", "0.4");
                                dojo.undo.browser.addToHistory(kwArgs);
                                return true;
                        }
                }

                // build this first for cache purposes
                var url = kwArgs.url;
                var query = "";
                if(kwArgs["formNode"]){
                        var ta = kwArgs.formNode.getAttribute("action");
                        if((ta)&&(!kwArgs["url"])){ url = ta; }
                        var tp = kwArgs.formNode.getAttribute("method");
                        if((tp)&&(!kwArgs["method"])){ kwArgs.method = tp; }
                        query += dojo.io.encodeForm(kwArgs.formNode, kwArgs.encoding, kwArgs["formFilter"]);
                }

                if(url.indexOf("#") > -1) {
                        dojo.debug("Warning: dojo.io.bind: stripping hash values from url:", url);
                        url = url.split("#")[0];
                }

                if(kwArgs["file"]){
                        // force post for file transfer
                        kwArgs.method = "post";
                }

                if(!kwArgs["method"]){
                        kwArgs.method = "get";
                }

                // guess the multipart value
                if(kwArgs.method.toLowerCase() == "get"){
                        // GET cannot use multipart
                        kwArgs.multipart = false;
                }else{
                        if(kwArgs["file"]){
                                // enforce multipart when sending files
                                kwArgs.multipart = true;
                        }else if(!kwArgs["multipart"]){
                                // default 
                                kwArgs.multipart = false;
                        }
                }

                if(kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"]){
                        dojo.undo.browser.addToHistory(kwArgs);
                }

                var content = kwArgs["content"] || {};

                if(kwArgs.sendTransport) {
                        content["dojo.transport"] = "xmlhttp";
                }

                do { // break-block
                        if(kwArgs.postContent){
                                query = kwArgs.postContent;
                                break;
                        }

                        if(content) {
                                query += dojo.io.argsFromMap(content, kwArgs.encoding);
                        }
                        
                        if(kwArgs.method.toLowerCase() == "get" || !kwArgs.multipart){
                                break;
                        }

                        var     t = [];
                        if(query.length){
                                var q = query.split("&");
                                for(var i = 0; i < q.length; ++i){
                                        if(q[i].length){
                                                var p = q[i].split("=");
                                                t.push( "--" + this.multipartBoundary,
                                                                "Content-Disposition: form-data; name=\"" + p[0] + "\"", 
                                                                "",
                                                                p[1]);
                                        }
                                }
                        }

                        if(kwArgs.file){
                                if(dojo.lang.isArray(kwArgs.file)){
                                        for(var i = 0; i < kwArgs.file.length; ++i){
                                                var o = kwArgs.file[i];
                                                t.push( "--" + this.multipartBoundary,
                                                                "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"",
                                                                "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"),
                                                                "",
                                                                o.content);
                                        }
                                }else{
                                        var o = kwArgs.file;
                                        t.push( "--" + this.multipartBoundary,
                                                        "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"",
                                                        "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"),
                                                        "",
                                                        o.content);
                                }
                        }

                        if(t.length){
                                t.push("--"+this.multipartBoundary+"--", "");
                                query = t.join("\r\n");
                        }
                }while(false);

                // kwArgs.Connection = "close";

                var async = kwArgs["sync"] ? false : true;

                var preventCache = kwArgs["preventCache"] ||
                        (this.preventCache == true && kwArgs["preventCache"] != false);
                var useCache = kwArgs["useCache"] == true ||
                        (this.useCache == true && kwArgs["useCache"] != false );

                // preventCache is browser-level (add query string junk), useCache
                // is for the local cache. If we say preventCache, then don't attempt
                // to look in the cache, but if useCache is true, we still want to cache
                // the response
                if(!preventCache && useCache){
                        var cachedHttp = getFromCache(url, query, kwArgs.method);
                        if(cachedHttp){
                                doLoad(kwArgs, cachedHttp, url, query, false);
                                return;
                        }
                }

                // much of this is from getText, but reproduced here because we need
                // more flexibility
                var http = dojo.hostenv.getXmlhttpObject(kwArgs);       
                var received = false;

                // build a handler function that calls back to the handler obj
                if(async){
                        var startTime = 
                        // FIXME: setting up this callback handler leaks on IE!!!
                        this.inFlight.push({
                                "req":          kwArgs,
                                "http":         http,
                                "url":          url,
                                "query":        query,
                                "useCache":     useCache,
                                "startTime": kwArgs.timeoutSeconds ? (new Date()).getTime() : 0
                        });
                        this.startWatchingInFlight();
                }else{
                        // block async callbacks until sync is in, needed in khtml, others?
                        _this._blockAsync = true;
                }

                if(kwArgs.method.toLowerCase() == "post"){
                        // FIXME: need to hack in more flexible Content-Type setting here!
                        if (!kwArgs.user) {
                                http.open("POST", url, async);
                        }else{
        http.open("POST", url, async, kwArgs.user, kwArgs.password);
                        }
                        setHeaders(http, kwArgs);
                        http.setRequestHeader("Content-Type", kwArgs.multipart ? ("multipart/form-data; boundary=" + this.multipartBoundary) : 
                                (kwArgs.contentType || "application/x-www-form-urlencoded"));
                        try{
                                http.send(query);
                        }catch(e){
                                if(typeof http.abort == "function"){
                                        http.abort();
                                }
                                doLoad(kwArgs, {status: 404}, url, query, useCache);
                        }
                }else{
                        var tmpUrl = url;
                        if(query != "") {
                                tmpUrl += (tmpUrl.indexOf("?") > -1 ? "&" : "?") + query;
                        }
                        if(preventCache) {
                                tmpUrl += (dojo.string.endsWithAny(tmpUrl, "?", "&")
                                        ? "" : (tmpUrl.indexOf("?") > -1 ? "&" : "?")) + "dojo.preventCache=" + new Date().valueOf();
                        }
                        if (!kwArgs.user) {
                                http.open(kwArgs.method.toUpperCase(), tmpUrl, async);
                        }else{
                                http.open(kwArgs.method.toUpperCase(), tmpUrl, async, kwArgs.user, kwArgs.password);
                        }
                        setHeaders(http, kwArgs);
                        try {
                                http.send(null);
                        }catch(e)       {
                                if(typeof http.abort == "function"){
                                        http.abort();
                                }
                                doLoad(kwArgs, {status: 404}, url, query, useCache);
                        }
                }

                if( !async ) {
                        doLoad(kwArgs, http, url, query, useCache);
                        _this._blockAsync = false;
                }

                kwArgs.abort = function(){
                        try{// khtml doesent reset readyState on abort, need this workaround
                                http._aborted = true; 
                        }catch(e){/*squelsh*/}
                        return http.abort();
                }

                return;
        }
        dojo.io.transports.addTransport("XMLHTTPTransport");
}

}

dojo.provide("dojo.io.cookie");

dojo.io.cookie.setCookie = function(/*String*/name, /*String*/value, 
                                                                        /*Number?*/days, /*String?*/path, 
                                                                        /*String?*/domain, /*boolean?*/secure){
        //summary: sets a cookie.
        var expires = -1;
        if((typeof days == "number")&&(days >= 0)){
                var d = new Date();
                d.setTime(d.getTime()+(days*24*60*60*1000));
                expires = d.toGMTString();
        }
        value = escape(value);
        document.cookie = name + "=" + value + ";"
                + (expires != -1 ? " expires=" + expires + ";" : "")
                + (path ? "path=" + path : "")
                + (domain ? "; domain=" + domain : "")
                + (secure ? "; secure" : "");
}

dojo.io.cookie.set = dojo.io.cookie.setCookie;

dojo.io.cookie.getCookie = function(/*String*/name){
        //summary: Gets a cookie with the given name.

        // FIXME: Which cookie should we return?
        //        If there are cookies set for different sub domains in the current
        //        scope there could be more than one cookie with the same name.
        //        I think taking the last one in the list takes the one from the
        //        deepest subdomain, which is what we're doing here.
        var idx = document.cookie.lastIndexOf(name+'=');
        if(idx == -1) { return null; }
        var value = document.cookie.substring(idx+name.length+1);
        var end = value.indexOf(';');
        if(end == -1) { end = value.length; }
        value = value.substring(0, end);
        value = unescape(value);
        return value; //String
}

dojo.io.cookie.get = dojo.io.cookie.getCookie;

dojo.io.cookie.deleteCookie = function(/*String*/name){
        //summary: Deletes a cookie with the given name.
        dojo.io.cookie.setCookie(name, "-", 0);
}

dojo.io.cookie.setObjectCookie = function(      /*String*/name, /*Object*/obj, 
                                                                                        /*Number?*/days, /*String?*/path, 
                                                                                        /*String?*/domain, /*boolean?*/secure, 
                                                                                        /*boolean?*/clearCurrent){
        //summary: Takes an object, serializes it to a cookie value, and either
        //sets a cookie with the serialized value.
        //description: If clearCurrent is true, then any current cookie value
        //for this object will be replaced with the the new serialized object value.
        //If clearCurrent is false, then the existing cookie value will be modified
        //with any changes from the new object value.
        //Objects must be simple name/value pairs where the value is either a string
        //or a number. Any other value will be ignored.
        if(arguments.length == 5){ // for backwards compat
                clearCurrent = domain;
                domain = null;
                secure = null;
        }
        var pairs = [], cookie, value = "";
        if(!clearCurrent){
                cookie = dojo.io.cookie.getObjectCookie(name);
        }
        if(days >= 0){
                if(!cookie){ cookie = {}; }
                for(var prop in obj){
                        if(obj[prop] == null){
                                delete cookie[prop];
                        }else if((typeof obj[prop] == "string")||(typeof obj[prop] == "number")){
                                cookie[prop] = obj[prop];
                        }
                }
                prop = null;
                for(var prop in cookie){
                        pairs.push(escape(prop) + "=" + escape(cookie[prop]));
                }
                value = pairs.join("&");
        }
        dojo.io.cookie.setCookie(name, value, days, path, domain, secure);
}

dojo.io.cookie.getObjectCookie = function(/*String*/name){
        //summary: Gets an object value for the given cookie name. The complement of
        //dojo.io.cookie.setObjectCookie().
        var values = null, cookie = dojo.io.cookie.getCookie(name);
        if(cookie){
                values = {};
                var pairs = cookie.split("&");
                for(var i = 0; i < pairs.length; i++){
                        var pair = pairs[i].split("=");
                        var value = pair[1];
                        if( isNaN(value) ){ value = unescape(pair[1]); }
                        values[ unescape(pair[0]) ] = value;
                }
        }
        return values;
}

dojo.io.cookie.isSupported = function(){
        //summary: Tests the browser to see if cookies are enabled.
        if(typeof navigator.cookieEnabled != "boolean"){
                dojo.io.cookie.setCookie("__TestingYourBrowserForCookieSupport__",
                        "CookiesAllowed", 90, null);
                var cookieVal = dojo.io.cookie.getCookie("__TestingYourBrowserForCookieSupport__");
                navigator.cookieEnabled = (cookieVal == "CookiesAllowed");
                if(navigator.cookieEnabled){
                        // FIXME: should we leave this around?
                        this.deleteCookie("__TestingYourBrowserForCookieSupport__");
                }
        }
        return navigator.cookieEnabled; //boolean
}

// need to leave this in for backwards-compat from 0.1 for when it gets pulled in by dojo.io.*
if(!dojo.io.cookies){ dojo.io.cookies = dojo.io.cookie; }

dojo.kwCompoundRequire({
        common: ["dojo.io.common"],
        rhino: ["dojo.io.RhinoIO"],
        browser: ["dojo.io.BrowserIO", "dojo.io.cookie"],
        dashboard: ["dojo.io.BrowserIO", "dojo.io.cookie"]
});
dojo.provide("dojo.io.*");

dojo.provide("dojo.event.common");





// TODO: connection filter functions
//                      these are functions that accept a method invocation (like around
//                      advice) and return a boolean based on it. That value determines
//                      whether or not the connection proceeds. It could "feel" like around
//                      advice for those who know what it is (calling proceed() or not),
//                      but I think presenting it as a "filter" and/or calling it with the
//                      function args and not the MethodInvocation might make it more
//                      palletable to "normal" users than around-advice currently is
// TODO: execution scope mangling
//                      YUI's event facility by default executes listeners in the context
//                      of the source object. This is very odd, but should probably be
//                      supported as an option (both for the source and for the dest). It
//                      can be thought of as a connection-specific hitch().
// TODO: more resiliency for 4+ arguments to connect()

dojo.event = new function(){
        this._canTimeout = dojo.lang.isFunction(dj_global["setTimeout"])||dojo.lang.isAlien(dj_global["setTimeout"]);

        // FIXME: where should we put this method (not here!)?
        function interpolateArgs(args, searchForNames){
                var dl = dojo.lang;
                var ao = {
                        srcObj: dj_global,
                        srcFunc: null,
                        adviceObj: dj_global,
                        adviceFunc: null,
                        aroundObj: null,
                        aroundFunc: null,
                        adviceType: (args.length>2) ? args[0] : "after",
                        precedence: "last",
                        once: false,
                        delay: null,
                        rate: 0,
                        adviceMsg: false,
                        maxCalls: -1
                };

                switch(args.length){
                        case 0: return;
                        case 1: return;
                        case 2:
                                ao.srcFunc = args[0];
                                ao.adviceFunc = args[1];
                                break;
                        case 3:
                                if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isString(args[2]))){
                                        ao.adviceType = "after";
                                        ao.srcObj = args[0];
                                        ao.srcFunc = args[1];
                                        ao.adviceFunc = args[2];
                                }else if((dl.isString(args[1]))&&(dl.isString(args[2]))){
                                        ao.srcFunc = args[1];
                                        ao.adviceFunc = args[2];
                                }else if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isFunction(args[2]))){
                                        ao.adviceType = "after";
                                        ao.srcObj = args[0];
                                        ao.srcFunc = args[1];
                                        var tmpName  = dl.nameAnonFunc(args[2], ao.adviceObj, searchForNames);
                                        ao.adviceFunc = tmpName;
                                }else if((dl.isFunction(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))){
                                        ao.adviceType = "after";
                                        ao.srcObj = dj_global;
                                        var tmpName  = dl.nameAnonFunc(args[0], ao.srcObj, searchForNames);
                                        ao.srcFunc = tmpName;
                                        ao.adviceObj = args[1];
                                        ao.adviceFunc = args[2];
                                }
                                break;
                        case 4:
                                if((dl.isObject(args[0]))&&(dl.isObject(args[2]))){
                                        // we can assume that we've got an old-style "connect" from
                                        // the sigslot school of event attachment. We therefore
                                        // assume after-advice.
                                        ao.adviceType = "after";
                                        ao.srcObj = args[0];
                                        ao.srcFunc = args[1];
                                        ao.adviceObj = args[2];
                                        ao.adviceFunc = args[3];
                                }else if((dl.isString(args[0]))&&(dl.isString(args[1]))&&(dl.isObject(args[2]))){
                                        ao.adviceType = args[0];
                                        ao.srcObj = dj_global;
                                        ao.srcFunc = args[1];
                                        ao.adviceObj = args[2];
                                        ao.adviceFunc = args[3];
                                }else if((dl.isString(args[0]))&&(dl.isFunction(args[1]))&&(dl.isObject(args[2]))){
                                        ao.adviceType = args[0];
                                        ao.srcObj = dj_global;
                                        var tmpName  = dl.nameAnonFunc(args[1], dj_global, searchForNames);
                                        ao.srcFunc = tmpName;
                                        ao.adviceObj = args[2];
                                        ao.adviceFunc = args[3];
                                }else if((dl.isString(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))&&(dl.isFunction(args[3]))){
                                        ao.srcObj = args[1];
                                        ao.srcFunc = args[2];
                                        var tmpName  = dl.nameAnonFunc(args[3], dj_global, searchForNames);
                                        ao.adviceObj = dj_global;
                                        ao.adviceFunc = tmpName;
                                }else if(dl.isObject(args[1])){
                                        ao.srcObj = args[1];
                                        ao.srcFunc = args[2];
                                        ao.adviceObj = dj_global;
                                        ao.adviceFunc = args[3];
                                }else if(dl.isObject(args[2])){
                                        ao.srcObj = dj_global;
                                        ao.srcFunc = args[1];
                                        ao.adviceObj = args[2];
                                        ao.adviceFunc = args[3];
                                }else{
                                        ao.srcObj = ao.adviceObj = ao.aroundObj = dj_global;
                                        ao.srcFunc = args[1];
                                        ao.adviceFunc = args[2];
                                        ao.aroundFunc = args[3];
                                }
                                break;
                        case 6:
                                ao.srcObj = args[1];
                                ao.srcFunc = args[2];
                                ao.adviceObj = args[3]
                                ao.adviceFunc = args[4];
                                ao.aroundFunc = args[5];
                                ao.aroundObj = dj_global;
                                break;
                        default:
                                ao.srcObj = args[1];
                                ao.srcFunc = args[2];
                                ao.adviceObj = args[3]
                                ao.adviceFunc = args[4];
                                ao.aroundObj = args[5];
                                ao.aroundFunc = args[6];
                                ao.once = args[7];
                                ao.delay = args[8];
                                ao.rate = args[9];
                                ao.adviceMsg = args[10];
                                ao.maxCalls = (!isNaN(parseInt(args[11]))) ? args[11] : -1;
                                break;
                }

                if(dl.isFunction(ao.aroundFunc)){
                        var tmpName  = dl.nameAnonFunc(ao.aroundFunc, ao.aroundObj, searchForNames);
                        ao.aroundFunc = tmpName;
                }

                if(dl.isFunction(ao.srcFunc)){
                        ao.srcFunc = dl.getNameInObj(ao.srcObj, ao.srcFunc);
                }

                if(dl.isFunction(ao.adviceFunc)){
                        ao.adviceFunc = dl.getNameInObj(ao.adviceObj, ao.adviceFunc);
                }

                if((ao.aroundObj)&&(dl.isFunction(ao.aroundFunc))){
                        ao.aroundFunc = dl.getNameInObj(ao.aroundObj, ao.aroundFunc);
                }

                if(!ao.srcObj){
                        dojo.raise("bad srcObj for srcFunc: "+ao.srcFunc);
                }
                if(!ao.adviceObj){
                        dojo.raise("bad adviceObj for adviceFunc: "+ao.adviceFunc);
                }
                
                if(!ao.adviceFunc){
                        dojo.debug("bad adviceFunc for srcFunc: "+ao.srcFunc);
                        dojo.debugShallow(ao);
                } 
                
                return ao;
        }

        this.connect = function(/*...*/){
                // summary:
                //              dojo.event.connect is the glue that holds most Dojo-based
                //              applications together. Most combinations of arguments are
                //              supported, with the connect() method attempting to disambiguate
                //              the implied types of positional parameters. The following will
                //              all work:
                //                      dojo.event.connect("globalFunctionName1", "globalFunctionName2");
                //                      dojo.event.connect(functionReference1, functionReference2);
                //                      dojo.event.connect("globalFunctionName1", functionReference2);
                //                      dojo.event.connect(functionReference1, "globalFunctionName2");
                //                      dojo.event.connect(scope1, "functionName1", "globalFunctionName2");
                //                      dojo.event.connect("globalFunctionName1", scope2, "functionName2");
                //                      dojo.event.connect(scope1, "functionName1", scope2, "functionName2");
                //                      dojo.event.connect("after", scope1, "functionName1", scope2, "functionName2");
                //                      dojo.event.connect("before", scope1, "functionName1", scope2, "functionName2");
                //                      dojo.event.connect("around",    scope1, "functionName1", 
                //                                                                                      scope2, "functionName2",
                //                                                                                      aroundFunctionReference);
                //                      dojo.event.connect("around",    scope1, "functionName1", 
                //                                                                                      scope2, "functionName2",
                //                                                                                      scope3, "aroundFunctionName");
                //                      dojo.event.connect("before-around",     scope1, "functionName1", 
                //                                                                                                      scope2, "functionName2",
                //                                                                                                      aroundFunctionReference);
                //                      dojo.event.connect("after-around",              scope1, "functionName1", 
                //                                                                                                      scope2, "functionName2",
                //                                                                                                      aroundFunctionReference);
                //                      dojo.event.connect("after-around",              scope1, "functionName1", 
                //                                                                                                      scope2, "functionName2",
                //                                                                                                      scope3, "aroundFunctionName");
                //                      dojo.event.connect("around",    scope1, "functionName1", 
                //                                                                                      scope2, "functionName2",
                //                                                                                      scope3, "aroundFunctionName", true, 30);
                //                      dojo.event.connect("around",    scope1, "functionName1", 
                //                                                                                      scope2, "functionName2",
                //                                                                                      scope3, "aroundFunctionName", null, null, 10);
                // adviceType: 
                //              Optional. String. One of "before", "after", "around",
                //              "before-around", or "after-around". FIXME
                // srcObj:
                //              the scope in which to locate/execute the named srcFunc. Along
                //              with srcFunc, this creates a way to dereference the function to
                //              call. So if the function in question is "foo.bar", the
                //              srcObj/srcFunc pair would be foo and "bar", where "bar" is a
                //              string and foo is an object reference.
                // srcFunc:
                //              the name of the function to connect to. When it is executed,
                //              the listener being registered with this call will be called.
                //              The adviceType defines the call order between the source and
                //              the target functions.
                // adviceObj:
                //              the scope in which to locate/execute the named adviceFunc.
                // adviceFunc:
                //              the name of the function being conected to srcObj.srcFunc
                // aroundObj:
                //              the scope in which to locate/execute the named aroundFunc.
                // aroundFunc:
                //              the name of, or a reference to, the function that will be used
                //              to mediate the advice call. Around advice requires a special
                //              unary function that will be passed a "MethodInvocation" object.
                //              These objects have several important properties, namely:
                //                      - args
                //                              a mutable array of arguments to be passed into the
                //                              wrapped function
                //                      - proceed
                //                              a function that "continues" the invocation. The result
                //                              of this function is the return of the wrapped function.
                //                              You can then manipulate this return before passing it
                //                              back out (or take further action based on it).
                // once:
                //              boolean that determines whether or not this connect() will
                //              create a new connection if an identical connect() has already
                //              been made. Defaults to "false".
                // delay:
                //              an optional delay (in ms), as an integer, for dispatch of a
                //              listener after the source has been fired.
                // rate:
                //              an optional rate throttling parameter (integer, in ms). When
                //              specified, this particular connection will not fire more than
                //              once in the interval specified by the rate
                // adviceMsg:
                //              boolean. Should the listener have all the parameters passed in
                //              as a single argument?

                /*
                                ao.adviceType = args[0];
                                ao.srcObj = args[1];
                                ao.srcFunc = args[2];
                                ao.adviceObj = args[3]
                                ao.adviceFunc = args[4];
                                ao.aroundObj = args[5];
                                ao.aroundFunc = args[6];
                                ao.once = args[7];
                                ao.delay = args[8];
                                ao.rate = args[9];
                                ao.adviceMsg = args[10];
                                ao.maxCalls = args[11];
                */
                if(arguments.length == 1){
                        var ao = arguments[0];
                }else{
                        var ao = interpolateArgs(arguments, true);
                }
                if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){
                        if(dojo.render.html.ie){
                                ao.srcFunc = "onkeydown";
                                this.connect(ao);
                        }
                        ao.srcFunc = "onkeypress";
                }

                if(dojo.lang.isArray(ao.srcObj) && ao.srcObj!=""){
                        var tmpAO = {};
                        for(var x in ao){
                                tmpAO[x] = ao[x];
                        }
                        var mjps = [];
                        dojo.lang.forEach(ao.srcObj, function(src){
                                if((dojo.render.html.capable)&&(dojo.lang.isString(src))){
                                        src = dojo.byId(src);
                                        // dojo.debug(src);
                                }
                                tmpAO.srcObj = src;
                                // dojo.debug(tmpAO.srcObj, tmpAO.srcFunc);
                                // dojo.debug(tmpAO.adviceObj, tmpAO.adviceFunc);
                                mjps.push(dojo.event.connect.call(dojo.event, tmpAO));
                        });
                        return mjps;
                }

                // FIXME: just doing a "getForMethod()" seems to be enough to put this into infinite recursion!!
                var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc);
                if(ao.adviceFunc){
                        var mjp2 = dojo.event.MethodJoinPoint.getForMethod(ao.adviceObj, ao.adviceFunc);
                }

                mjp.kwAddAdvice(ao);

                // advanced users might want to fsck w/ the join point manually
                return mjp; // a MethodJoinPoint object
        }

        this.log = function(/*object or funcName*/ a1, /*funcName*/ a2){
                // summary:
                //              a function that will wrap and log all calls to the specified
                //              a1.a2() function. If only a1 is passed, it'll be used as a
                //              function or function name on the global context. Logging will
                //              be sent to dojo.debug
                // a1:
                //              if a2 is passed, this should be an object. If not, it can be a
                //              function or function name.
                // a2:
                //              a function name
                var kwArgs;
                if((arguments.length == 1)&&(typeof a1 == "object")){
                        kwArgs = a1;
                }else{
                        kwArgs = {
                                srcObj: a1,
                                srcFunc: a2
                        };
                }
                kwArgs.adviceFunc = function(){
                        var argsStr = [];
                        for(var x=0; x<arguments.length; x++){
                                argsStr.push(arguments[x]);
                        }
                        dojo.debug("("+kwArgs.srcObj+")."+kwArgs.srcFunc, ":", argsStr.join(", "));
                };
                this.kwConnect(kwArgs);
        }

        this.connectBefore = function(){
                // summary:
                //              takes the same parameters as dojo.event.connect(), except that
                //              the advice type will always be "before"
                var args = ["before"];
                for(var i = 0; i < arguments.length; i++){ args.push(arguments[i]); }
                return this.connect.apply(this, args); // a MethodJoinPoint object
        }

        this.connectAround = function(){
                // summary:
                //              takes the same parameters as dojo.event.connect(), except that
                //              the advice type will always be "around"
                var args = ["around"];
                for(var i = 0; i < arguments.length; i++){ args.push(arguments[i]); }
                return this.connect.apply(this, args); // a MethodJoinPoint object
        }

        this.connectOnce = function(){
                // summary:
                //              takes the same parameters as dojo.event.connect(), except that
                //              the "once" flag will always be set to "true"
                var ao = interpolateArgs(arguments, true);
                ao.once = true;
                return this.connect(ao); // a MethodJoinPoint object
        }

        this.connectRunOnce = function(){
                // summary:
                //              takes the same parameters as dojo.event.connect(), except that
                //              the "maxCalls" flag will always be set to 1
                var ao = interpolateArgs(arguments, true);
                ao.maxCalls = 1;
                return this.connect(ao); // a MethodJoinPoint object
        }

        this._kwConnectImpl = function(kwArgs, disconnect){
                var fn = (disconnect) ? "disconnect" : "connect";
                if(typeof kwArgs["srcFunc"] == "function"){
                        kwArgs.srcObj = kwArgs["srcObj"]||dj_global;
                        var tmpName  = dojo.lang.nameAnonFunc(kwArgs.srcFunc, kwArgs.srcObj, true);
                        kwArgs.srcFunc = tmpName;
                }
                if(typeof kwArgs["adviceFunc"] == "function"){
                        kwArgs.adviceObj = kwArgs["adviceObj"]||dj_global;
                        var tmpName  = dojo.lang.nameAnonFunc(kwArgs.adviceFunc, kwArgs.adviceObj, true);
                        kwArgs.adviceFunc = tmpName;
                }
                kwArgs.srcObj = kwArgs["srcObj"]||dj_global;
                kwArgs.adviceObj = kwArgs["adviceObj"]||kwArgs["targetObj"]||dj_global;
                kwArgs.adviceFunc = kwArgs["adviceFunc"]||kwArgs["targetFunc"];
                // pass kwargs to avoid unrolling/repacking
                return dojo.event[fn](kwArgs);
        }

        this.kwConnect = function(/*Object*/ kwArgs){
                // summary:
                //              A version of dojo.event.connect() that takes a map of named
                //              parameters instead of the positional parameters that
                //              dojo.event.connect() uses. For many advanced connection types,
                //              this can be a much more readable (and potentially faster)
                //              alternative.
                // kwArgs:
                //              An object that can have the following properties:
                //                      - adviceType
                //                      - srcObj
                //                      - srcFunc
                //                      - adviceObj
                //                      - adviceFunc 
                //                      - aroundObj
                //                      - aroundFunc
                //                      - once
                //                      - delay
                //                      - rate
                //                      - adviceMsg
                //              As with connect, only srcFunc and adviceFunc are generally
                //              required

                return this._kwConnectImpl(kwArgs, false); // a MethodJoinPoint object

        }

        this.disconnect = function(){
                // summary:
                //              Takes the same parameters as dojo.event.connect() but destroys
                //              an existing connection instead of building a new one. For
                //              multiple identical connections, multiple disconnect() calls
                //              will unroll one each time it's called.
                if(arguments.length == 1){
                        var ao = arguments[0];
                }else{
                        var ao = interpolateArgs(arguments, true);
                }
                if(!ao.adviceFunc){ return; } // nothing to disconnect
                if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){
                        if(dojo.render.html.ie){
                                ao.srcFunc = "onkeydown";
                                this.disconnect(ao);
                        }
                        ao.srcFunc = "onkeypress";
                }
                if(!ao.srcObj[ao.srcFunc]){ return null; } // prevent un-necessaray joinpoint creation
                var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc, true);
                mjp.removeAdvice(ao.adviceObj, ao.adviceFunc, ao.adviceType, ao.once); // a MethodJoinPoint object
                return mjp;
        }

        this.kwDisconnect = function(kwArgs){
                // summary:
                //              Takes the same parameters as dojo.event.kwConnect() but
                //              destroys an existing connection instead of building a new one.
                return this._kwConnectImpl(kwArgs, true);
        }
}

// exactly one of these is created whenever a method with a joint point is run,
// if there is at least one 'around' advice.
dojo.event.MethodInvocation = function(/*dojo.event.MethodJoinPoint*/join_point, /*Object*/obj, /*Array*/args){
        // summary:
        //              a class the models the call into a function. This is used under the
        //              covers for all method invocations on both ends of a
        //              connect()-wrapped function dispatch. This allows us to "pickle"
        //              calls, such as in the case of around advice.
        // join_point:
        //              a dojo.event.MethodJoinPoint object that represents a connection
        // obj:
        //              the scope the call will execute in
        // args:
        //              an array of parameters that will get passed to the callee
        this.jp_ = join_point;
        this.object = obj;
        this.args = [];
        // make sure we don't lock into a mutable object which can change under us.
        // It's ok if the individual items change, though.
        for(var x=0; x<args.length; x++){
                this.args[x] = args[x];
        }
        // the index of the 'around' that is currently being executed.
        this.around_index = -1;
}

dojo.event.MethodInvocation.prototype.proceed = function(){
        // summary:
        //              proceed with the method call that's represented by this invocation
        //              object
        this.around_index++;
        if(this.around_index >= this.jp_.around.length){
                return this.jp_.object[this.jp_.methodname].apply(this.jp_.object, this.args);
                // return this.jp_.run_before_after(this.object, this.args);
        }else{
                var ti = this.jp_.around[this.around_index];
                var mobj = ti[0]||dj_global;
                var meth = ti[1];
                return mobj[meth].call(mobj, this);
        }
} 


dojo.event.MethodJoinPoint = function(/*Object*/obj, /*String*/funcName){
        this.object = obj||dj_global;
        this.methodname = funcName;
        this.methodfunc = this.object[funcName];
        this.squelch = false;
        // this.before = [];
        // this.after = [];
        // this.around = [];
}

dojo.event.MethodJoinPoint.getForMethod = function(/*Object*/obj, /*String*/funcName){
        // summary:
        //              "static" class function for returning a MethodJoinPoint from a
        //              scoped function. If one doesn't exist, one is created.
        // obj:
        //              the scope to search for the function in
        // funcName:
        //              the name of the function to return a MethodJoinPoint for
        if(!obj){ obj = dj_global; }
        var ofn = obj[funcName];
        if(!ofn){
                // supply a do-nothing method implementation
                ofn = obj[funcName] = function(){};
                if(!obj[funcName]){
                        // e.g. cannot add to inbuilt objects in IE6
                        dojo.raise("Cannot set do-nothing method on that object "+funcName);
                }
        }else if((typeof ofn != "function")&&(!dojo.lang.isFunction(ofn))&&(!dojo.lang.isAlien(ofn))){
                // FIXME: should we throw an exception here instead?
                return null; 
        }
        // we hide our joinpoint instance in obj[funcName + '$joinpoint']
        var jpname = funcName + "$joinpoint";
        var jpfuncname = funcName + "$joinpoint$method";
        var joinpoint = obj[jpname];
        if(!joinpoint){
                var isNode = false;
                if(dojo.event["browser"]){
                        if( (obj["attachEvent"])||
                                (obj["nodeType"])||
                                (obj["addEventListener"]) ){
                                isNode = true;
                                dojo.event.browser.addClobberNodeAttrs(obj, [jpname, jpfuncname, funcName]);
                        }
                }
                var origArity = ofn.length;
                obj[jpfuncname] = ofn;
                // joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, funcName);
                joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, jpfuncname);

                if(!isNode){
                        obj[funcName] = function(){ 
                                // var args = [];
                                // for(var x=0; x<arguments.length; x++){
                                        // args.push(arguments[x]);
                                // }
                                // return joinpoint.run.apply(joinpoint, args); 
                                return joinpoint.run.apply(joinpoint, arguments); 
                        }
                }else{
                        obj[funcName] = function(){ 
                                var args = [];

                                if(!arguments.length){
                                        var evt = null;
                                        try{
                                                if(obj.ownerDocument){
                                                        evt = obj.ownerDocument.parentWindow.event;
                                                }else if(obj.documentElement){
                                                        evt = obj.documentElement.ownerDocument.parentWindow.event;
                                                }else if(obj.event){ //obj is a window
                                                        evt = obj.event;
                                                }else{
                                                        evt = window.event;
                                                }
                                        }catch(e){
                                                evt = window.event;
                                        }

                                        if(evt){
                                                args.push(dojo.event.browser.fixEvent(evt, this));
                                        }
                                }else{
                                        for(var x=0; x<arguments.length; x++){
                                                if((x==0)&&(dojo.event.browser.isEvent(arguments[x]))){
                                                        args.push(dojo.event.browser.fixEvent(arguments[x], this));
                                                }else{
                                                        args.push(arguments[x]);
                                                }
                                        }
                                }
                                // return joinpoint.run.apply(joinpoint, arguments); 
                                return joinpoint.run.apply(joinpoint, args); 
                        }
                }
                obj[funcName].__preJoinArity = origArity;
        }
        return joinpoint; // dojo.event.MethodJoinPoint
}

dojo.lang.extend(dojo.event.MethodJoinPoint, {
        squelch: false,

        unintercept: function(){
                // summary: 
                //              destroy the connection to all listeners that may have been
                //              registered on this joinpoint
                this.object[this.methodname] = this.methodfunc;
                this.before = [];
                this.after = [];
                this.around = [];
        },

        disconnect: dojo.lang.forward("unintercept"),

        run: function(){
                // summary:
                //              execute the connection represented by this join point. The
                //              arguments passed to run() will be passed to the function and
                //              its listeners.
                var obj = this.object||dj_global;
                var args = arguments;

                // optimization. We only compute once the array version of the arguments
                // pseudo-arr in order to prevent building it each time advice is unrolled.
                var aargs = [];
                for(var x=0; x<args.length; x++){
                        aargs[x] = args[x];
                }

                var unrollAdvice  = function(marr){ 
                        if(!marr){
                                dojo.debug("Null argument to unrollAdvice()");
                                return;
                        }
                  
                        var callObj = marr[0]||dj_global;
                        var callFunc = marr[1];
                        
                        if(!callObj[callFunc]){
                                dojo.raise("function \"" + callFunc + "\" does not exist on \"" + callObj + "\"");
                        }
                        
                        var aroundObj = marr[2]||dj_global;
                        var aroundFunc = marr[3];
                        var msg = marr[6];
                        var maxCount = marr[7];
                        if(maxCount > -1){
                                if(maxCount == 0){
                                        return;
                                }
                                marr[7]--;
                        }
                        var undef;

                        var to = {
                                args: [],
                                jp_: this,
                                object: obj,
                                proceed: function(){
                                        return callObj[callFunc].apply(callObj, to.args);
                                }
                        };
                        to.args = aargs;

                        var delay = parseInt(marr[4]);
                        var hasDelay = ((!isNaN(delay))&&(marr[4]!==null)&&(typeof marr[4] != "undefined"));
                        if(marr[5]){
                                var rate = parseInt(marr[5]);
                                var cur = new Date();
                                var timerSet = false;
                                if((marr["last"])&&((cur-marr.last)<=rate)){
                                        if(dojo.event._canTimeout){
                                                if(marr["delayTimer"]){
                                                        clearTimeout(marr.delayTimer);
                                                }
                                                var tod = parseInt(rate*2); // is rate*2 naive?
                                                var mcpy = dojo.lang.shallowCopy(marr);
                                                marr.delayTimer = setTimeout(function(){
                                                        // FIXME: on IE at least, event objects from the
                                                        // browser can go out of scope. How (or should?) we
                                                        // deal with it?
                                                        mcpy[5] = 0;
                                                        unrollAdvice(mcpy);
                                                }, tod);
                                        }
                                        return;
                                }else{
                                        marr.last = cur;
                                }
                        }

                        // FIXME: need to enforce rates for a connection here!

                        if(aroundFunc){
                                // NOTE: around advice can't delay since we might otherwise depend
                                // on execution order!
                                aroundObj[aroundFunc].call(aroundObj, to);
                        }else{
                                // var tmjp = dojo.event.MethodJoinPoint.getForMethod(obj, methname);
                                if((hasDelay)&&((dojo.render.html)||(dojo.render.svg))){  // FIXME: the render checks are grotty!
                                        dj_global["setTimeout"](function(){
                                                if(msg){
                                                        callObj[callFunc].call(callObj, to); 
                                                }else{
                                                        callObj[callFunc].apply(callObj, args); 
                                                }
                                        }, delay);
                                }else{ // many environments can't support delay!
                                        if(msg){
                                                callObj[callFunc].call(callObj, to); 
                                        }else{
                                                callObj[callFunc].apply(callObj, args); 
                                        }
                                }
                        }
                };

                var unRollSquelch = function(){
                        if(this.squelch){
                                try{
                                        return unrollAdvice.apply(this, arguments);
                                }catch(e){ 
                                        dojo.debug(e);
                                }
                        }else{
                                return unrollAdvice.apply(this, arguments);
                        }
                };

                if((this["before"])&&(this.before.length>0)){
                        // pass a cloned array, if this event disconnects this event forEach on this.before wont work
                        dojo.lang.forEach(this.before.concat(new Array()), unRollSquelch);
                }

                var result;
                try{
                        if((this["around"])&&(this.around.length>0)){
                                var mi = new dojo.event.MethodInvocation(this, obj, args);
                                result = mi.proceed();
                        }else if(this.methodfunc){
                                result = this.object[this.methodname].apply(this.object, args);
                        }
                }catch(e){ 
                        if(!this.squelch){ 
                                dojo.debug(e,"when calling",this.methodname,"on",this.object,"with arguments",args);
                                dojo.raise(e);
                        } 
                }

                if((this["after"])&&(this.after.length>0)){
                        // see comment on this.before above
                        dojo.lang.forEach(this.after.concat(new Array()), unRollSquelch);
                }

                return (this.methodfunc) ? result : null;
        },

        getArr: function(/*String*/kind){
                // summary: return a list of listeners of the past "kind"
                // kind:
                //              can be one of: "before", "after", "around", "before-around", or
                //              "after-around"
                var type = "after";
                // FIXME: we should be able to do this through props or Array.in()
                if((typeof kind == "string")&&(kind.indexOf("before")!=-1)){
                        type = "before";
                }else if(kind=="around"){
                        type = "around";
                }
                if(!this[type]){ this[type] = []; }
                return this[type]; // Array
        },

        kwAddAdvice: function(/*Object*/args){
                // summary:
                //              adds advice to the joinpoint with arguments in a map
                // args:
                //              An object that can have the following properties:
                //                      - adviceType
                //                      - adviceObj
                //                      - adviceFunc 
                //                      - aroundObj
                //                      - aroundFunc
                //                      - once
                //                      - delay
                //                      - rate
                //                      - adviceMsg
                //                      - maxCalls
                this.addAdvice( args["adviceObj"], args["adviceFunc"], 
                                                args["aroundObj"], args["aroundFunc"], 
                                                args["adviceType"], args["precedence"], 
                                                args["once"], args["delay"], args["rate"], 
                                                args["adviceMsg"], args["maxCalls"]);
        },

        addAdvice: function(    thisAdviceObj, thisAdvice, 
                                                        thisAroundObj, thisAround, 
                                                        adviceType, precedence, 
                                                        once, delay, rate, asMessage,
                                                        maxCalls){
                // summary:
                //              add advice to this joinpoint using positional parameters
                // thisAdviceObj:
                //              the scope in which to locate/execute the named adviceFunc.
                // thisAdviceFunc:
                //              the name of the function being conected
                // thisAroundObj:
                //              the scope in which to locate/execute the named aroundFunc.
                // thisAroundFunc:
                //              the name of the function that will be used to mediate the
                //              advice call.
                // adviceType: 
                //              Optional. String. One of "before", "after", "around",
                //              "before-around", or "after-around". FIXME
                // once:
                //              boolean that determines whether or not this advice will create
                //              a new connection if an identical advice set has already been
                //              provided. Defaults to "false".
                // delay:
                //              an optional delay (in ms), as an integer, for dispatch of a
                //              listener after the source has been fired.
                // rate:
                //              an optional rate throttling parameter (integer, in ms). When
                //              specified, this particular connection will not fire more than
                //              once in the interval specified by the rate
                // adviceMsg:
                //              boolean. Should the listener have all the parameters passed in
                //              as a single argument?
                // maxCalls:
                //              Integer. The maximum number of times this connection can be
                //              used before being auto-disconnected. -1 signals that the
                //              connection should never be disconnected.
                var arr = this.getArr(adviceType);
                if(!arr){
                        dojo.raise("bad this: " + this);
                }

                var ao = [thisAdviceObj, thisAdvice, thisAroundObj, thisAround, delay, rate, asMessage, maxCalls];
                
                if(once){
                        if(this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr) >= 0){
                                return;
                        }
                }

                if(precedence == "first"){
                        arr.unshift(ao);
                }else{
                        arr.push(ao);
                }
        },

        hasAdvice: function(thisAdviceObj, thisAdvice, adviceType, arr){
                // summary:
                //              returns the array index of the first existing connection
                //              betweened the passed advice and this joinpoint. Will be -1 if
                //              none exists.
                // thisAdviceObj:
                //              the scope in which to locate/execute the named adviceFunc.
                // thisAdviceFunc:
                //              the name of the function being conected
                // adviceType: 
                //              Optional. String. One of "before", "after", "around",
                //              "before-around", or "after-around". FIXME
                // arr:
                //              Optional. The list of advices to search. Will be found via
                //              adviceType if not passed
                if(!arr){ arr = this.getArr(adviceType); }
                var ind = -1;
                for(var x=0; x<arr.length; x++){
                        var aao = (typeof thisAdvice == "object") ? (new String(thisAdvice)).toString() : thisAdvice;
                        var a1o = (typeof arr[x][1] == "object") ? (new String(arr[x][1])).toString() : arr[x][1];
                        if((arr[x][0] == thisAdviceObj)&&(a1o == aao)){
                                ind = x;
                        }
                }
                return ind; // Integer
        },

        removeAdvice: function(thisAdviceObj, thisAdvice, adviceType, once){
                // summary:
                //              returns the array index of the first existing connection
                //              betweened the passed advice and this joinpoint. Will be -1 if
                //              none exists.
                // thisAdviceObj:
                //              the scope in which to locate/execute the named adviceFunc.
                // thisAdviceFunc:
                //              the name of the function being conected
                // adviceType: 
                //              Optional. String. One of "before", "after", "around",
                //              "before-around", or "after-around". FIXME
                // once:
                //              Optional. Should this only remove the first occurance of the
                //              connection?
                var arr = this.getArr(adviceType);
                var ind = this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr);
                if(ind == -1){
                        return false;
                }
                while(ind != -1){
                        arr.splice(ind, 1);
                        if(once){ break; }
                        ind = this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr);
                }
                return true;
        }
});


dojo.provide("dojo.event.topic");

dojo.event.topic = new function(){
        this.topics = {};

        this.getTopic = function(/*String*/topic){
                // summary:
                //              returns a topic implementation object of type
                //              dojo.event.topic.TopicImpl
                // topic:
                //              a unique, opaque string that names the topic
                if(!this.topics[topic]){
                        this.topics[topic] = new this.TopicImpl(topic);
                }
                return this.topics[topic]; // a dojo.event.topic.TopicImpl object
        }

        this.registerPublisher = function(/*String*/topic, /*Object*/obj, /*String*/funcName){
                // summary:
                //              registers a function as a publisher on a topic. Subsequent
                //              calls to the function will cause a publish event on the topic
                //              with the arguments passed to the function passed to registered
                //              listeners.
                // topic: 
                //              a unique, opaque string that names the topic
                // obj:
                //              the scope to locate the function in
                // funcName:
                //              the name of the function to register
                var topic = this.getTopic(topic);
                topic.registerPublisher(obj, funcName);
        }

        this.subscribe = function(/*String*/topic, /*Object*/obj, /*String*/funcName){
                // summary:
                //              susbscribes the function to the topic. Subsequent events
                //              dispached to the topic will create a function call for the
                //              obj.funcName() function.
                // topic: 
                //              a unique, opaque string that names the topic
                // obj:
                //              the scope to locate the function in
                // funcName:
                //              the name of the function to being registered as a listener
                var topic = this.getTopic(topic);
                topic.subscribe(obj, funcName);
        }

        this.unsubscribe = function(/*String*/topic, /*Object*/obj, /*String*/funcName){
                // summary:
                //              unsubscribes the obj.funcName() from the topic
                // topic: 
                //              a unique, opaque string that names the topic
                // obj:
                //              the scope to locate the function in
                // funcName:
                //              the name of the function to being unregistered as a listener
                var topic = this.getTopic(topic);
                topic.unsubscribe(obj, funcName);
        }

        this.destroy = function(/*String*/topic){
                // summary: 
                //              destroys the topic and unregisters all listeners
                // topic:
                //              a unique, opaque string that names the topic
                this.getTopic(topic).destroy();
                delete this.topics[topic];
        }

        this.publishApply = function(/*String*/topic, /*Array*/args){
                // summary: 
                //              dispatches an event to the topic using the args array as the
                //              source for the call arguments to each listener. This is similar
                //              to JavaScript's built-in Function.apply()
                // topic:
                //              a unique, opaque string that names the topic
                // args:
                //              the arguments to be passed into listeners of the topic
                var topic = this.getTopic(topic);
                topic.sendMessage.apply(topic, args);
        }

        this.publish = function(/*String*/topic, /*Object*/message){
                // summary: 
                //              manually "publish" to the passed topic
                // topic:
                //              a unique, opaque string that names the topic
                // message:
                //              can be an array of parameters (similar to publishApply), or
                //              will be treated as one of many arguments to be passed along in
                //              a "flat" unrolling
                var topic = this.getTopic(topic);
                // if message is an array, we treat it as a set of arguments,
                // otherwise, we just pass on the arguments passed in as-is
                var args = [];
                // could we use concat instead here?
                for(var x=1; x<arguments.length; x++){
                        args.push(arguments[x]);
                }
                topic.sendMessage.apply(topic, args);
        }
}

dojo.event.topic.TopicImpl = function(topicName){
        // summary: a class to represent topics

        this.topicName = topicName;

        this.subscribe = function(/*Object*/listenerObject, /*Function or String*/listenerMethod){
                // summary:
                //              use dojo.event.connect() to attach the passed listener to the
                //              topic represented by this object
                // listenerObject:
                //              if a string and listenerMethod is ommitted, this is treated as
                //              the name of a function in the global namespace. If
                //              listenerMethod is provided, this is the scope to find/execute
                //              the function in.
                // listenerMethod:
                //              Optional. The function to register.
                var tf = listenerMethod||listenerObject;
                var to = (!listenerMethod) ? dj_global : listenerObject;
                return dojo.event.kwConnect({ // dojo.event.MethodJoinPoint
                        srcObj:         this, 
                        srcFunc:        "sendMessage", 
                        adviceObj:      to,
                        adviceFunc: tf
                });
        }

        this.unsubscribe = function(/*Object*/listenerObject, /*Function or String*/listenerMethod){
                // summary:
                //              use dojo.event.disconnect() to attach the passed listener to the
                //              topic represented by this object
                // listenerObject:
                //              if a string and listenerMethod is ommitted, this is treated as
                //              the name of a function in the global namespace. If
                //              listenerMethod is provided, this is the scope to find the
                //              function in.
                // listenerMethod:
                //              Optional. The function to unregister.
                var tf = (!listenerMethod) ? listenerObject : listenerMethod;
                var to = (!listenerMethod) ? null : listenerObject;
                return dojo.event.kwDisconnect({ // dojo.event.MethodJoinPoint
                        srcObj:         this, 
                        srcFunc:        "sendMessage", 
                        adviceObj:      to,
                        adviceFunc: tf
                });
        }

        this._getJoinPoint = function(){
                return dojo.event.MethodJoinPoint.getForMethod(this, "sendMessage");
        }

        this.setSquelch = function(/*Boolean*/shouldSquelch){
                // summary: 
                //              determine whether or not exceptions in the calling of a
                //              listener in the chain should stop execution of the chain.
                this._getJoinPoint().squelch = shouldSquelch;
        }

        this.destroy = function(){
                // summary: disconnects all listeners from this topic
                this._getJoinPoint().disconnect();
        }

        this.registerPublisher = function(      /*Object*/publisherObject, 
                                                                                /*Function or String*/publisherMethod){
                // summary:
                //              registers the passed function as a publisher on this topic.
                //              Each time the function is called, an event will be published on
                //              this topic.
                // publisherObject:
                //              if a string and listenerMethod is ommitted, this is treated as
                //              the name of a function in the global namespace. If
                //              listenerMethod is provided, this is the scope to find the
                //              function in.
                // publisherMethod:
                //              Optional. The function to register.
                dojo.event.connect(publisherObject, publisherMethod, this, "sendMessage");
        }

        this.sendMessage = function(message){
                // summary: a stub to be called when a message is sent to the topic.

                // The message has been propagated
        }
}


dojo.provide("dojo.event.browser");


// FIXME: any particular reason this is in the global scope?
dojo._ie_clobber = new function(){
        this.clobberNodes = [];

        function nukeProp(node, prop){
                // try{ node.removeAttribute(prop);     }catch(e){ /* squelch */ }
                try{ node[prop] = null;                         }catch(e){ /* squelch */ }
                try{ delete node[prop];                         }catch(e){ /* squelch */ }
                // FIXME: JotLive needs this, but I'm not sure if it's too slow or not
                try{ node.removeAttribute(prop);        }catch(e){ /* squelch */ }
        }

        this.clobber = function(nodeRef){
                var na;
                var tna;
                if(nodeRef){
                        tna = nodeRef.all || nodeRef.getElementsByTagName("*");
                        na = [nodeRef];
                        for(var x=0; x<tna.length; x++){
                                // if we're gonna be clobbering the thing, at least make sure
                                // we aren't trying to do it twice
                                if(tna[x]["__doClobber__"]){
                                        na.push(tna[x]);
                                }
                        }
                }else{
                        try{ window.onload = null; }catch(e){}
                        na = (this.clobberNodes.length) ? this.clobberNodes : document.all;
                }
                tna = null;
                var basis = {};
                for(var i = na.length-1; i>=0; i=i-1){
                        var el = na[i];
                        try{
                                if(el && el["__clobberAttrs__"]){
                                        for(var j=0; j<el.__clobberAttrs__.length; j++){
                                                nukeProp(el, el.__clobberAttrs__[j]);
                                        }
                                        nukeProp(el, "__clobberAttrs__");
                                        nukeProp(el, "__doClobber__");
                                }
                        }catch(e){ /* squelch! */};
                }
                na = null;
        }
}

if(dojo.render.html.ie){
        dojo.addOnUnload(function(){
                dojo._ie_clobber.clobber();
                try{
                        if((dojo["widget"])&&(dojo.widget["manager"])){
                                dojo.widget.manager.destroyAll();
                        }
                }catch(e){}

                // Workaround for IE leak recommended in ticket #1727 by schallm
                if(dojo.widget){
                        for(var name in dojo.widget._templateCache){
                                if(dojo.widget._templateCache[name].node){
                                        dojo.dom.destroyNode(dojo.widget._templateCache[name].node);
                                        dojo.widget._templateCache[name].node = null;
                                        delete dojo.widget._templateCache[name].node;
                                }
                        }
                }

                try{ window.onload = null; }catch(e){}
                try{ window.onunload = null; }catch(e){}
                dojo._ie_clobber.clobberNodes = [];
                // CollectGarbage();
        });
}

dojo.event.browser = new function(){

        var clobberIdx = 0;

        this.normalizedEventName = function(/*String*/eventName){
                switch(eventName){
                        case "CheckboxStateChange":
                        case "DOMAttrModified":
                        case "DOMMenuItemActive":
                        case "DOMMenuItemInactive":
                        case "DOMMouseScroll":
                        case "DOMNodeInserted":
                        case "DOMNodeRemoved":
                        case "RadioStateChange":
                                return eventName;
                                break;
                        default:
                                var lcn = eventName.toLowerCase();
                                return (lcn.indexOf("on") == 0) ? lcn.substr(2) : lcn;
                                break;
                }
        }
        
        this.clean = function(/*DOMNode*/node){
                // summary:
                //              removes native event handlers so that destruction of the node
                //              will not leak memory. On most browsers this is a no-op, but
                //              it's critical for manual node removal on IE.
                // node:
                //              A DOM node. All of it's children will also be cleaned.
                if(dojo.render.html.ie){ 
                        dojo._ie_clobber.clobber(node);
                }
        }

        this.addClobberNode = function(/*DOMNode*/node){
                // summary:
                //              register the passed node to support event stripping
                // node:
                //              A DOM node
                if(!dojo.render.html.ie){ return; }
                if(!node["__doClobber__"]){
                        node.__doClobber__ = true;
                        dojo._ie_clobber.clobberNodes.push(node);
                        // this might not be the most efficient thing to do, but it's
                        // much less error prone than other approaches which were
                        // previously tried and failed
                        node.__clobberAttrs__ = [];
                }
        }

        this.addClobberNodeAttrs = function(/*DOMNode*/node, /*Array*/props){
                // summary:
                //              register the passed node to support event stripping
                // node:
                //              A DOM node to stip properties from later
                // props:
                //              A list of propeties to strip from the node
                if(!dojo.render.html.ie){ return; }
                this.addClobberNode(node);
                for(var x=0; x<props.length; x++){
                        node.__clobberAttrs__.push(props[x]);
                }
        }

        this.removeListener = function( /*DOMNode*/ node, 
                                                                        /*String*/      evtName, 
                                                                        /*Function*/fp, 
                                                                        /*Boolean*/     capture){
                // summary:
                //              clobbers the listener from the node
                // evtName:
                //              the name of the handler to remove the function from
                // node:
                //              DOM node to attach the event to
                // fp:
                //              the function to register
                // capture:
                //              Optional. should this listener prevent propigation?
                if(!capture){ var capture = false; }
                evtName = dojo.event.browser.normalizedEventName(evtName);
                if(evtName == "key"){
                        if(dojo.render.html.ie){
                                this.removeListener(node, "onkeydown", fp, capture);
                        }
                        evtName = "keypress";
                }
                // FIXME: this is mostly a punt, we aren't actually doing anything on IE
                if(node.removeEventListener){
                        node.removeEventListener(evtName, fp, capture);
                }
        }

        this.addListener = function(/*DOMNode*/node, /*String*/evtName, /*Function*/fp, /*Boolean*/capture, /*Boolean*/dontFix){
                // summary:
                //              adds a listener to the node
                // evtName:
                //              the name of the handler to add the listener to can be either of
                //              the form "onclick" or "click"
                // node:
                //              DOM node to attach the event to
                // fp:
                //              the function to register
                // capture:
                //              Optional. Should this listener prevent propigation?
                // dontFix:
                //              Optional. Should we avoid registering a new closure around the
                //              listener to enable fixEvent for dispatch of the registered
                //              function?
                if(!node){ return; } // FIXME: log and/or bail?
                if(!capture){ var capture = false; }
                evtName = dojo.event.browser.normalizedEventName(evtName);
                if(evtName == "key"){
                        if(dojo.render.html.ie){
                                this.addListener(node, "onkeydown", fp, capture, dontFix);
                        }
                        evtName = "keypress";
                }

                if(!dontFix){
                        // build yet another closure around fp in order to inject fixEvent
                        // around the resulting event
                        var newfp = function(evt){
                                if(!evt){ evt = window.event; }
                                var ret = fp(dojo.event.browser.fixEvent(evt, this));
                                if(capture){
                                        dojo.event.browser.stopEvent(evt);
                                }
                                return ret;
                        }
                }else{
                        newfp = fp;
                }

                if(node.addEventListener){ 
                        node.addEventListener(evtName, newfp, capture);
                        return newfp;
                }else{
                        evtName = "on"+evtName;
                        if(typeof node[evtName] == "function" ){
                                var oldEvt = node[evtName];
                                node[evtName] = function(e){
                                        oldEvt(e);
                                        return newfp(e);
                                }
                        }else{
                                node[evtName]=newfp;
                        }
                        if(dojo.render.html.ie){
                                this.addClobberNodeAttrs(node, [evtName]);
                        }
                        return newfp;
                }
        }

        this.isEvent = function(/*Object*/obj){
                // summary: 
                //              Tries to determine whether or not the object is a DOM event.

                // FIXME: event detection hack ... could test for additional attributes
                // if necessary
                return (typeof obj != "undefined")&&(obj)&&(typeof Event != "undefined")&&(obj.eventPhase); // Boolean
                // Event does not support instanceof in Opera, otherwise:
                //return (typeof Event != "undefined")&&(obj instanceof Event);
        }

        this.currentEvent = null;
        
        this.callListener = function(/*Function*/listener, /*DOMNode*/curTarget){
                // summary:
                //              calls the specified listener in the context of the passed node
                //              with the current DOM event object as the only parameter
                // listener:
                //              the function to call
                // curTarget:
                //              the Node to call the function in the scope of
                if(typeof listener != 'function'){
                        dojo.raise("listener not a function: " + listener);
                }
                dojo.event.browser.currentEvent.currentTarget = curTarget;
                return listener.call(curTarget, dojo.event.browser.currentEvent);
        }

        this._stopPropagation = function(){
                dojo.event.browser.currentEvent.cancelBubble = true; 
        }

        this._preventDefault = function(){
                dojo.event.browser.currentEvent.returnValue = false;
        }

        this.keys = {
                KEY_BACKSPACE: 8,
                KEY_TAB: 9,
                KEY_CLEAR: 12,
                KEY_ENTER: 13,
                KEY_SHIFT: 16,
                KEY_CTRL: 17,
                KEY_ALT: 18,
                KEY_PAUSE: 19,
                KEY_CAPS_LOCK: 20,
                KEY_ESCAPE: 27,
                KEY_SPACE: 32,
                KEY_PAGE_UP: 33,
                KEY_PAGE_DOWN: 34,
                KEY_END: 35,
                KEY_HOME: 36,
                KEY_LEFT_ARROW: 37,
                KEY_UP_ARROW: 38,
                KEY_RIGHT_ARROW: 39,
                KEY_DOWN_ARROW: 40,
                KEY_INSERT: 45,
                KEY_DELETE: 46,
                KEY_HELP: 47,
                KEY_LEFT_WINDOW: 91,
                KEY_RIGHT_WINDOW: 92,
                KEY_SELECT: 93,
                KEY_NUMPAD_0: 96,
                KEY_NUMPAD_1: 97,
                KEY_NUMPAD_2: 98,
                KEY_NUMPAD_3: 99,
                KEY_NUMPAD_4: 100,
                KEY_NUMPAD_5: 101,
                KEY_NUMPAD_6: 102,
                KEY_NUMPAD_7: 103,
                KEY_NUMPAD_8: 104,
                KEY_NUMPAD_9: 105,
                KEY_NUMPAD_MULTIPLY: 106,
                KEY_NUMPAD_PLUS: 107,
                KEY_NUMPAD_ENTER: 108,
                KEY_NUMPAD_MINUS: 109,
                KEY_NUMPAD_PERIOD: 110,
                KEY_NUMPAD_DIVIDE: 111,
                KEY_F1: 112,
                KEY_F2: 113,
                KEY_F3: 114,
                KEY_F4: 115,
                KEY_F5: 116,
                KEY_F6: 117,
                KEY_F7: 118,
                KEY_F8: 119,
                KEY_F9: 120,
                KEY_F10: 121,
                KEY_F11: 122,
                KEY_F12: 123,
                KEY_F13: 124,
                KEY_F14: 125,
                KEY_F15: 126,
                KEY_NUM_LOCK: 144,
                KEY_SCROLL_LOCK: 145
        };

        // reverse lookup
        this.revKeys = [];
        for(var key in this.keys){
                this.revKeys[this.keys[key]] = key;
        }

        this.fixEvent = function(/*Event*/evt, /*DOMNode*/sender){
                // summary:
                //              normalizes properties on the event object including event
                //              bubbling methods, keystroke normalization, and x/y positions
                // evt: the native event object
                // sender: the node to treat as "currentTarget"
                if(!evt){
                        if(window["event"]){
                                evt = window.event;
                        }
                }
                
                if((evt["type"])&&(evt["type"].indexOf("key") == 0)){ // key events
                        evt.keys = this.revKeys;
                        // FIXME: how can we eliminate this iteration?
                        for(var key in this.keys){
                                evt[key] = this.keys[key];
                        }
                        if(evt["type"] == "keydown" && dojo.render.html.ie){
                                switch(evt.keyCode){
                                        case evt.KEY_SHIFT:
                                        case evt.KEY_CTRL:
                                        case evt.KEY_ALT:
                                        case evt.KEY_CAPS_LOCK:
                                        case evt.KEY_LEFT_WINDOW:
                                        case evt.KEY_RIGHT_WINDOW:
                                        case evt.KEY_SELECT:
                                        case evt.KEY_NUM_LOCK:
                                        case evt.KEY_SCROLL_LOCK:
                                        // I'll get these in keypress after the OS munges them based on numlock
                                        case evt.KEY_NUMPAD_0:
                                        case evt.KEY_NUMPAD_1:
                                        case evt.KEY_NUMPAD_2:
                                        case evt.KEY_NUMPAD_3:
                                        case evt.KEY_NUMPAD_4:
                                        case evt.KEY_NUMPAD_5:
                                        case evt.KEY_NUMPAD_6:
                                        case evt.KEY_NUMPAD_7:
                                        case evt.KEY_NUMPAD_8:
                                        case evt.KEY_NUMPAD_9:
                                        case evt.KEY_NUMPAD_PERIOD:
                                                break; // just ignore the keys that can morph
                                        case evt.KEY_NUMPAD_MULTIPLY:
                                        case evt.KEY_NUMPAD_PLUS:
                                        case evt.KEY_NUMPAD_ENTER:
                                        case evt.KEY_NUMPAD_MINUS:
                                        case evt.KEY_NUMPAD_DIVIDE:
                                                break; // I could handle these but just pick them up in keypress
                                        case evt.KEY_PAUSE:
                                        case evt.KEY_TAB:
                                        case evt.KEY_BACKSPACE:
                                        case evt.KEY_ENTER:
                                        case evt.KEY_ESCAPE:
                                        case evt.KEY_PAGE_UP:
                                        case evt.KEY_PAGE_DOWN:
                                        case evt.KEY_END:
                                        case evt.KEY_HOME:
                                        case evt.KEY_LEFT_ARROW:
                                        case evt.KEY_UP_ARROW:
                                        case evt.KEY_RIGHT_ARROW:
                                        case evt.KEY_DOWN_ARROW:
                                        case evt.KEY_INSERT:
                                        case evt.KEY_DELETE:
                                        case evt.KEY_F1:
                                        case evt.KEY_F2:
                                        case evt.KEY_F3:
                                        case evt.KEY_F4:
                                        case evt.KEY_F5:
                                        case evt.KEY_F6:
                                        case evt.KEY_F7:
                                        case evt.KEY_F8:
                                        case evt.KEY_F9:
                                        case evt.KEY_F10:
                                        case evt.KEY_F11:
                                        case evt.KEY_F12:
                                        case evt.KEY_F12:
                                        case evt.KEY_F13:
                                        case evt.KEY_F14:
                                        case evt.KEY_F15:
                                        case evt.KEY_CLEAR:
                                        case evt.KEY_HELP:
                                                evt.key = evt.keyCode;
                                                break;
                                        default:
                                                if(evt.ctrlKey || evt.altKey){
                                                        var unifiedCharCode = evt.keyCode;
                                                        // if lower case but keycode is uppercase, convert it
                                                        if(unifiedCharCode >= 65 && unifiedCharCode <= 90 && evt.shiftKey == false){
                                                                unifiedCharCode += 32;
                                                        }
                                                        if(unifiedCharCode >= 1 && unifiedCharCode <= 26 && evt.ctrlKey){
                                                                unifiedCharCode += 96; // 001-032 = ctrl+[a-z]
                                                        }
                                                        evt.key = String.fromCharCode(unifiedCharCode);
                                                }
                                }
                        } else if(evt["type"] == "keypress"){
                                if(dojo.render.html.opera){
                                        if(evt.which == 0){
                                                evt.key = evt.keyCode;
                                        }else if(evt.which > 0){
                                                switch(evt.which){
                                                        case evt.KEY_SHIFT:
                                                        case evt.KEY_CTRL:
                                                        case evt.KEY_ALT:
                                                        case evt.KEY_CAPS_LOCK:
                                                        case evt.KEY_NUM_LOCK:
                                                        case evt.KEY_SCROLL_LOCK:
                                                                break;
                                                        case evt.KEY_PAUSE:
                                                        case evt.KEY_TAB:
                                                        case evt.KEY_BACKSPACE:
                                                        case evt.KEY_ENTER:
                                                        case evt.KEY_ESCAPE:
                                                                evt.key = evt.which;
                                                                break;
                                                        default:
                                                                var unifiedCharCode = evt.which;
                                                                if((evt.ctrlKey || evt.altKey || evt.metaKey) && (evt.which >= 65 && evt.which <= 90 && evt.shiftKey == false)){
                                                                        unifiedCharCode += 32;
                                                                }
                                                                evt.key = String.fromCharCode(unifiedCharCode);
                                                }
                                        }
                                }else if(dojo.render.html.ie){ // catch some IE keys that are hard to get in keyDown
                                        // key combinations were handled in onKeyDown
                                        if(!evt.ctrlKey && !evt.altKey && evt.keyCode >= evt.KEY_SPACE){
                                                evt.key = String.fromCharCode(evt.keyCode);
                                        }
                                }else if(dojo.render.html.safari){
                                        switch(evt.keyCode){
                                                case 25: evt.key = evt.KEY_TAB; evt.shift = true;break;
                                                case 63232: evt.key = evt.KEY_UP_ARROW; break;
                                                case 63233: evt.key = evt.KEY_DOWN_ARROW; break;
                                                case 63234: evt.key = evt.KEY_LEFT_ARROW; break;
                                                case 63235: evt.key = evt.KEY_RIGHT_ARROW; break;
                                                case 63236: evt.key = evt.KEY_F1; break;
                                                case 63237: evt.key = evt.KEY_F2; break;
                                                case 63238: evt.key = evt.KEY_F3; break;
                                                case 63239: evt.key = evt.KEY_F4; break;
                                                case 63240: evt.key = evt.KEY_F5; break;
                                                case 63241: evt.key = evt.KEY_F6; break;
                                                case 63242: evt.key = evt.KEY_F7; break;
                                                case 63243: evt.key = evt.KEY_F8; break;
                                                case 63244: evt.key = evt.KEY_F9; break;
                                                case 63245: evt.key = evt.KEY_F10; break;
                                                case 63246: evt.key = evt.KEY_F11; break;
                                                case 63247: evt.key = evt.KEY_F12; break;
                                                case 63250: evt.key = evt.KEY_PAUSE; break;
                                                case 63272: evt.key = evt.KEY_DELETE; break;
                                                case 63273: evt.key = evt.KEY_HOME; break;
                                                case 63275: evt.key = evt.KEY_END; break;
                                                case 63276: evt.key = evt.KEY_PAGE_UP; break;
                                                case 63277: evt.key = evt.KEY_PAGE_DOWN; break;
                                                case 63302: evt.key = evt.KEY_INSERT; break;
                                                case 63248://prtscr
                                                case 63249://scrolllock
                                                case 63289://numlock
                                                        break;
                                                default: 
                                                        evt.key = evt.charCode >= evt.KEY_SPACE ? String.fromCharCode(evt.charCode) : evt.keyCode;
                                        }
                                }else{
                                        evt.key = evt.charCode > 0 ? String.fromCharCode(evt.charCode) : evt.keyCode;
                                }
                        }
                }
                if(dojo.render.html.ie){
                        if(!evt.target){ evt.target = evt.srcElement; }
                        if(!evt.currentTarget){ evt.currentTarget = (sender ? sender : evt.srcElement); }
                        if(!evt.layerX){ evt.layerX = evt.offsetX; }
                        if(!evt.layerY){ evt.layerY = evt.offsetY; }
                        // FIXME: scroll position query is duped from dojo.html to avoid dependency on that entire module
                        // DONOT replace the following to use dojo.body(), in IE, document.documentElement should be used
                        // here rather than document.body
                        var doc = (evt.srcElement && evt.srcElement.ownerDocument) ? evt.srcElement.ownerDocument : document;
                        var docBody = ((dojo.render.html.ie55)||(doc["compatMode"] == "BackCompat")) ? doc.body : doc.documentElement;
                        if(!evt.pageX){ evt.pageX = evt.clientX + (docBody.scrollLeft || 0) }
                        if(!evt.pageY){ evt.pageY = evt.clientY + (docBody.scrollTop || 0) }
                        // mouseover
                        if(evt.type == "mouseover"){ evt.relatedTarget = evt.fromElement; }
                        // mouseout
                        if(evt.type == "mouseout"){ evt.relatedTarget = evt.toElement; }
                        this.currentEvent = evt;
                        evt.callListener = this.callListener;
                        evt.stopPropagation = this._stopPropagation;
                        evt.preventDefault = this._preventDefault;
                }
                return evt; // Event
        }

        this.stopEvent = function(/*Event*/evt){
                // summary:
                //              prevents propigation and clobbers the default action of the
                //              passed event
                // evt: Optional for IE. The native event object.
                if(window.event){
                        evt.cancelBubble = true;
                        evt.returnValue = false;
                }else{
                        evt.preventDefault();
                        evt.stopPropagation();
                }
        }
}

dojo.kwCompoundRequire({
        common: ["dojo.event.common", "dojo.event.topic"],
        browser: ["dojo.event.browser"],
        dashboard: ["dojo.event.browser"]
});
dojo.provide("dojo.event.*");

dojo.provide("dojo.gfx.color");



// TODO: rewrite the "x2y" methods to take advantage of the parsing
//       abilities of the Color object. Also, beef up the Color
//       object (as possible) to parse most common formats

// takes an r, g, b, a(lpha) value, [r, g, b, a] array, "rgb(...)" string, hex string (#aaa, #aaaaaa, aaaaaaa)
dojo.gfx.color.Color = function(r, g, b, a) {
        // dojo.debug("r:", r[0], "g:", r[1], "b:", r[2]);
        if(dojo.lang.isArray(r)){
                this.r = r[0];
                this.g = r[1];
                this.b = r[2];
                this.a = r[3]||1.0;
        }else if(dojo.lang.isString(r)){
                var rgb = dojo.gfx.color.extractRGB(r);
                this.r = rgb[0];
                this.g = rgb[1];
                this.b = rgb[2];
                this.a = g||1.0;
        }else if(r instanceof dojo.gfx.color.Color){
                // why does this create a new instance if we were passed one?
                this.r = r.r;
                this.b = r.b;
                this.g = r.g;
                this.a = r.a;
        }else{
                this.r = r;
                this.g = g;
                this.b = b;
                this.a = a;
        }
}

dojo.gfx.color.Color.fromArray = function(arr) {
        return new dojo.gfx.color.Color(arr[0], arr[1], arr[2], arr[3]);
}

dojo.extend(dojo.gfx.color.Color, {
        toRgb: function(includeAlpha) {
                if(includeAlpha) {
                        return this.toRgba();
                } else {
                        return [this.r, this.g, this.b];
                }
        },
        toRgba: function() {
                return [this.r, this.g, this.b, this.a];
        },
        toHex: function() {
                return dojo.gfx.color.rgb2hex(this.toRgb());
        },
        toCss: function() {
                return "rgb(" + this.toRgb().join() + ")";
        },
        toString: function() {
                return this.toHex(); // decent default?
        },
        blend: function(color, weight){
                var rgb = null;
                if(dojo.lang.isArray(color)){
                        rgb = color;
                }else if(color instanceof dojo.gfx.color.Color){
                        rgb = color.toRgb();
                }else{
                        rgb = new dojo.gfx.color.Color(color).toRgb();
                }
                return dojo.gfx.color.blend(this.toRgb(), rgb, weight);
        }
});

dojo.gfx.color.named = {
        white:      [255,255,255],
        black:      [0,0,0],
        red:        [255,0,0],
        green:      [0,255,0],
        lime:       [0,255,0],
        blue:       [0,0,255],
        navy:       [0,0,128],
        gray:       [128,128,128],
        silver:     [192,192,192]
};

dojo.gfx.color.blend = function(a, b, weight){
        // summary: 
        //              blend colors a and b (both as RGB array or hex strings) with weight
        //              from -1 to +1, 0 being a 50/50 blend
        if(typeof a == "string"){
                return dojo.gfx.color.blendHex(a, b, weight);
        }
        if(!weight){
                weight = 0;
        }
        weight = Math.min(Math.max(-1, weight), 1);

        // alex: this interface blows.
        // map -1 to 1 to the range 0 to 1
        weight = ((weight + 1)/2);
        
        var c = [];

        // var stop = (1000*weight);
        for(var x = 0; x < 3; x++){
                c[x] = parseInt( b[x] + ( (a[x] - b[x]) * weight) );
        }
        return c;
}

// very convenient blend that takes and returns hex values
// (will get called automatically by blend when blend gets strings)
dojo.gfx.color.blendHex = function(a, b, weight) {
        return dojo.gfx.color.rgb2hex(dojo.gfx.color.blend(dojo.gfx.color.hex2rgb(a), dojo.gfx.color.hex2rgb(b), weight));
}

// get RGB array from css-style color declarations
dojo.gfx.color.extractRGB = function(color) {
        var hex = "0123456789abcdef";
        color = color.toLowerCase();
        if( color.indexOf("rgb") == 0 ) {
                var matches = color.match(/rgba*\((\d+), *(\d+), *(\d+)/i);
                var ret = matches.splice(1, 3);
                return ret;
        } else {
                var colors = dojo.gfx.color.hex2rgb(color);
                if(colors) {
                        return colors;
                } else {
                        // named color (how many do we support?)
                        return dojo.gfx.color.named[color] || [255, 255, 255];
                }
        }
}

dojo.gfx.color.hex2rgb = function(hex) {
        var hexNum = "0123456789ABCDEF";
        var rgb = new Array(3);
        if( hex.indexOf("#") == 0 ) { hex = hex.substring(1); }
        hex = hex.toUpperCase();
        if(hex.replace(new RegExp("["+hexNum+"]", "g"), "") != "") {
                return null;
        }
        if( hex.length == 3 ) {
                rgb[0] = hex.charAt(0) + hex.charAt(0)
                rgb[1] = hex.charAt(1) + hex.charAt(1)
                rgb[2] = hex.charAt(2) + hex.charAt(2);
        } else {
                rgb[0] = hex.substring(0, 2);
                rgb[1] = hex.substring(2, 4);
                rgb[2] = hex.substring(4);
        }
        for(var i = 0; i < rgb.length; i++) {
                rgb[i] = hexNum.indexOf(rgb[i].charAt(0)) * 16 + hexNum.indexOf(rgb[i].charAt(1));
        }
        return rgb;
}

dojo.gfx.color.rgb2hex = function(r, g, b) {
        if(dojo.lang.isArray(r)) {
                g = r[1] || 0;
                b = r[2] || 0;
                r = r[0] || 0;
        }
        var ret = dojo.lang.map([r, g, b], function(x) {
                x = new Number(x);
                var s = x.toString(16);
                while(s.length < 2) { s = "0" + s; }
                return s;
        });
        ret.unshift("#");
        return ret.join("");
}

dojo.provide("dojo.lfx.Animation");



/*
        Animation package based on Dan Pupius' work: http://pupius.co.uk/js/Toolkit.Drawing.js
*/
dojo.lfx.Line = function(/*int*/ start, /*int*/ end){
        // summary: dojo.lfx.Line is the object used to generate values
        //                      from a start value to an end value
        this.start = start;
        this.end = end;
        if(dojo.lang.isArray(start)){
                /* start: Array
                   end: Array
                   pId: a */
                var diff = [];
                dojo.lang.forEach(this.start, function(s,i){
                        diff[i] = this.end[i] - s;
                }, this);
                
                this.getValue = function(/*float*/ n){
                        var res = [];
                        dojo.lang.forEach(this.start, function(s, i){
                                res[i] = (diff[i] * n) + s;
                        }, this);
                        return res; // Array
                }
        }else{
                var diff = end - start;
                        
                this.getValue = function(/*float*/ n){
                        //      summary: returns the point on the line
                        //      n: a floating point number greater than 0 and less than 1
                        return (diff * n) + this.start; // Decimal
                }
        }
}

if((dojo.render.html.khtml)&&(!dojo.render.html.safari)){
        // the cool kids are obviously not using konqueror...
        // found a very wierd bug in floats constants, 1.5 evals as 1
        // seems somebody mixed up ints and floats in 3.5.4 ??
        // FIXME: investigate more and post a KDE bug (Fredrik)
        dojo.lfx.easeDefault = function(/*Decimal?*/ n){
                //      summary: Returns the point for point n on a sin wave.
                return (parseFloat("0.5")+((Math.sin( (n+parseFloat("1.5")) * Math.PI))/2));
        }
}else{
        dojo.lfx.easeDefault = function(/*Decimal?*/ n){
                return (0.5+((Math.sin( (n+1.5) * Math.PI))/2));
        }
}

dojo.lfx.easeIn = function(/*Decimal?*/ n){
        //      summary: returns the point on an easing curve
        //      n: a floating point number greater than 0 and less than 1
        return Math.pow(n, 3);
}

dojo.lfx.easeOut = function(/*Decimal?*/ n){
        //      summary: returns the point on the line
        //      n: a floating point number greater than 0 and less than 1
        return ( 1 - Math.pow(1 - n, 3) );
}

dojo.lfx.easeInOut = function(/*Decimal?*/ n){
        //      summary: returns the point on the line
        //      n: a floating point number greater than 0 and less than 1
        return ( (3 * Math.pow(n, 2)) - (2 * Math.pow(n, 3)) );
}

dojo.lfx.IAnimation = function(){
        // summary: dojo.lfx.IAnimation is an interface that implements
        //                      commonly used functions of animation objects
}
dojo.lang.extend(dojo.lfx.IAnimation, {
        // public properties
        curve: null,
        duration: 1000,
        easing: null,
        repeatCount: 0,
        rate: 10,
        
        // events
        handler: null,
        beforeBegin: null,
        onBegin: null,
        onAnimate: null,
        onEnd: null,
        onPlay: null,
        onPause: null,
        onStop: null,
        
        // public methods
        play: null,
        pause: null,
        stop: null,
        
        connect: function(/*Event*/ evt, /*Object*/ scope, /*Function*/ newFunc){
                // summary: Convenience function.  Quickly connect to an event
                //                      of this object and save the old functions connected to it.
                // evt: The name of the event to connect to.
                // scope: the scope in which to run newFunc.
                // newFunc: the function to run when evt is fired.
                if(!newFunc){
                        /* scope: Function
                           newFunc: null
                           pId: f */
                        newFunc = scope;
                        scope = this;
                }
                newFunc = dojo.lang.hitch(scope, newFunc);
                var oldFunc = this[evt]||function(){};
                this[evt] = function(){
                        var ret = oldFunc.apply(this, arguments);
                        newFunc.apply(this, arguments);
                        return ret;
                }
                return this; // dojo.lfx.IAnimation
        },

        fire: function(/*Event*/ evt, /*Array*/ args){
                // summary: Convenience function.  Fire event "evt" and pass it
                //                      the arguments specified in "args".
                // evt: The event to fire.
                // args: The arguments to pass to the event.
                if(this[evt]){
                        this[evt].apply(this, (args||[]));
                }
                return this; // dojo.lfx.IAnimation
        },
        
        repeat: function(/*int*/ count){
                // summary: Set the repeat count of this object.
                // count: How many times to repeat the animation.
                this.repeatCount = count;
                return this; // dojo.lfx.IAnimation
        },

        // private properties
        _active: false,
        _paused: false
});

dojo.lfx.Animation = function(  /*Object*/ handlers, 
                                                                /*int*/ duration, 
                                                                /*dojo.lfx.Line*/ curve, 
                                                                /*function*/ easing, 
                                                                /*int*/ repeatCount, 
                                                                /*int*/ rate){
        //      summary
        //              a generic animation object that fires callbacks into it's handlers
        //              object at various states
        //      handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? }
        dojo.lfx.IAnimation.call(this);
        if(dojo.lang.isNumber(handlers)||(!handlers && duration.getValue)){
                // no handlers argument:
                rate = repeatCount;
                repeatCount = easing;
                easing = curve;
                curve = duration;
                duration = handlers;
                handlers = null;
        }else if(handlers.getValue||dojo.lang.isArray(handlers)){
                // no handlers or duration:
                rate = easing;
                repeatCount = curve;
                easing = duration;
                curve = handlers;
                duration = null;
                handlers = null;
        }
        if(dojo.lang.isArray(curve)){
                /* curve: Array
                   pId: a */
                this.curve = new dojo.lfx.Line(curve[0], curve[1]);
        }else{
                this.curve = curve;
        }
        if(duration != null && duration > 0){ this.duration = duration; }
        if(repeatCount){ this.repeatCount = repeatCount; }
        if(rate){ this.rate = rate; }
        if(handlers){
                dojo.lang.forEach([
                                "handler", "beforeBegin", "onBegin", 
                                "onEnd", "onPlay", "onStop", "onAnimate"
                        ], function(item){
                                if(handlers[item]){
                                        this.connect(item, handlers[item]);
                                }
                        }, this);
        }
        if(easing && dojo.lang.isFunction(easing)){
                this.easing=easing;
        }
}
dojo.inherits(dojo.lfx.Animation, dojo.lfx.IAnimation);
dojo.lang.extend(dojo.lfx.Animation, {
        // "private" properties
        _startTime: null,
        _endTime: null,
        _timer: null,
        _percent: 0,
        _startRepeatCount: 0,

        // public methods
        play: function(/*int?*/ delay, /*bool?*/ gotoStart){
                // summary: Start the animation.
                // delay: How many milliseconds to delay before starting.
                // gotoStart: If true, starts the animation from the beginning; otherwise,
                //            starts it from its current position.
                if(gotoStart){
                        clearTimeout(this._timer);
                        this._active = false;
                        this._paused = false;
                        this._percent = 0;
                }else if(this._active && !this._paused){
                        return this; // dojo.lfx.Animation
                }
                
                this.fire("handler", ["beforeBegin"]);
                this.fire("beforeBegin");

                if(delay > 0){
                        setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay);
                        return this; // dojo.lfx.Animation
                }
                
                this._startTime = new Date().valueOf();
                if(this._paused){
                        this._startTime -= (this.duration * this._percent / 100);
                }
                this._endTime = this._startTime + this.duration;

                this._active = true;
                this._paused = false;
                
                var step = this._percent / 100;
                var value = this.curve.getValue(step);
                if(this._percent == 0 ){
                        if(!this._startRepeatCount){
                                this._startRepeatCount = this.repeatCount;
                        }
                        this.fire("handler", ["begin", value]);
                        this.fire("onBegin", [value]);
                }

                this.fire("handler", ["play", value]);
                this.fire("onPlay", [value]);

                this._cycle();
                return this; // dojo.lfx.Animation
        },

        pause: function(){
                // summary: Pauses a running animation.
                clearTimeout(this._timer);
                if(!this._active){ return this; /*dojo.lfx.Animation*/}
                this._paused = true;
                var value = this.curve.getValue(this._percent / 100);
                this.fire("handler", ["pause", value]);
                this.fire("onPause", [value]);
                return this; // dojo.lfx.Animation
        },

        gotoPercent: function(/*Decimal*/ pct, /*bool?*/ andPlay){
                // summary: Sets the progress of the animation.
                // pct: A percentage in decimal notation (between and including 0.0 and 1.0).
                // andPlay: If true, play the animation after setting the progress.
                clearTimeout(this._timer);
                this._active = true;
                this._paused = true;
                this._percent = pct;
                if(andPlay){ this.play(); }
                return this; // dojo.lfx.Animation
        },

        stop: function(/*bool?*/ gotoEnd){
                // summary: Stops a running animation.
                // gotoEnd: If true, the animation will end.
                clearTimeout(this._timer);
                var step = this._percent / 100;
                if(gotoEnd){
                        step = 1;
                }
                var value = this.curve.getValue(step);
                this.fire("handler", ["stop", value]);
                this.fire("onStop", [value]);
                this._active = false;
                this._paused = false;
                return this; // dojo.lfx.Animation
        },

        status: function(){
                // summary: Returns a string representation of the status of
                //                      the animation.
                if(this._active){
                        return this._paused ? "paused" : "playing"; // String
                }else{
                        return "stopped"; // String
                }
                return this;
        },

        // "private" methods
        _cycle: function(){
                clearTimeout(this._timer);
                if(this._active){
                        var curr = new Date().valueOf();
                        var step = (curr - this._startTime) / (this._endTime - this._startTime);

                        if(step >= 1){
                                step = 1;
                                this._percent = 100;
                        }else{
                                this._percent = step * 100;
                        }
                        
                        // Perform easing
                        if((this.easing)&&(dojo.lang.isFunction(this.easing))){
                                step = this.easing(step);
                        }

                        var value = this.curve.getValue(step);
                        this.fire("handler", ["animate", value]);
                        this.fire("onAnimate", [value]);

                        if( step < 1 ){
                                this._timer = setTimeout(dojo.lang.hitch(this, "_cycle"), this.rate);
                        }else{
                                this._active = false;
                                this.fire("handler", ["end"]);
                                this.fire("onEnd");

                                if(this.repeatCount > 0){
                                        this.repeatCount--;
                                        this.play(null, true);
                                }else if(this.repeatCount == -1){
                                        this.play(null, true);
                                }else{
                                        if(this._startRepeatCount){
                                                this.repeatCount = this._startRepeatCount;
                                                this._startRepeatCount = 0;
                                        }
                                }
                        }
                }
                return this; // dojo.lfx.Animation
        }
});

dojo.lfx.Combine = function(/*dojo.lfx.IAnimation...*/ animations){
        // summary: An animation object to play animations passed to it at the same time.
        dojo.lfx.IAnimation.call(this);
        this._anims = [];
        this._animsEnded = 0;
        
        var anims = arguments;
        if(anims.length == 1 && (dojo.lang.isArray(anims[0]) || dojo.lang.isArrayLike(anims[0]))){
                /* animations: dojo.lfx.IAnimation[]
                   pId: a */
                anims = anims[0];
        }
        
        dojo.lang.forEach(anims, function(anim){
                this._anims.push(anim);
                anim.connect("onEnd", dojo.lang.hitch(this, "_onAnimsEnded"));
        }, this);
}
dojo.inherits(dojo.lfx.Combine, dojo.lfx.IAnimation);
dojo.lang.extend(dojo.lfx.Combine, {
        // private members
        _animsEnded: 0,
        
        // public methods
        play: function(/*int?*/ delay, /*bool?*/ gotoStart){
                // summary: Start the animations.
                // delay: How many milliseconds to delay before starting.
                // gotoStart: If true, starts the animations from the beginning; otherwise,
                //            starts them from their current position.
                if( !this._anims.length ){ return this; /*dojo.lfx.Combine*/}

                this.fire("beforeBegin");

                if(delay > 0){
                        setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay);
                        return this; // dojo.lfx.Combine
                }
                
                if(gotoStart || this._anims[0].percent == 0){
                        this.fire("onBegin");
                }
                this.fire("onPlay");
                this._animsCall("play", null, gotoStart);
                return this; // dojo.lfx.Combine
        },
        
        pause: function(){
                // summary: Pauses the running animations.
                this.fire("onPause");
                this._animsCall("pause"); 
                return this; // dojo.lfx.Combine
        },
        
        stop: function(/*bool?*/ gotoEnd){
                // summary: Stops the running animations.
                // gotoEnd: If true, the animations will end.
                this.fire("onStop");
                this._animsCall("stop", gotoEnd);
                return this; // dojo.lfx.Combine
        },
        
        // private methods
        _onAnimsEnded: function(){
                this._animsEnded++;
                if(this._animsEnded >= this._anims.length){
                        this.fire("onEnd");
                }
                return this; // dojo.lfx.Combine
        },
        
        _animsCall: function(/*String*/ funcName){
                var args = [];
                if(arguments.length > 1){
                        for(var i = 1 ; i < arguments.length ; i++){
                                args.push(arguments[i]);
                        }
                }
                var _this = this;
                dojo.lang.forEach(this._anims, function(anim){
                        anim[funcName](args);
                }, _this);
                return this; // dojo.lfx.Combine
        }
});

dojo.lfx.Chain = function(/*dojo.lfx.IAnimation...*/ animations) {
        // summary: An animation object to play animations passed to it
        //                      one after another.
        dojo.lfx.IAnimation.call(this);
        this._anims = [];
        this._currAnim = -1;
        
        var anims = arguments;
        if(anims.length == 1 && (dojo.lang.isArray(anims[0]) || dojo.lang.isArrayLike(anims[0]))){
                /* animations: dojo.lfx.IAnimation[]
                   pId: a */
                anims = anims[0];
        }
        
        var _this = this;
        dojo.lang.forEach(anims, function(anim, i, anims_arr){
                this._anims.push(anim);
                if(i < anims_arr.length - 1){
                        anim.connect("onEnd", dojo.lang.hitch(this, "_playNext") );
                }else{
                        anim.connect("onEnd", dojo.lang.hitch(this, function(){ this.fire("onEnd"); }) );
                }
        }, this);
}
dojo.inherits(dojo.lfx.Chain, dojo.lfx.IAnimation);
dojo.lang.extend(dojo.lfx.Chain, {
        // private members
        _currAnim: -1,
        
        // public methods
        play: function(/*int?*/ delay, /*bool?*/ gotoStart){
                // summary: Start the animation sequence.
                // delay: How many milliseconds to delay before starting.
                // gotoStart: If true, starts the sequence from the beginning; otherwise,
                //            starts it from its current position.
                if( !this._anims.length ) { return this; /*dojo.lfx.Chain*/}
                if( gotoStart || !this._anims[this._currAnim] ) {
                        this._currAnim = 0;
                }

                var currentAnimation = this._anims[this._currAnim];

                this.fire("beforeBegin");
                if(delay > 0){
                        setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay);
                        return this; // dojo.lfx.Chain
                }
                
                if(currentAnimation){
                        if(this._currAnim == 0){
                                this.fire("handler", ["begin", this._currAnim]);
                                this.fire("onBegin", [this._currAnim]);
                        }
                        this.fire("onPlay", [this._currAnim]);
                        currentAnimation.play(null, gotoStart);
                }
                return this; // dojo.lfx.Chain
        },
        
        pause: function(){
                // summary: Pauses the running animation sequence.
                if( this._anims[this._currAnim] ) {
                        this._anims[this._currAnim].pause();
                        this.fire("onPause", [this._currAnim]);
                }
                return this; // dojo.lfx.Chain
        },
        
        playPause: function(){
                // summary: If the animation sequence is playing, pause it; otherwise,
                //                      play it.
                if(this._anims.length == 0){ return this; }
                if(this._currAnim == -1){ this._currAnim = 0; }
                var currAnim = this._anims[this._currAnim];
                if( currAnim ) {
                        if( !currAnim._active || currAnim._paused ) {
                                this.play();
                        } else {
                                this.pause();
                        }
                }
                return this; // dojo.lfx.Chain
        },
        
        stop: function(){
                // summary: Stops the running animations.
                var currAnim = this._anims[this._currAnim];
                if(currAnim){
                        currAnim.stop();
                        this.fire("onStop", [this._currAnim]);
                }
                return currAnim; // dojo.lfx.IAnimation
        },
        
        // private methods
        _playNext: function(){
                if( this._currAnim == -1 || this._anims.length == 0 ) { return this; }
                this._currAnim++;
                if( this._anims[this._currAnim] ){
                        this._anims[this._currAnim].play(null, true);
                }
                return this; // dojo.lfx.Chain
        }
});

dojo.lfx.combine = function(/*dojo.lfx.IAnimation...*/ animations){
        // summary: Convenience function.  Returns a dojo.lfx.Combine created
        //                      using the animations passed in.
        var anims = arguments;
        if(dojo.lang.isArray(arguments[0])){
                /* animations: dojo.lfx.IAnimation[]
                   pId: a */
                anims = arguments[0];
        }
        if(anims.length == 1){ return anims[0]; }
        return new dojo.lfx.Combine(anims); // dojo.lfx.Combine
}

dojo.lfx.chain = function(/*dojo.lfx.IAnimation...*/ animations){
        // summary: Convenience function.  Returns a dojo.lfx.Chain created
        //                      using the animations passed in.
        var anims = arguments;
        if(dojo.lang.isArray(arguments[0])){
                /* animations: dojo.lfx.IAnimation[]
                   pId: a */
                anims = arguments[0];
        }
        if(anims.length == 1){ return anims[0]; }
        return new dojo.lfx.Chain(anims); // dojo.lfx.Combine
}

dojo.provide("dojo.html.common");



dojo.lang.mixin(dojo.html, dojo.dom);

dojo.html.body = function(){
        dojo.deprecated("dojo.html.body() moved to dojo.body()", "0.5");
        return dojo.body();
}

// FIXME: we are going to assume that we can throw any and every rendering
// engine into the IE 5.x box model. In Mozilla, we do this w/ CSS.
// Need to investigate for KHTML and Opera

dojo.html.getEventTarget = function(/* DOMEvent */evt){
        //      summary
        //      Returns the target of an event
        if(!evt) { evt = dojo.global().event || {} };
        var t = (evt.srcElement ? evt.srcElement : (evt.target ? evt.target : null));
        while((t)&&(t.nodeType!=1)){ t = t.parentNode; }
        return t;       //      HTMLElement
}

dojo.html.getViewport = function(){
        //      summary
        //      Returns the dimensions of the viewable area of a browser window
        var _window = dojo.global();
        var _document = dojo.doc();
        var w = 0;
        var h = 0;

        if(dojo.render.html.mozilla){
                // mozilla
                w = _document.documentElement.clientWidth;
                h = _window.innerHeight;
        }else if(!dojo.render.html.opera && _window.innerWidth){
                //in opera9, dojo.body().clientWidth should be used, instead
                //of window.innerWidth/document.documentElement.clientWidth
                //so we have to check whether it is opera
                w = _window.innerWidth;
                h = _window.innerHeight;
        } else if (!dojo.render.html.opera && dojo.exists(_document, "documentElement.clientWidth")){
                // IE6 Strict
                var w2 = _document.documentElement.clientWidth;
                // this lets us account for scrollbars
                if(!w || w2 && w2 < w) {
                        w = w2;
                }
                h = _document.documentElement.clientHeight;
        } else if (dojo.body().clientWidth){
                // IE, Opera
                w = dojo.body().clientWidth;
                h = dojo.body().clientHeight;
        }
        return { width: w, height: h }; //      object
}

dojo.html.getScroll = function(){
        //      summary
        //      Returns the scroll position of the document
        var _window = dojo.global();
        var _document = dojo.doc();
        var top = _window.pageYOffset || _document.documentElement.scrollTop || dojo.body().scrollTop || 0;
        var left = _window.pageXOffset || _document.documentElement.scrollLeft || dojo.body().scrollLeft || 0;
        return { 
                top: top, 
                left: left, 
                offset:{ x: left, y: top }      //      note the change, NOT an Array with added properties. 
        };      //      object
}

dojo.html.getParentByType = function(/* HTMLElement */node, /* string */type) {
        //      summary
        //      Returns the first ancestor of node with tagName type.
        var _document = dojo.doc();
        var parent = dojo.byId(node);
        type = type.toLowerCase();
        while((parent)&&(parent.nodeName.toLowerCase()!=type)){
                if(parent==(_document["body"]||_document["documentElement"])){
                        return null;
                }
                parent = parent.parentNode;
        }
        return parent;  //      HTMLElement
}

dojo.html.getAttribute = function(/* HTMLElement */node, /* string */attr){
        //      summary
        //      Returns the value of attribute attr from node.
        node = dojo.byId(node);
        // FIXME: need to add support for attr-specific accessors
        if((!node)||(!node.getAttribute)){
                // if(attr !== 'nwType'){
                //      alert("getAttr of '" + attr + "' with bad node"); 
                // }
                return null;
        }
        var ta = typeof attr == 'string' ? attr : new String(attr);

        // first try the approach most likely to succeed
        var v = node.getAttribute(ta.toUpperCase());
        if((v)&&(typeof v == 'string')&&(v!="")){ 
                return v;       //      string 
        }

        // try returning the attributes value, if we couldn't get it as a string
        if(v && v.value){ 
                return v.value; //      string 
        }

        // this should work on Opera 7, but it's a little on the crashy side
        if((node.getAttributeNode)&&(node.getAttributeNode(ta))){
                return (node.getAttributeNode(ta)).value;       //      string
        }else if(node.getAttribute(ta)){
                return node.getAttribute(ta);   //      string
        }else if(node.getAttribute(ta.toLowerCase())){
                return node.getAttribute(ta.toLowerCase());     //      string
        }
        return null;    //      string
}
        
dojo.html.hasAttribute = function(/* HTMLElement */node, /* string */attr){
        //      summary
        //      Determines whether or not the specified node carries a value for the attribute in question.
        return dojo.html.getAttribute(dojo.byId(node), attr) ? true : false;    //      boolean
}
        
dojo.html.getCursorPosition = function(/* DOMEvent */e){
        //      summary
        //      Returns the mouse position relative to the document (not the viewport).
        //      For example, if you have a document that is 10000px tall,
        //      but your browser window is only 100px tall,
        //      if you scroll to the bottom of the document and call this function it
        //      will return {x: 0, y: 10000}
        //      NOTE: for events delivered via dojo.event.connect() and/or dojoAttachEvent (for widgets),
        //      you can just access evt.pageX and evt.pageY, rather than calling this function.
        e = e || dojo.global().event;
        var cursor = {x:0, y:0};
        if(e.pageX || e.pageY){
                cursor.x = e.pageX;
                cursor.y = e.pageY;
        }else{
                var de = dojo.doc().documentElement;
                var db = dojo.body();
                cursor.x = e.clientX + ((de||db)["scrollLeft"]) - ((de||db)["clientLeft"]);
                cursor.y = e.clientY + ((de||db)["scrollTop"]) - ((de||db)["clientTop"]);
        }
        return cursor;  //      object
}

dojo.html.isTag = function(/* HTMLElement */node) {
        //      summary
        //      Like dojo.dom.isTag, except case-insensitive
        node = dojo.byId(node);
        if(node && node.tagName) {
                for (var i=1; i<arguments.length; i++){
                        if (node.tagName.toLowerCase()==String(arguments[i]).toLowerCase()){
                                return String(arguments[i]).toLowerCase();      //      string
                        }
                }
        }
        return "";      //      string
}

//define dojo.html.createExternalElement for IE to workaround the annoying activation "feature" in new IE
//details: http://msdn.microsoft.com/library/default.asp?url=/workshop/author/dhtml/overview/activating_activex.asp
if(dojo.render.html.ie && !dojo.render.html.ie70){
        //only define createExternalElement for IE in none https to avoid "mixed content" warning dialog
        if(window.location.href.substr(0,6).toLowerCase() != "https:"){
                (function(){
                        // FIXME: this seems not to work correctly on IE 7!!

                        //The trick is to define a function in a script.src property:
                        // <script src="javascript:'function createExternalElement(){...}'"></script>,
                        //which will be treated as an external javascript file in IE
                        var xscript = dojo.doc().createElement('script');
                        xscript.src = "javascript:'dojo.html.createExternalElement=function(doc, tag){ return doc.createElement(tag); }'";
                        dojo.doc().getElementsByTagName("head")[0].appendChild(xscript);
                })();
        }
}else{
        //for other browsers, simply use document.createElement
        //is enough
        dojo.html.createExternalElement = function(/* HTMLDocument */doc, /* string */tag){
                //      summary
                //      Creates an element in the HTML document, here for ActiveX activation workaround.
                return doc.createElement(tag);  //      HTMLElement
        }
}

dojo.html._callDeprecated = function(inFunc, replFunc, args, argName, retValue){
        dojo.deprecated("dojo.html." + inFunc,
                                        "replaced by dojo.html." + replFunc + "(" + (argName ? "node, {"+ argName + ": " + argName + "}" : "" ) + ")" + (retValue ? "." + retValue : ""), "0.5");
        var newArgs = [];
        if(argName){ var argsIn = {}; argsIn[argName] = args[1]; newArgs.push(args[0]); newArgs.push(argsIn); }
        else { newArgs = args }
        var ret = dojo.html[replFunc].apply(dojo.html, args);
        if(retValue){ return ret[retValue]; }
        else { return ret; }
}

dojo.html.getViewportWidth = function(){
        return dojo.html._callDeprecated("getViewportWidth", "getViewport", arguments, null, "width");
}
dojo.html.getViewportHeight = function(){
        return dojo.html._callDeprecated("getViewportHeight", "getViewport", arguments, null, "height");
}
dojo.html.getViewportSize = function(){
        return dojo.html._callDeprecated("getViewportSize", "getViewport", arguments);
}
dojo.html.getScrollTop = function(){
        return dojo.html._callDeprecated("getScrollTop", "getScroll", arguments, null, "top");
}
dojo.html.getScrollLeft = function(){
        return dojo.html._callDeprecated("getScrollLeft", "getScroll", arguments, null, "left");
}
dojo.html.getScrollOffset = function(){
        return dojo.html._callDeprecated("getScrollOffset", "getScroll", arguments, null, "offset");
}

dojo.provide("dojo.uri.Uri");

dojo.uri = new function() {
        this.dojoUri = function (/*dojo.uri.Uri||String*/uri) {
                // summary: returns a Uri object resolved relative to the dojo root
                return new dojo.uri.Uri(dojo.hostenv.getBaseScriptUri(), uri);
        }

        this.moduleUri = function(/*String*/module, /*dojo.uri.Uri||String*/uri){
                // summary: returns a Uri object relative to a module
                // description: Examples: dojo.uri.moduleUri("dojo.widget","templates/template.html"), or dojo.uri.moduleUri("acme","images/small.png")
                var loc = dojo.hostenv.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 baseScriptUri.
                var colonIndex = loc.indexOf(":");
                var slashIndex = loc.indexOf("/");
                if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > slashIndex)){
                        loc = dojo.hostenv.getBaseScriptUri() + loc;
                }

                return new dojo.uri.Uri(loc,uri);
        }

        this.Uri = function (/*dojo.uri.Uri||String...*/) {
                // summary: Constructor to create an object representing a URI.
                // 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.uri.Uri(document.baseURI, uri)

                // TODO: support for IPv6, see RFC 2732

                // resolve uri components relative to each other
                var uri = arguments[0];
                for (var i = 1; i < arguments.length; i++) {
                        if(!arguments[i]) { continue; }

                        // Safari doesn't support this.constructor so we have to be explicit
                        var relobj = new dojo.uri.Uri(arguments[i].toString());
                        var uriobj = new dojo.uri.Uri(uri.toString());

                        if ((relobj.path=="")&&(relobj.scheme==null)&&(relobj.authority==null)&&(relobj.query==null)) {
                                if (relobj.fragment != null) { uriobj.fragment = relobj.fragment; }
                                relobj = uriobj;
                        } else if (relobj.scheme == null) {
                                relobj.scheme = uriobj.scheme;

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

                this.uri = uri.toString();

                // break the uri into its main components
                var regexp = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$";
                var r = this.uri.match(new RegExp(regexp));

                this.scheme = r[2] || (r[1] ? "" : null);
                this.authority = r[4] || (r[3] ? "" : null);
                this.path = r[5]; // can never be undefined
                this.query = r[7] || (r[6] ? "" : null);
                this.fragment  = r[9] || (r[8] ? "" : null);

                if (this.authority != null) {
                        // server based naming authority
                        regexp = "^((([^:]+:)?([^@]+))@)?([^:]*)(:([0-9]+))?$";
                        r = this.authority.match(new RegExp(regexp));

                        this.user = r[3] || null;
                        this.password = r[4] || null;
                        this.host = r[5];
                        this.port = r[7] || null;
                }

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

dojo.provide("dojo.html.style");



dojo.html.getClass = function(/* HTMLElement */node){
        //      summary
        //      Returns the string value of the list of CSS classes currently assigned directly 
        //      to the node in question. Returns an empty string if no class attribute is found;
        node = dojo.byId(node);
        if(!node){ return ""; }
        var cs = "";
        if(node.className){
                cs = node.className;
        }else if(dojo.html.hasAttribute(node, "class")){
                cs = dojo.html.getAttribute(node, "class");
        }
        return cs.replace(/^\s+|\s+$/g, "");    //      string
}

dojo.html.getClasses = function(/* HTMLElement */node) {
        //      summary
        //      Returns an array of CSS classes currently assigned directly to the node in question. 
        //      Returns an empty array if no classes are found;
        var c = dojo.html.getClass(node);
        return (c == "") ? [] : c.split(/\s+/g);        //      array
}

dojo.html.hasClass = function(/* HTMLElement */node, /* string */classname){
        //      summary
        //      Returns whether or not the specified classname is a portion of the
        //      class list currently applied to the node. Does not cover cascaded
        //      styles, only classes directly applied to the node.
        return (new RegExp('(^|\\s+)'+classname+'(\\s+|$)')).test(dojo.html.getClass(node))     //      boolean
}

dojo.html.prependClass = function(/* HTMLElement */node, /* string */classStr){
        //      summary
        //      Adds the specified class to the beginning of the class list on the
        //      passed node. This gives the specified class the highest precidence
        //      when style cascading is calculated for the node. Returns true or
        //      false; indicating success or failure of the operation, respectively.
        classStr += " " + dojo.html.getClass(node);
        return dojo.html.setClass(node, classStr);      //      boolean
}

dojo.html.addClass = function(/* HTMLElement */node, /* string */classStr){
        //      summary
        //      Adds the specified class to the end of the class list on the
        //      passed &node;. Returns &true; or &false; indicating success or failure.
        if (dojo.html.hasClass(node, classStr)) {
          return false;
        }
        classStr = (dojo.html.getClass(node) + " " + classStr).replace(/^\s+|\s+$/g,"");
        return dojo.html.setClass(node, classStr);      //      boolean
}

dojo.html.setClass = function(/* HTMLElement */node, /* string */classStr){
        //      summary
        //      Clobbers the existing list of classes for the node, replacing it with
        //      the list given in the 2nd argument. Returns true or false
        //      indicating success or failure.
        node = dojo.byId(node);
        var cs = new String(classStr);
        try{
                if(typeof node.className == "string"){
                        node.className = cs;
                }else if(node.setAttribute){
                        node.setAttribute("class", classStr);
                        node.className = cs;
                }else{
                        return false;
                }
        }catch(e){
                dojo.debug("dojo.html.setClass() failed", e);
        }
        return true;
}

dojo.html.removeClass = function(/* HTMLElement */node, /* string */classStr, /* boolean? */allowPartialMatches){
        //      summary
        //      Removes the className from the node;. Returns true or false indicating success or failure.
        try{
                if (!allowPartialMatches) {
                        var newcs = dojo.html.getClass(node).replace(new RegExp('(^|\\s+)'+classStr+'(\\s+|$)'), "$1$2");
                } else {
                        var newcs = dojo.html.getClass(node).replace(classStr,'');
                }
                dojo.html.setClass(node, newcs);
        }catch(e){
                dojo.debug("dojo.html.removeClass() failed", e);
        }
        return true;    //      boolean
}

dojo.html.replaceClass = function(/* HTMLElement */node, /* string */newClass, /* string */oldClass) {
        //      summary
        //      Replaces 'oldClass' and adds 'newClass' to node
        dojo.html.removeClass(node, oldClass);
        dojo.html.addClass(node, newClass);
}

// Enum type for getElementsByClass classMatchType arg:
dojo.html.classMatchType = {
        ContainsAll : 0, // all of the classes are part of the node's class (default)
        ContainsAny : 1, // any of the classes are part of the node's class
        IsOnly : 2 // only all of the classes are part of the node's class
}


dojo.html.getElementsByClass = function(
        /* string */classStr, 
        /* HTMLElement? */parent, 
        /* string? */nodeType, 
        /* integer? */classMatchType, 
        /* boolean? */useNonXpath
){
        //      summary
        //      Returns an array of nodes for the given classStr, children of a
        //      parent, and optionally of a certain nodeType
        // FIXME: temporarily set to false because of several dojo tickets related
        // to the xpath version not working consistently in firefox.
        useNonXpath = false;
        var _document = dojo.doc();
        parent = dojo.byId(parent) || _document;
        var classes = classStr.split(/\s+/g);
        var nodes = [];
        if( classMatchType != 1 && classMatchType != 2 ) classMatchType = 0; // make it enum
        var reClass = new RegExp("(\\s|^)((" + classes.join(")|(") + "))(\\s|$)");
        var srtLength = classes.join(" ").length;
        var candidateNodes = [];
        
        if(!useNonXpath && _document.evaluate) { // supports dom 3 xpath
                var xpath = ".//" + (nodeType || "*") + "[contains(";
                if(classMatchType != dojo.html.classMatchType.ContainsAny){
                        xpath += "concat(' ',@class,' '), ' " +
                        classes.join(" ') and contains(concat(' ',@class,' '), ' ") +
                        " ')";
                        if (classMatchType == 2) {
                                xpath += " and string-length(@class)="+srtLength+"]";
                        }else{
                                xpath += "]";
                        }
                }else{
                        xpath += "concat(' ',@class,' '), ' " +
                        classes.join(" ') or contains(concat(' ',@class,' '), ' ") +
                        " ')]";
                }
                var xpathResult = _document.evaluate(xpath, parent, null, XPathResult.ANY_TYPE, null);
                var result = xpathResult.iterateNext();
                while(result){
                        try{
                                candidateNodes.push(result);
                                result = xpathResult.iterateNext();
                        }catch(e){ break; }
                }
                return candidateNodes;  //      NodeList
        }else{
                if(!nodeType){
                        nodeType = "*";
                }
                candidateNodes = parent.getElementsByTagName(nodeType);

                var node, i = 0;
                outer:
                while(node = candidateNodes[i++]){
                        var nodeClasses = dojo.html.getClasses(node);
                        if(nodeClasses.length == 0){ continue outer; }
                        var matches = 0;
        
                        for(var j = 0; j < nodeClasses.length; j++){
                                if(reClass.test(nodeClasses[j])){
                                        if(classMatchType == dojo.html.classMatchType.ContainsAny){
                                                nodes.push(node);
                                                continue outer;
                                        }else{
                                                matches++;
                                        }
                                }else{
                                        if(classMatchType == dojo.html.classMatchType.IsOnly){
                                                continue outer;
                                        }
                                }
                        }
        
                        if(matches == classes.length){
                                if(     (classMatchType == dojo.html.classMatchType.IsOnly)&&
                                        (matches == nodeClasses.length)){
                                        nodes.push(node);
                                }else if(classMatchType == dojo.html.classMatchType.ContainsAll){
                                        nodes.push(node);
                                }
                        }
                }
                return nodes;   //      NodeList
        }
}
dojo.html.getElementsByClassName = dojo.html.getElementsByClass;

dojo.html.toCamelCase = function(/* string */selector){
        //      summary
        //      Translates a CSS selector string to a camel-cased one.
        var arr = selector.split('-'), cc = arr[0];
        for(var i = 1; i < arr.length; i++) {
                cc += arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
        }
        return cc;      //      string
}

dojo.html.toSelectorCase = function(/* string */selector){
        //      summary
        //      Translates a camel cased string to a selector cased one.
        return selector.replace(/([A-Z])/g, "-$1" ).toLowerCase();      //      string
}

if (dojo.render.html.ie) {
        // IE branch
        dojo.html.getComputedStyle = function(/*HTMLElement|String*/node, /*String*/property, /*String*/value) {
                // summary
                // Get the computed style value for style "property" on "node" (IE).
                node = dojo.byId(node); // FIXME: remove ability to access nodes by id for this time-critical function
                if(!node || !node.currentStyle){return value;}
                // FIXME: standardize on camel-case input to improve speed
                return node.currentStyle[dojo.html.toCamelCase(property)]; // String
        }
        // SJM: getComputedStyle should be abandoned and replaced with the below function.
        // All our supported browsers can return CSS2 compliant CssStyleDeclaration objects
        // which can be queried directly for multiple styles.
        dojo.html.getComputedStyles = function(/*HTMLElement*/node) {
                // summary
                // Get a style object containing computed styles for HTML Element node (IE).
                return node.currentStyle; // CSSStyleDeclaration
        }
} else {
        // non-IE branch
        dojo.html.getComputedStyle = function(/*HTMLElement|String*/node, /*String*/property, /*Any*/value) {
                // summary
                // Get the computed style value for style "property" on "node" (non-IE).
                node = dojo.byId(node);
                if(!node || !node.style){return value;}
                var s = document.defaultView.getComputedStyle(node, null);
                // s may be null on Safari
                return (s&&s[dojo.html.toCamelCase(property)])||''; // String
        }       
        // SJM: getComputedStyle should be abandoned and replaced with the below function.
        // All our supported browsers can return CSS2 compliant CssStyleDeclaration objects
        // which can be queried directly for multiple styles.
        dojo.html.getComputedStyles = function(node) {
                // summary
                // Get a style object containing computed styles for HTML Element node (non-IE).
                return document.defaultView.getComputedStyle(node, null); // CSSStyleDeclaration
        }       
}

dojo.html.getStyleProperty = function(/* HTMLElement */node, /* string */cssSelector){
        //      summary
        //      Returns the value of the passed style
        node = dojo.byId(node);
        return (node && node.style ? node.style[dojo.html.toCamelCase(cssSelector)] : undefined);       //      string
}

dojo.html.getStyle = function(/* HTMLElement */node, /* string */cssSelector){
        //      summary
        //      Returns the computed value of the passed style
        var value = dojo.html.getStyleProperty(node, cssSelector);
        return (value ? value : dojo.html.getComputedStyle(node, cssSelector)); //      string || integer
}

dojo.html.setStyle = function(/* HTMLElement */node, /* string */cssSelector, /* string */value){
        //      summary
        //      Set the value of passed style on node
        node = dojo.byId(node);
        if(node && node.style){
                var camelCased = dojo.html.toCamelCase(cssSelector);
                node.style[camelCased] = value;
        }
}

dojo.html.setStyleText = function (/* HTMLElement */target, /* string */text) {
        //      summary
        //      Try to set the entire cssText property of the passed target; equiv of setting style attribute.
        try {
                target.style.cssText = text;
        } catch (e) {
                target.setAttribute("style", text);
        }
}

dojo.html.copyStyle = function(/* HTMLElement */target, /* HTMLElement */source){
        //      summary
        // work around for opera which doesn't have cssText, and for IE which fails on setAttribute 
        if(!source.style.cssText){ 
                target.setAttribute("style", source.getAttribute("style")); 
        }else{
                target.style.cssText = source.style.cssText; 
        }
        dojo.html.addClass(target, dojo.html.getClass(source));
}

dojo.html.getUnitValue = function(/* HTMLElement */node, /* string */cssSelector, /* boolean? */autoIsZero){
        //      summary
        //      Get the value of passed selector, with the specific units used
        var s = dojo.html.getComputedStyle(node, cssSelector);
        if((!s)||((s == 'auto')&&(autoIsZero))){ 
                return { value: 0, units: 'px' };       //      object 
        }
        // FIXME: is regex inefficient vs. parseInt or some manual test? 
        var match = s.match(/(\-?[\d.]+)([a-z%]*)/i);
        if (!match){return dojo.html.getUnitValue.bad;}
        return { value: Number(match[1]), units: match[2].toLowerCase() };      //      object
}
dojo.html.getUnitValue.bad = { value: NaN, units: '' };

if (dojo.render.html.ie) {
        // IE branch
        dojo.html.toPixelValue = function(/* HTMLElement */element, /* String */styleValue){
                // summary
                //  Extract value in pixels from styleValue (IE version).
                //  If a value cannot be extracted, zero is returned.
                if(!styleValue){return 0;}
                if(styleValue.slice(-2) == 'px'){return parseFloat(styleValue);}
                var pixelValue = 0;
                with(element){
                        var sLeft = style.left;
                        var rsLeft = runtimeStyle.left;
                        runtimeStyle.left = currentStyle.left;
                        try {
                                style.left = styleValue || 0;
                                pixelValue = style.pixelLeft;
                                style.left = sLeft;
                                runtimeStyle.left = rsLeft;
                        }catch(e){
                                // FIXME: it's possible for styleValue to be incompatible with
                                // style.left. In particular, border width values of 
                                // "thick", "medium", or "thin" will provoke an exception.
                        }
                }
                return pixelValue; // Number
        }
} else {
        // non-IE branch
        dojo.html.toPixelValue = function(/* HTMLElement */element, /* String */styleValue){
                // summary
                //  Extract value in pixels from styleValue (non-IE version).
                //  If a value cannot be extracted, zero is returned.
                return (styleValue && (styleValue.slice(-2)=='px') ? parseFloat(styleValue) : 0); // Number
        }
}

dojo.html.getPixelValue = function(/* HTMLElement */node, /* string */styleProperty, /* boolean? */autoIsZero){
        // summary
        //  Get a computed style value, in pixels.
        // node: HTMLElement
        //  Node to interrogate
        // styleProperty: String
        //  Style property to query, in either css-selector or camelCase (property) format.
        // autoIsZero: Boolean
        //  Deprecated. Any value that cannot be converted to pixels is returned as zero.
        // 
        //  summary
        //  Get the value of passed selector in pixels.
        //
        return dojo.html.toPixelValue(node, dojo.html.getComputedStyle(node, styleProperty));
} 

dojo.html.setPositivePixelValue = function(/* HTMLElement */node, /* string */selector, /* integer */value){
        //      summary
        //      Attempt to set the value of selector on node as a positive pixel value.
        if(isNaN(value)){return false;}
        node.style[selector] = Math.max(0, value) + 'px'; 
        return true;    //      boolean
}

dojo.html.styleSheet = null;

// FIXME: this is a really basic stub for adding and removing cssRules, but
// it assumes that you know the index of the cssRule that you want to add 
// or remove, making it less than useful.  So we need something that can 
// search for the selector that you you want to remove.
dojo.html.insertCssRule = function(/* string */selector, /* string */declaration, /* integer? */index) {
        //      summary
        //      Attempt to insert declaration as selector on the internal stylesheet; if index try to set it there.
        if (!dojo.html.styleSheet) {
                if (document.createStyleSheet) { // IE
                        dojo.html.styleSheet = document.createStyleSheet();
                } else if (document.styleSheets[0]) { // rest
                        // FIXME: should create a new style sheet here
                        // fall back on an exsiting style sheet
                        dojo.html.styleSheet = document.styleSheets[0];
                } else { 
                        return null;    //      integer 
                } // fail
        }

        if (arguments.length < 3) { // index may == 0
                if (dojo.html.styleSheet.cssRules) { // W3
                        index = dojo.html.styleSheet.cssRules.length;
                } else if (dojo.html.styleSheet.rules) { // IE
                        index = dojo.html.styleSheet.rules.length;
                } else { 
                        return null;    //      integer 
                } // fail
        }

        if (dojo.html.styleSheet.insertRule) { // W3
                var rule = selector + " { " + declaration + " }";
                return dojo.html.styleSheet.insertRule(rule, index);    //      integer
        } else if (dojo.html.styleSheet.addRule) { // IE
                return dojo.html.styleSheet.addRule(selector, declaration, index);      //      integer
        } else { 
                return null; // integer
        } // fail
}

dojo.html.removeCssRule = function(/* integer? */index){
        //      summary
        //      Attempt to remove the rule at index.
        if(!dojo.html.styleSheet){
                dojo.debug("no stylesheet defined for removing rules");
                return false;
        }
        if(dojo.render.html.ie){
                if(!index){
                        index = dojo.html.styleSheet.rules.length;
                        dojo.html.styleSheet.removeRule(index);
                }
        }else if(document.styleSheets[0]){
                if(!index){
                        index = dojo.html.styleSheet.cssRules.length;
                }
                dojo.html.styleSheet.deleteRule(index);
        }
        return true;    //      boolean
}

dojo.html._insertedCssFiles = []; // cache container needed because IE reformats cssText when added to DOM
dojo.html.insertCssFile = function(/* string */URI, /* HTMLDocument? */doc, /* boolean? */checkDuplicates, /* boolean */fail_ok){
        //      summary
        // calls css by XmlHTTP and inserts it into DOM as <style [widgetType="widgetType"]> *downloaded cssText*</style>
        if(!URI){ return; }
        if(!doc){ doc = document; }
        var cssStr = dojo.hostenv.getText(URI, false, fail_ok);
        if(cssStr===null){ return; }
        cssStr = dojo.html.fixPathsInCssText(cssStr, URI);

        if(checkDuplicates){
                var idx = -1, node, ent = dojo.html._insertedCssFiles;
                for(var i = 0; i < ent.length; i++){
                        if((ent[i].doc == doc) && (ent[i].cssText == cssStr)){
                                idx = i; node = ent[i].nodeRef;
                                break;
                        }
                }
                // make sure we havent deleted our node
                if(node){
                        var styles = doc.getElementsByTagName("style");
                        for(var i = 0; i < styles.length; i++){
                                if(styles[i] == node){
                                        return;
                                }
                        }
                        // delete this entry
                        dojo.html._insertedCssFiles.shift(idx, 1);
                }
        }

        var style = dojo.html.insertCssText(cssStr, doc);
        dojo.html._insertedCssFiles.push({'doc': doc, 'cssText': cssStr, 'nodeRef': style});

        // insert custom attribute ex dbgHref="../foo.css" usefull when debugging in DOM inspectors, no?
        if(style && djConfig.isDebug){
                style.setAttribute("dbgHref", URI);
        }
        return style;   //      HTMLStyleElement
}

dojo.html.insertCssText = function(/* string */cssStr, /* HTMLDocument? */doc, /* string? */URI){
        //      summary
        //      Attempt to insert CSS rules into the document through inserting a style element
        // DomNode Style  = insertCssText(String ".dojoMenu {color: green;}"[, DomDoc document, dojo.uri.Uri Url ])
        if(!cssStr){ 
                return; //      HTMLStyleElement
        }
        if(!doc){ doc = document; }
        if(URI){// fix paths in cssStr
                cssStr = dojo.html.fixPathsInCssText(cssStr, URI);
        }
        var style = doc.createElement("style");
        style.setAttribute("type", "text/css");
        // IE is b0rken enough to require that we add the element to the doc
        // before changing it's properties
        var head = doc.getElementsByTagName("head")[0];
        if(!head){ // must have a head tag 
                dojo.debug("No head tag in document, aborting styles");
                return; //      HTMLStyleElement
        }else{
                head.appendChild(style);
        }
        if(style.styleSheet){// IE
                var setFunc = function(){ 
                        try{
                                style.styleSheet.cssText = cssStr;
                        }catch(e){ dojo.debug(e); }
                };
                if(style.styleSheet.disabled){
                        setTimeout(setFunc, 10);
                }else{
                        setFunc();
                }
        }else{ // w3c
                var cssText = doc.createTextNode(cssStr);
                style.appendChild(cssText);
        }
        return style;   //      HTMLStyleElement
}

dojo.html.fixPathsInCssText = function(/* string */cssStr, /* string */URI){
        //      summary
        // usage: cssText comes from dojoroot/src/widget/templates/Foobar.css
        //      it has .dojoFoo { background-image: url(images/bar.png);} then uri should point to dojoroot/src/widget/templates/
        if(!cssStr || !URI){ return; }
        var match, str = "", url = "", urlChrs = "[\\t\\s\\w\\(\\)\\/\\.\\\\'\"-:#=&?~]+";
        var regex = new RegExp('url\\(\\s*('+urlChrs+')\\s*\\)');
        var regexProtocol = /(file|https?|ftps?):\/\//;
        regexTrim = new RegExp("^[\\s]*(['\"]?)("+urlChrs+")\\1[\\s]*?$");
        if(dojo.render.html.ie55 || dojo.render.html.ie60){
                var regexIe = new RegExp("AlphaImageLoader\\((.*)src\=['\"]("+urlChrs+")['\"]");
                // TODO: need to decide how to handle relative paths and AlphaImageLoader see #1441
                // current implementation breaks on build with intern_strings
                while(match = regexIe.exec(cssStr)){
                        url = match[2].replace(regexTrim, "$2");
                        if(!regexProtocol.exec(url)){
                                url = (new dojo.uri.Uri(URI, url).toString());
                        }
                        str += cssStr.substring(0, match.index) + "AlphaImageLoader(" + match[1] + "src='" + url + "'";
                        cssStr = cssStr.substr(match.index + match[0].length);
                }
                cssStr = str + cssStr;
                str = "";
        }

        while(match = regex.exec(cssStr)){
                url = match[1].replace(regexTrim, "$2");
                if(!regexProtocol.exec(url)){
                        url = (new dojo.uri.Uri(URI, url).toString());
                }
                str += cssStr.substring(0, match.index) + "url(" + url + ")";
                cssStr = cssStr.substr(match.index + match[0].length);
        }
        return str + cssStr;    //      string
}

dojo.html.setActiveStyleSheet = function(/* string */title){
        //      summary
        //      Activate style sheet with specified title.
        var i = 0, a, els = dojo.doc().getElementsByTagName("link");
        while (a = els[i++]) {
                if(a.getAttribute("rel").indexOf("style") != -1 && a.getAttribute("title")){
                        a.disabled = true;
                        if (a.getAttribute("title") == title) { a.disabled = false; }
                }
        }
}

dojo.html.getActiveStyleSheet = function(){
        //      summary
        //      return the title of the currently active stylesheet
        var i = 0, a, els = dojo.doc().getElementsByTagName("link");
        while (a = els[i++]) {
                if (a.getAttribute("rel").indexOf("style") != -1 
                        && a.getAttribute("title") 
                        && !a.disabled
                ){
                        return a.getAttribute("title"); //      string 
                }
        }
        return null;    //      string
}

dojo.html.getPreferredStyleSheet = function(){
        //      summary
        //      Return the preferred stylesheet title (i.e. link without alt attribute)
        var i = 0, a, els = dojo.doc().getElementsByTagName("link");
        while (a = els[i++]) {
                if(a.getAttribute("rel").indexOf("style") != -1
                        && a.getAttribute("rel").indexOf("alt") == -1
                        && a.getAttribute("title")
                ){ 
                        return a.getAttribute("title");         //      string
                }
        }
        return null;    //      string
}

dojo.html.applyBrowserClass = function(/* HTMLElement */node){
        //      summary
        //      Applies pre-set class names based on browser & version to the passed node.
        //      Modified version of Morris' CSS hack.
        var drh=dojo.render.html;
        var classes = {
                dj_ie: drh.ie,
                dj_ie55: drh.ie55,
                dj_ie6: drh.ie60,
                dj_ie7: drh.ie70,
                dj_iequirks: drh.ie && drh.quirks,
                dj_opera: drh.opera,
                dj_opera8: drh.opera && (Math.floor(dojo.render.version)==8),
                dj_opera9: drh.opera && (Math.floor(dojo.render.version)==9),
                dj_khtml: drh.khtml,
                dj_safari: drh.safari,
                dj_gecko: drh.mozilla
        }; // no dojo unsupported browsers
        for(var p in classes){
                if(classes[p]){
                        dojo.html.addClass(node, p);
                }
        }
};

dojo.provide("dojo.html.display");


dojo.html._toggle = function(node, tester, setter){
        node = dojo.byId(node);
        setter(node, !tester(node));
        return tester(node);
}

dojo.html.show = function(/* HTMLElement */node){
        //      summary
        //      Show the passed element by reverting display property set by dojo.html.hide
        node = dojo.byId(node);
        if(dojo.html.getStyleProperty(node, 'display')=='none'){
                dojo.html.setStyle(node, 'display', (node.dojoDisplayCache||''));
                node.dojoDisplayCache = undefined;      // cannot use delete on a node in IE6
        }
}

dojo.html.hide = function(/* HTMLElement */node){
        //      summary
        //      Hide the passed element by setting display:none
        node = dojo.byId(node);
        if(typeof node["dojoDisplayCache"] == "undefined"){ // it could == '', so we cannot say !node.dojoDisplayCount
                var d = dojo.html.getStyleProperty(node, 'display')
                if(d!='none'){
                        node.dojoDisplayCache = d;
                }
        }
        dojo.html.setStyle(node, 'display', 'none');
}

dojo.html.setShowing = function(/* HTMLElement */node, /* boolean? */showing){
        //      summary
        // Calls show() if showing is true, hide() otherwise
        dojo.html[(showing ? 'show' : 'hide')](node);
}

dojo.html.isShowing = function(/* HTMLElement */node){
        //      summary
        //      Returns whether the element is displayed or not.
        // FIXME: returns true if node is bad, isHidden would be easier to make correct
        return (dojo.html.getStyleProperty(node, 'display') != 'none'); //      boolean
}

dojo.html.toggleShowing = function(/* HTMLElement */node){
        //      summary
        // Call setShowing() on node with the complement of isShowing(), then return the new value of isShowing()
        return dojo.html._toggle(node, dojo.html.isShowing, dojo.html.setShowing);      //      boolean
}

// Simple mapping of tag names to display values
// FIXME: simplistic 
dojo.html.displayMap = { tr: '', td: '', th: '', img: 'inline', span: 'inline', input: 'inline', button: 'inline' };

dojo.html.suggestDisplayByTagName = function(/* HTMLElement */node){
        //      summary
        // Suggest a value for the display property that will show 'node' based on it's tag
        node = dojo.byId(node);
        if(node && node.tagName){
                var tag = node.tagName.toLowerCase();
                return (tag in dojo.html.displayMap ? dojo.html.displayMap[tag] : 'block');     //      string
        }
}

dojo.html.setDisplay = function(/* HTMLElement */node, /* string */display){
        //      summary
        //      Sets the value of style.display to value of 'display' parameter if it is a string.
        //      Otherwise, if 'display' is false, set style.display to 'none'.
        //      Finally, set 'display' to a suggested display value based on the node's tag
        dojo.html.setStyle(node, 'display', ((display instanceof String || typeof display == "string") ? display : (display ? dojo.html.suggestDisplayByTagName(node) : 'none')));
}

dojo.html.isDisplayed = function(/* HTMLElement */node){
        //      summary
        //      Is true if the the computed display style for node is not 'none'
        //      FIXME: returns true if node is bad, isNotDisplayed would be easier to make correct
        return (dojo.html.getComputedStyle(node, 'display') != 'none'); //      boolean
}

dojo.html.toggleDisplay = function(/* HTMLElement */node){
        //      summary
        //      Call setDisplay() on node with the complement of isDisplayed(), then
        //      return the new value of isDisplayed()
        return dojo.html._toggle(node, dojo.html.isDisplayed, dojo.html.setDisplay);    //      boolean
}

dojo.html.setVisibility = function(/* HTMLElement */node, /* string */visibility){
        //      summary
        //      Sets the value of style.visibility to value of 'visibility' parameter if it is a string.
        //      Otherwise, if 'visibility' is false, set style.visibility to 'hidden'. Finally, set style.visibility to 'visible'.
        dojo.html.setStyle(node, 'visibility', ((visibility instanceof String || typeof visibility == "string") ? visibility : (visibility ? 'visible' : 'hidden')));
}

dojo.html.isVisible = function(/* HTMLElement */node){
        //      summary
        //      Returns true if the the computed visibility style for node is not 'hidden'
        //      FIXME: returns true if node is bad, isInvisible would be easier to make correct
        return (dojo.html.getComputedStyle(node, 'visibility') != 'hidden');    //      boolean
}

dojo.html.toggleVisibility = function(node){
        //      summary
        // Call setVisibility() on node with the complement of isVisible(), then return the new value of isVisible()
        return dojo.html._toggle(node, dojo.html.isVisible, dojo.html.setVisibility);   //      boolean
}

dojo.html.setOpacity = function(/* HTMLElement */node, /* float */opacity, /* boolean? */dontFixOpacity){
        //      summary
        //      Sets the opacity of node in a cross-browser way.
        //      float between 0.0 (transparent) and 1.0 (opaque)
        node = dojo.byId(node);
        var h = dojo.render.html;
        if(!dontFixOpacity){
                if( opacity >= 1.0){
                        if(h.ie){
                                dojo.html.clearOpacity(node);
                                return;
                        }else{
                                opacity = 0.999999;
                        }
                }else if( opacity < 0.0){ opacity = 0; }
        }
        if(h.ie){
                if(node.nodeName.toLowerCase() == "tr"){
                        // FIXME: is this too naive? will we get more than we want?
                        var tds = node.getElementsByTagName("td");
                        for(var x=0; x<tds.length; x++){
                                tds[x].style.filter = "Alpha(Opacity="+opacity*100+")";
                        }
                }
                node.style.filter = "Alpha(Opacity="+opacity*100+")";
        }else if(h.moz){
                node.style.opacity = opacity; // ffox 1.0 directly supports "opacity"
                node.style.MozOpacity = opacity;
        }else if(h.safari){
                node.style.opacity = opacity; // 1.3 directly supports "opacity"
                node.style.KhtmlOpacity = opacity;
        }else{
                node.style.opacity = opacity;
        }
}

dojo.html.clearOpacity = function(/* HTMLElement */node){
        //      summary
        //      Clears any opacity setting on the passed element.
        node = dojo.byId(node);
        var ns = node.style;
        var h = dojo.render.html;
        if(h.ie){
                try {
                        if( node.filters && node.filters.alpha ){
                                ns.filter = ""; // FIXME: may get rid of other filter effects
                        }
                } catch(e) {
                        /*
                         * IE7 gives error if node.filters not set;
                         * don't know why or how to workaround (other than this)
                         */
                }
        }else if(h.moz){
                ns.opacity = 1;
                ns.MozOpacity = 1;
        }else if(h.safari){
                ns.opacity = 1;
                ns.KhtmlOpacity = 1;
        }else{
                ns.opacity = 1;
        }
}

dojo.html.getOpacity = function(/* HTMLElement */node){
        //      summary
        //      Returns the opacity of the passed element
        node = dojo.byId(node);
        var h = dojo.render.html;
        if(h.ie){
                var opac = (node.filters && node.filters.alpha &&
                        typeof node.filters.alpha.opacity == "number"
                        ? node.filters.alpha.opacity : 100) / 100;
        }else{
                var opac = node.style.opacity || node.style.MozOpacity ||
                        node.style.KhtmlOpacity || 1;
        }
        return opac >= 0.999999 ? 1.0 : Number(opac);   //      float
}


dojo.provide("dojo.html.color");




dojo.html.getBackgroundColor = function(/* HTMLElement */node){
        //      summary
        //      returns the background color of the passed node as a 32-bit color (RGBA)
        node = dojo.byId(node);
        var color;
        do{
                color = dojo.html.getStyle(node, "background-color");
                // Safari doesn't say "transparent"
                if(color.toLowerCase() == "rgba(0, 0, 0, 0)") { color = "transparent"; }
                if(node == document.getElementsByTagName("body")[0]) { node = null; break; }
                node = node.parentNode;
        }while(node && dojo.lang.inArray(["transparent", ""], color));
        if(color == "transparent"){
                color = [255, 255, 255, 0];
        }else{
                color = dojo.gfx.color.extractRGB(color);
        }
        return color;   //      array
}

dojo.provide("dojo.html.layout");





dojo.html.sumAncestorProperties = function(/* HTMLElement */node, /* string */prop){
        //      summary
        //      Returns the sum of the passed property on all ancestors of node.
        node = dojo.byId(node);
        if(!node){ return 0; } // FIXME: throw an error?
        
        var retVal = 0;
        while(node){
                if(dojo.html.getComputedStyle(node, 'position') == 'fixed'){
                        return 0;
                }
                var val = node[prop];
                if(val){
                        retVal += val - 0;
                        if(node==dojo.body()){ break; }// opera and khtml #body & #html has the same values, we only need one value
                }
                node = node.parentNode;
        }
        return retVal;  //      integer
}

dojo.html.setStyleAttributes = function(/* HTMLElement */node, /* string */attributes) { 
        //      summary
        //      allows a dev to pass a string similar to what you'd pass in style="", and apply it to a node.
        node = dojo.byId(node);
        var splittedAttribs=attributes.replace(/(;)?\s*$/, "").split(";"); 
        for(var i=0; i<splittedAttribs.length; i++){ 
                var nameValue=splittedAttribs[i].split(":"); 
                var name=nameValue[0].replace(/\s*$/, "").replace(/^\s*/, "").toLowerCase();
                var value=nameValue[1].replace(/\s*$/, "").replace(/^\s*/, "");
                switch(name){
                        case "opacity":
                                dojo.html.setOpacity(node, value); 
                                break; 
                        case "content-height":
                                dojo.html.setContentBox(node, {height: value}); 
                                break; 
                        case "content-width":
                                dojo.html.setContentBox(node, {width: value}); 
                                break; 
                        case "outer-height":
                                dojo.html.setMarginBox(node, {height: value}); 
                                break; 
                        case "outer-width":
                                dojo.html.setMarginBox(node, {width: value}); 
                                break; 
                        default:
                                node.style[dojo.html.toCamelCase(name)]=value; 
                }
        } 
}

dojo.html.boxSizing = {
        MARGIN_BOX: "margin-box",
        BORDER_BOX: "border-box",
        PADDING_BOX: "padding-box",
        CONTENT_BOX: "content-box"
};

dojo.html.getAbsolutePosition = dojo.html.abs = function(/* HTMLElement */node, /* boolean? */includeScroll, /* string? */boxType){
        //      summary
        //      Gets the absolute position of the passed element based on the document itself.
        node = dojo.byId(node, node.ownerDocument);
        var ret = {
                x: 0,
                y: 0
        };

        var bs = dojo.html.boxSizing;
        if(!boxType) { boxType = bs.CONTENT_BOX; }
        var nativeBoxType = 2; //BORDER box
        var targetBoxType;
        switch(boxType){
                case bs.MARGIN_BOX:
                        targetBoxType = 3;
                        break;
                case bs.BORDER_BOX:
                        targetBoxType = 2;
                        break;
                case bs.PADDING_BOX:
                default:
                        targetBoxType = 1;
                        break;
                case bs.CONTENT_BOX:
                        targetBoxType = 0;
                        break;
        }

        var h = dojo.render.html;
        var db = document["body"]||document["documentElement"];

        if(h.ie){
                with(node.getBoundingClientRect()){
                        ret.x = left-2;
                        ret.y = top-2;
                }
        }else if(document.getBoxObjectFor){
                // mozilla
                nativeBoxType = 1; //getBoxObjectFor return padding box coordinate
                try{
                        var bo = document.getBoxObjectFor(node);
                        ret.x = bo.x - dojo.html.sumAncestorProperties(node, "scrollLeft");
                        ret.y = bo.y - dojo.html.sumAncestorProperties(node, "scrollTop");
                }catch(e){
                        // squelch
                }
        }else{
                if(node["offsetParent"]){
                        var endNode;
                        // in Safari, if the node is an absolutely positioned child of
                        // the body and the body has a margin the offset of the child
                        // and the body contain the body's margins, so we need to end
                        // at the body
                        if(     (h.safari)&&
                                (node.style.getPropertyValue("position") == "absolute")&&
                                (node.parentNode == db)){
                                endNode = db;
                        }else{
                                endNode = db.parentNode;
                        }

                        //TODO: set correct nativeBoxType for safari/konqueror

                        if(node.parentNode != db){
                                var nd = node;
                                if(dojo.render.html.opera){ nd = db; }
                                ret.x -= dojo.html.sumAncestorProperties(nd, "scrollLeft");
                                ret.y -= dojo.html.sumAncestorProperties(nd, "scrollTop");
                        }
                        var curnode = node;
                        do{
                                var n = curnode["offsetLeft"];
                                //FIXME: ugly hack to workaround the submenu in 
                                //popupmenu2 does not shown up correctly in opera. 
                                //Someone have a better workaround?
                                if(!h.opera || n>0){
                                        ret.x += isNaN(n) ? 0 : n;
                                }
                                var m = curnode["offsetTop"];
                                ret.y += isNaN(m) ? 0 : m;
                                curnode = curnode.offsetParent;
                        }while((curnode != endNode)&&(curnode != null));
                }else if(node["x"]&&node["y"]){
                        ret.x += isNaN(node.x) ? 0 : node.x;
                        ret.y += isNaN(node.y) ? 0 : node.y;
                }
        }

        // account for document scrolling!
        if(includeScroll){
                var scroll = dojo.html.getScroll();
                ret.y += scroll.top;
                ret.x += scroll.left;
        }

        var extentFuncArray=[dojo.html.getPaddingExtent, dojo.html.getBorderExtent, dojo.html.getMarginExtent];
        if(nativeBoxType > targetBoxType){
                for(var i=targetBoxType;i<nativeBoxType;++i){
                        ret.y += extentFuncArray[i](node, 'top');
                        ret.x += extentFuncArray[i](node, 'left');
                }
        }else if(nativeBoxType < targetBoxType){
                for(var i=targetBoxType;i>nativeBoxType;--i){
                        ret.y -= extentFuncArray[i-1](node, 'top');
                        ret.x -= extentFuncArray[i-1](node, 'left');
                }
        }
        ret.top = ret.y;
        ret.left = ret.x;
        return ret;     //      object
}

dojo.html.isPositionAbsolute = function(/* HTMLElement */node){
        //      summary
        //      Returns true if the element is absolutely positioned.
        return (dojo.html.getComputedStyle(node, 'position') == 'absolute');    //      boolean
}

dojo.html._sumPixelValues = function(/* HTMLElement */node, selectors, autoIsZero){
        var total = 0;
        for(var x=0; x<selectors.length; x++){
                total += dojo.html.getPixelValue(node, selectors[x], autoIsZero);
        }
        return total;
}

dojo.html.getMargin = function(/* HTMLElement */node){
        //      summary
        //      Returns the width and height of the passed node's margin
        return {
                width: dojo.html._sumPixelValues(node, ["margin-left", "margin-right"], (dojo.html.getComputedStyle(node, 'position') == 'absolute')),
                height: dojo.html._sumPixelValues(node, ["margin-top", "margin-bottom"], (dojo.html.getComputedStyle(node, 'position') == 'absolute'))
        };      //      object
}

dojo.html.getBorder = function(/* HTMLElement */node){
        //      summary
        //      Returns the width and height of the passed node's border
        return {
                width: dojo.html.getBorderExtent(node, 'left') + dojo.html.getBorderExtent(node, 'right'),
                height: dojo.html.getBorderExtent(node, 'top') + dojo.html.getBorderExtent(node, 'bottom')
        };      //      object
}

dojo.html.getBorderExtent = function(/* HTMLElement */node, /* string */side){
        //      summary
        //      returns the width of the requested border
        return (dojo.html.getStyle(node, 'border-' + side + '-style') == 'none' ? 0 : dojo.html.getPixelValue(node, 'border-' + side + '-width'));      // integer
}

dojo.html.getMarginExtent = function(/* HTMLElement */node, /* string */side){
        //      summary
        //      returns the width of the requested margin
        return dojo.html._sumPixelValues(node, ["margin-" + side], dojo.html.isPositionAbsolute(node)); //      integer
}

dojo.html.getPaddingExtent = function(/* HTMLElement */node, /* string */side){
        //      summary
        //      Returns the width of the requested padding 
        return dojo.html._sumPixelValues(node, ["padding-" + side], true);      //      integer
}

dojo.html.getPadding = function(/* HTMLElement */node){
        //      summary
        //      Returns the width and height of the passed node's padding
        return {
                width: dojo.html._sumPixelValues(node, ["padding-left", "padding-right"], true),
                height: dojo.html._sumPixelValues(node, ["padding-top", "padding-bottom"], true)
        };      //      object
}

dojo.html.getPadBorder = function(/* HTMLElement */node){
        //      summary
        //      Returns the width and height of the passed node's padding and border
        var pad = dojo.html.getPadding(node);
        var border = dojo.html.getBorder(node);
        return { width: pad.width + border.width, height: pad.height + border.height }; //      object
}

dojo.html.getBoxSizing = function(/* HTMLElement */node){
        //      summary
        //      Returns which box model the passed element is working with
        var h = dojo.render.html;
        var bs = dojo.html.boxSizing;
        if(((h.ie)||(h.opera)) && node.nodeName.toLowerCase() != "img"){ 
                var cm = document["compatMode"];
                if((cm == "BackCompat")||(cm == "QuirksMode")){
                        return bs.BORDER_BOX;   //      string
                }else{
                        return bs.CONTENT_BOX;  //      string
                }
        }else{
                if(arguments.length == 0){ node = document.documentElement; }
                var sizing;
                if(!h.ie){
                        sizing = dojo.html.getStyle(node, "-moz-box-sizing");
                        if(!sizing){ 
                                sizing = dojo.html.getStyle(node, "box-sizing");
                        }
                }
                return (sizing ? sizing : bs.CONTENT_BOX);      //      string
        }
}

dojo.html.isBorderBox = function(/* HTMLElement */node){
        //      summary
        //      returns whether the passed element is using border box sizing or not.
        return (dojo.html.getBoxSizing(node) == dojo.html.boxSizing.BORDER_BOX);        //      boolean
}

dojo.html.getBorderBox = function(/* HTMLElement */node){
        //      summary
        //      Returns the dimensions of the passed element based on border-box sizing.
        node = dojo.byId(node);
        return { width: node.offsetWidth, height: node.offsetHeight };  //      object
}

dojo.html.getPaddingBox = function(/* HTMLElement */node){
        //      summary
        //      Returns the dimensions of the padding box (see http://www.w3.org/TR/CSS21/box.html)
        var box = dojo.html.getBorderBox(node);
        var border = dojo.html.getBorder(node);
        return {
                width: box.width - border.width,
                height:box.height - border.height
        };      //      object
}

dojo.html.getContentBox = function(/* HTMLElement */node){
        //      summary
        //      Returns the dimensions of the content box (see http://www.w3.org/TR/CSS21/box.html)
        node = dojo.byId(node);
        var padborder = dojo.html.getPadBorder(node);
        return {
                width: node.offsetWidth - padborder.width,
                height: node.offsetHeight - padborder.height
        };      //      object
}

dojo.html.setContentBox = function(/* HTMLElement */node, /* object */args){
        //      summary
        //      Sets the dimensions of the passed node according to content sizing.
        node = dojo.byId(node);
        var width = 0; var height = 0;
        var isbb = dojo.html.isBorderBox(node);
        var padborder = (isbb ? dojo.html.getPadBorder(node) : { width: 0, height: 0});
        var ret = {};
        if(typeof args.width != "undefined"){
                width = args.width + padborder.width;
                ret.width = dojo.html.setPositivePixelValue(node, "width", width);
        }
        if(typeof args.height != "undefined"){
                height = args.height + padborder.height;
                ret.height = dojo.html.setPositivePixelValue(node, "height", height);
        }
        return ret;     //      object
}

dojo.html.getMarginBox = function(/* HTMLElement */node){
        //      summary
        //      returns the dimensions of the passed node including any margins.
        var borderbox = dojo.html.getBorderBox(node);
        var margin = dojo.html.getMargin(node);
        return { width: borderbox.width + margin.width, height: borderbox.height + margin.height };     //      object
}

dojo.html.setMarginBox = function(/* HTMLElement */node, /* object */args){
        //      summary
        //      Sets the dimensions of the passed node using margin box calcs.
        node = dojo.byId(node);
        var width = 0; var height = 0;
        var isbb = dojo.html.isBorderBox(node);
        var padborder = (!isbb ? dojo.html.getPadBorder(node) : { width: 0, height: 0 });
        var margin = dojo.html.getMargin(node);
        var ret = {};
        if(typeof args.width != "undefined"){
                width = args.width - padborder.width;
                width -= margin.width;
                ret.width = dojo.html.setPositivePixelValue(node, "width", width);
        }
        if(typeof args.height != "undefined"){
                height = args.height - padborder.height;
                height -= margin.height;
                ret.height = dojo.html.setPositivePixelValue(node, "height", height);
        }
        return ret;     //      object
}

dojo.html.getElementBox = function(/* HTMLElement */node, /* string */type){
        //      summary
        //      return dimesions of a node based on the passed box model type.
        var bs = dojo.html.boxSizing;
        switch(type){
                case bs.MARGIN_BOX:
                        return dojo.html.getMarginBox(node);    //      object
                case bs.BORDER_BOX:
                        return dojo.html.getBorderBox(node);    //      object
                case bs.PADDING_BOX:
                        return dojo.html.getPaddingBox(node);   //      object
                case bs.CONTENT_BOX:
                default:
                        return dojo.html.getContentBox(node);   //      object
        }
}
// in: coordinate array [x,y,w,h] or dom node
// return: coordinate object
dojo.html.toCoordinateObject = dojo.html.toCoordinateArray = function(/* array */coords, /* boolean? */includeScroll, /* string? */boxtype) {
        //      summary
        //      Converts an array of coordinates into an object of named arguments.
        if(coords instanceof Array || typeof coords == "array"){
                dojo.deprecated("dojo.html.toCoordinateArray", "use dojo.html.toCoordinateObject({left: , top: , width: , height: }) instead", "0.5");
                // coords is already an array (of format [x,y,w,h]), just return it
                while ( coords.length < 4 ) { coords.push(0); }
                while ( coords.length > 4 ) { coords.pop(); }
                var ret = {
                        left: coords[0],
                        top: coords[1],
                        width: coords[2],
                        height: coords[3]
                };
        }else if(!coords.nodeType && !(coords instanceof String || typeof coords == "string") &&
                         ('width' in coords || 'height' in coords || 'left' in coords ||
                          'x' in coords || 'top' in coords || 'y' in coords)){
                // coords is a coordinate object or at least part of one
                var ret = {
                        left: coords.left||coords.x||0,
                        top: coords.top||coords.y||0,
                        width: coords.width||0,
                        height: coords.height||0
                };
        }else{
                // coords is an dom object (or dom object id); return it's coordinates
                var node = dojo.byId(coords);
                var pos = dojo.html.abs(node, includeScroll, boxtype);
                var marginbox = dojo.html.getMarginBox(node);
                var ret = {
                        left: pos.left,
                        top: pos.top,
                        width: marginbox.width,
                        height: marginbox.height
                };
        }
        ret.x = ret.left;
        ret.y = ret.top;
        return ret;     //      object
}

dojo.html.setMarginBoxWidth = dojo.html.setOuterWidth = function(node, width){
        return dojo.html._callDeprecated("setMarginBoxWidth", "setMarginBox", arguments, "width");
}
dojo.html.setMarginBoxHeight = dojo.html.setOuterHeight = function(){
        return dojo.html._callDeprecated("setMarginBoxHeight", "setMarginBox", arguments, "height");
}
dojo.html.getMarginBoxWidth = dojo.html.getOuterWidth = function(){
        return dojo.html._callDeprecated("getMarginBoxWidth", "getMarginBox", arguments, null, "width");
}
dojo.html.getMarginBoxHeight = dojo.html.getOuterHeight = function(){
        return dojo.html._callDeprecated("getMarginBoxHeight", "getMarginBox", arguments, null, "height");
}
dojo.html.getTotalOffset = function(node, type, includeScroll){
        return dojo.html._callDeprecated("getTotalOffset", "getAbsolutePosition", arguments, null, type);
}
dojo.html.getAbsoluteX = function(node, includeScroll){
        return dojo.html._callDeprecated("getAbsoluteX", "getAbsolutePosition", arguments, null, "x");
}
dojo.html.getAbsoluteY = function(node, includeScroll){
        return dojo.html._callDeprecated("getAbsoluteY", "getAbsolutePosition", arguments, null, "y");
}
dojo.html.totalOffsetLeft = function(node, includeScroll){
        return dojo.html._callDeprecated("totalOffsetLeft", "getAbsolutePosition", arguments, null, "left");
}
dojo.html.totalOffsetTop = function(node, includeScroll){
        return dojo.html._callDeprecated("totalOffsetTop", "getAbsolutePosition", arguments, null, "top");
}
dojo.html.getMarginWidth = function(node){
        return dojo.html._callDeprecated("getMarginWidth", "getMargin", arguments, null, "width");
}
dojo.html.getMarginHeight = function(node){
        return dojo.html._callDeprecated("getMarginHeight", "getMargin", arguments, null, "height");
}
dojo.html.getBorderWidth = function(node){
        return dojo.html._callDeprecated("getBorderWidth", "getBorder", arguments, null, "width");
}
dojo.html.getBorderHeight = function(node){
        return dojo.html._callDeprecated("getBorderHeight", "getBorder", arguments, null, "height");
}
dojo.html.getPaddingWidth = function(node){
        return dojo.html._callDeprecated("getPaddingWidth", "getPadding", arguments, null, "width");
}
dojo.html.getPaddingHeight = function(node){
        return dojo.html._callDeprecated("getPaddingHeight", "getPadding", arguments, null, "height");
}
dojo.html.getPadBorderWidth = function(node){
        return dojo.html._callDeprecated("getPadBorderWidth", "getPadBorder", arguments, null, "width");
}
dojo.html.getPadBorderHeight = function(node){
        return dojo.html._callDeprecated("getPadBorderHeight", "getPadBorder", arguments, null, "height");
}
dojo.html.getBorderBoxWidth = dojo.html.getInnerWidth = function(){
        return dojo.html._callDeprecated("getBorderBoxWidth", "getBorderBox", arguments, null, "width");
}
dojo.html.getBorderBoxHeight = dojo.html.getInnerHeight = function(){
        return dojo.html._callDeprecated("getBorderBoxHeight", "getBorderBox", arguments, null, "height");
}
dojo.html.getContentBoxWidth = dojo.html.getContentWidth = function(){
        return dojo.html._callDeprecated("getContentBoxWidth", "getContentBox", arguments, null, "width");
}
dojo.html.getContentBoxHeight = dojo.html.getContentHeight = function(){
        return dojo.html._callDeprecated("getContentBoxHeight", "getContentBox", arguments, null, "height");
}
dojo.html.setContentBoxWidth = dojo.html.setContentWidth = function(node, width){
        return dojo.html._callDeprecated("setContentBoxWidth", "setContentBox", arguments, "width");
}
dojo.html.setContentBoxHeight = dojo.html.setContentHeight = function(node, height){
        return dojo.html._callDeprecated("setContentBoxHeight", "setContentBox", arguments, "height");
}

dojo.provide("dojo.lfx.html");








dojo.lfx.html._byId = function(nodes){
        if(!nodes){ return []; }
        if(dojo.lang.isArrayLike(nodes)){
                if(!nodes.alreadyChecked){
                        var n = [];
                        dojo.lang.forEach(nodes, function(node){
                                n.push(dojo.byId(node));
                        });
                        n.alreadyChecked = true;
                        return n;
                }else{
                        return nodes;
                }
        }else{
                var n = [];
                n.push(dojo.byId(nodes));
                n.alreadyChecked = true;
                return n;
        }
}

dojo.lfx.html.propertyAnimation = function(     /*DOMNode[]*/ nodes, 
                                                                                        /*Object[]*/ propertyMap, 
                                                                                        /*int*/ duration,
                                                                                        /*function*/ easing,
                                                                                        /*Object*/ handlers){
        // summary: Returns an animation that will transition the properties of "nodes"
        //                      depending how they are defined in "propertyMap".
        // nodes: An array of DOMNodes or one DOMNode.
        // propertyMap: { property: String, start: Decimal?, end: Decimal?, units: String? }
        //                              An array of objects defining properties to change.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? }
        nodes = dojo.lfx.html._byId(nodes);

        var targs = {
                "propertyMap": propertyMap,
                "nodes": nodes,
                "duration": duration,
                "easing": easing||dojo.lfx.easeDefault
        };
        
        var setEmUp = function(args){
                if(args.nodes.length==1){
                        // FIXME: we're only supporting start-value filling when one node is
                        // passed
                        
                        var pm = args.propertyMap;
                        if(!dojo.lang.isArray(args.propertyMap)){
                                // it's stupid to have to pack an array with a set of objects
                                // when you can just pass in an object list
                                var parr = [];
                                for(var pname in pm){
                                        pm[pname].property = pname;
                                        parr.push(pm[pname]);
                                }
                                pm = args.propertyMap = parr;
                        }
                        dojo.lang.forEach(pm, function(prop){
                                if(dj_undef("start", prop)){
                                        if(prop.property != "opacity"){
                                                prop.start = parseInt(dojo.html.getComputedStyle(args.nodes[0], prop.property));
                                        }else{
                                                prop.start = dojo.html.getOpacity(args.nodes[0]);
                                        }
                                }
                        });
                }
        }

        var coordsAsInts = function(coords){
                var cints = [];
                dojo.lang.forEach(coords, function(c){ 
                        cints.push(Math.round(c));
                });
                return cints;
        }

        var setStyle = function(n, style){
                n = dojo.byId(n);
                if(!n || !n.style){ return; }
                for(var s in style){
                        try{
                                if(s == "opacity"){
                                        dojo.html.setOpacity(n, style[s]);
                                }else{
                                                n.style[s] = style[s];
                                }
                        }catch(e){ dojo.debug(e); }
                }
        }

        var propLine = function(properties){
                this._properties = properties;
                this.diffs = new Array(properties.length);
                dojo.lang.forEach(properties, function(prop, i){
                        // calculate the end - start to optimize a bit
                        if(dojo.lang.isFunction(prop.start)){
                                prop.start = prop.start(prop, i);
                        }
                        if(dojo.lang.isFunction(prop.end)){
                                prop.end = prop.end(prop, i);
                        }
                        if(dojo.lang.isArray(prop.start)){
                                // don't loop through the arrays
                                this.diffs[i] = null;
                        }else if(prop.start instanceof dojo.gfx.color.Color){
                                // save these so we don't have to call toRgb() every getValue() call
                                prop.startRgb = prop.start.toRgb();
                                prop.endRgb = prop.end.toRgb();
                        }else{
                                this.diffs[i] = prop.end - prop.start;
                        }
                }, this);

                this.getValue = function(n){
                        var ret = {};
                        dojo.lang.forEach(this._properties, function(prop, i){
                                var value = null;
                                if(dojo.lang.isArray(prop.start)){
                                        // FIXME: what to do here?
                                }else if(prop.start instanceof dojo.gfx.color.Color){
                                        value = (prop.units||"rgb") + "(";
                                        for(var j = 0 ; j < prop.startRgb.length ; j++){
                                                value += Math.round(((prop.endRgb[j] - prop.startRgb[j]) * n) + prop.startRgb[j]) + (j < prop.startRgb.length - 1 ? "," : "");
                                        }
                                        value += ")";
                                }else{
                                        value = ((this.diffs[i]) * n) + prop.start + (prop.property != "opacity" ? prop.units||"px" : "");
                                }
                                ret[dojo.html.toCamelCase(prop.property)] = value;
                        }, this);
                        return ret;
                }
        }
        
        var anim = new dojo.lfx.Animation({
                        beforeBegin: function(){ 
                                setEmUp(targs); 
                                anim.curve = new propLine(targs.propertyMap);
                        },
                        onAnimate: function(propValues){
                                dojo.lang.forEach(targs.nodes, function(node){
                                        setStyle(node, propValues);
                                });
                        }
                },
                targs.duration, 
                null,
                targs.easing
        );
        if(handlers){
                for(var x in handlers){
                        if(dojo.lang.isFunction(handlers[x])){
                                anim.connect(x, anim, handlers[x]);
                        }
                }
        }
        
        return anim; // dojo.lfx.Animation
}

dojo.lfx.html._makeFadeable = function(nodes){
        var makeFade = function(node){
                if(dojo.render.html.ie){
                        // only set the zoom if the "tickle" value would be the same as the
                        // default
                        if( (node.style.zoom.length == 0) &&
                                (dojo.html.getStyle(node, "zoom") == "normal") ){
                                // make sure the node "hasLayout"
                                // NOTE: this has been tested with larger and smaller user-set text
                                // sizes and works fine
                                node.style.zoom = "1";
                                // node.style.zoom = "normal";
                        }
                        // don't set the width to auto if it didn't already cascade that way.
                        // We don't want to f anyones designs
                        if(     (node.style.width.length == 0) &&
                                (dojo.html.getStyle(node, "width") == "auto") ){
                                node.style.width = "auto";
                        }
                }
        }
        if(dojo.lang.isArrayLike(nodes)){
                dojo.lang.forEach(nodes, makeFade);
        }else{
                makeFade(nodes);
        }
}

dojo.lfx.html.fade = function(/*DOMNode[]*/ nodes,
                                                          /*Object*/values,
                                                          /*int?*/ duration,
                                                          /*Function?*/ easing,
                                                          /*Function?*/ callback){
        // summary:Returns an animation that will fade the "nodes" from the start to end values passed.
        // nodes: An array of DOMNodes or one DOMNode.
        // values: { start: Decimal?, end: Decimal? }
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var props = { property: "opacity" };
        if(!dj_undef("start", values)){
                props.start = values.start;
        }else{
                props.start = function(){ return dojo.html.getOpacity(nodes[0]); };
        }

        if(!dj_undef("end", values)){
                props.end = values.end;
        }else{
                dojo.raise("dojo.lfx.html.fade needs an end value");
        }

        var anim = dojo.lfx.propertyAnimation(nodes, [ props ], duration, easing);
        anim.connect("beforeBegin", function(){
                dojo.lfx.html._makeFadeable(nodes);
        });
        if(callback){
                anim.connect("onEnd", function(){ callback(nodes, anim); });
        }

        return anim; // dojo.lfx.Animation
}

dojo.lfx.html.fadeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will fade "nodes" from its current opacity to fully opaque.
        // nodes: An array of DOMNodes or one DOMNode.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        return dojo.lfx.html.fade(nodes, { end: 1 }, duration, easing, callback); // dojo.lfx.Animation
}

dojo.lfx.html.fadeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will fade "nodes" from its current opacity to fully transparent.
        // nodes: An array of DOMNodes or one DOMNode.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.       
        return dojo.lfx.html.fade(nodes, { end: 0 }, duration, easing, callback); // dojo.lfx.Animation
}

dojo.lfx.html.fadeShow = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will fade "nodes" from transparent to opaque and shows
        //                      "nodes" at the end if it is hidden.
        // nodes: An array of DOMNodes or one DOMNode.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.       
        nodes=dojo.lfx.html._byId(nodes);
        dojo.lang.forEach(nodes, function(node){
                dojo.html.setOpacity(node, 0.0);
        });

        var anim = dojo.lfx.html.fadeIn(nodes, duration, easing, callback);
        anim.connect("beforeBegin", function(){ 
                if(dojo.lang.isArrayLike(nodes)){
                        dojo.lang.forEach(nodes, dojo.html.show);
                }else{
                        dojo.html.show(nodes);
                }
        });

        return anim; // dojo.lfx.Animation
}

dojo.lfx.html.fadeHide = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will fade "nodes" from its current opacity to opaque and hides
        //                      "nodes" at the end.
        // nodes: An array of DOMNodes or one DOMNode.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        var anim = dojo.lfx.html.fadeOut(nodes, duration, easing, function(){
                if(dojo.lang.isArrayLike(nodes)){
                        dojo.lang.forEach(nodes, dojo.html.hide);
                }else{
                        dojo.html.hide(nodes);
                }
                if(callback){ callback(nodes, anim); }
        });
        
        return anim; // dojo.lfx.Animation
}

dojo.lfx.html.wipeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will show and wipe in "nodes".
        // nodes: An array of DOMNodes or one DOMNode.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var anims = [];

        dojo.lang.forEach(nodes, function(node){
                var oprop = {  };       // old properties of node (before we mucked w/them)
                
                // get node height, either it's natural height or it's height specified via style or class attributes
                // (for FF, the node has to be (temporarily) rendered to measure height)
                // TODO: should this offscreen code be part of dojo.html, so that getBorderBox() works on hidden nodes?
                var origTop, origLeft, origPosition;
                with(node.style){
                        origTop=top; origLeft=left; origPosition=position;
                        top="-9999px"; left="-9999px"; position="absolute";
                        display="";
                }
                var nodeHeight = dojo.html.getBorderBox(node).height;
                with(node.style){
                        top=origTop; left=origLeft; position=origPosition;
                        display="none";
                }

                var anim = dojo.lfx.propertyAnimation(node,
                        {       "height": {
                                        start: 1, // 0 causes IE to display the whole panel
                                        end: function(){ return nodeHeight; } 
                                }
                        }, 
                        duration, 
                        easing);
        
                anim.connect("beforeBegin", function(){
                        oprop.overflow = node.style.overflow;
                        oprop.height = node.style.height;
                        with(node.style){
                                overflow = "hidden";
                                height = "1px"; // 0 causes IE to display the whole panel
                        }
                        dojo.html.show(node);
                });
                
                anim.connect("onEnd", function(){ 
                        with(node.style){
                                overflow = oprop.overflow;
                                height = oprop.height;
                        }
                        if(callback){ callback(node, anim); }
                });
                anims.push(anim);
        });
        
        return dojo.lfx.combine(anims); // dojo.lfx.Combine
}

dojo.lfx.html.wipeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will wipe out and hide "nodes".
        // nodes: An array of DOMNodes or one DOMNode.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var anims = [];
        
        dojo.lang.forEach(nodes, function(node){
                var oprop = {  };       // old properties of node (before we mucked w/them)
                var anim = dojo.lfx.propertyAnimation(node,
                        {       "height": {
                                        start: function(){ return dojo.html.getContentBox(node).height; },
                                        end: 1 // 0 causes IE to display the whole panel
                                } 
                        },
                        duration,
                        easing,
                        {
                                "beforeBegin": function(){
                                        oprop.overflow = node.style.overflow;
                                        oprop.height = node.style.height;
                                        with(node.style){
                                                overflow = "hidden";
                                        }
                                        dojo.html.show(node);
                                },
                                
                                "onEnd": function(){ 
                                        dojo.html.hide(node);
                                        with(node.style){
                                                overflow = oprop.overflow;
                                                height = oprop.height;
                                        }
                                        if(callback){ callback(node, anim); }
                                }
                        }
                );
                anims.push(anim);
        });

        return dojo.lfx.combine(anims); // dojo.lfx.Combine
}

dojo.lfx.html.slideTo = function(/*DOMNode*/ nodes,
                                                                 /*Object*/ coords,
                                                                 /*int?*/ duration,
                                                                 /*Function?*/ easing,
                                                                 /*Function?*/ callback){
        // summary: Returns an animation that will slide "nodes" from its current position to
        //                      the position defined in "coords".
        // nodes: An array of DOMNodes or one DOMNode.
        // coords: { top: Decimal?, left: Decimal? }
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var anims = [];
        var compute = dojo.html.getComputedStyle;
        
        if(dojo.lang.isArray(coords)){
                /* coords: Array
                   pId: a */
                dojo.deprecated('dojo.lfx.html.slideTo(node, array)', 'use dojo.lfx.html.slideTo(node, {top: value, left: value});', '0.5');
                coords = { top: coords[0], left: coords[1] };
        }
        dojo.lang.forEach(nodes, function(node){
                var top = null;
                var left = null;
                
                var init = (function(){
                        var innerNode = node;
                        return function(){
                                var pos = compute(innerNode, 'position');
                                top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0);
                                left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0);

                                if (!dojo.lang.inArray(['absolute', 'relative'], pos)) {
                                        var ret = dojo.html.abs(innerNode, true);
                                        dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;");
                                        top = ret.y;
                                        left = ret.x;
                                }
                        }
                })();
                init();
                
                var anim = dojo.lfx.propertyAnimation(node,
                        {       "top": { start: top, end: (coords.top||0) },
                                "left": { start: left, end: (coords.left||0)  }
                        },
                        duration,
                        easing,
                        { "beforeBegin": init }
                );

                if(callback){
                        anim.connect("onEnd", function(){ callback(nodes, anim); });
                }

                anims.push(anim);
        });
        
        return dojo.lfx.combine(anims); // dojo.lfx.Combine
}

dojo.lfx.html.slideBy = function(/*DOMNode*/ nodes, /*Object*/ coords, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
        // summary: Returns an animation that will slide "nodes" from its current position
        //                      to its current position plus the numbers defined in "coords".
        // nodes: An array of DOMNodes or one DOMNode.
        // coords: { top: Decimal?, left: Decimal? }
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var anims = [];
        var compute = dojo.html.getComputedStyle;

        if(dojo.lang.isArray(coords)){
                /* coords: Array
                   pId: a */
                dojo.deprecated('dojo.lfx.html.slideBy(node, array)', 'use dojo.lfx.html.slideBy(node, {top: value, left: value});', '0.5');
                coords = { top: coords[0], left: coords[1] };
        }

        dojo.lang.forEach(nodes, function(node){
                var top = null;
                var left = null;
                
                var init = (function(){
                        var innerNode = node;
                        return function(){
                                var pos = compute(innerNode, 'position');
                                top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0);
                                left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0);

                                if (!dojo.lang.inArray(['absolute', 'relative'], pos)) {
                                        var ret = dojo.html.abs(innerNode, true);
                                        dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;");
                                        top = ret.y;
                                        left = ret.x;
                                }
                        }
                })();
                init();
                
                var anim = dojo.lfx.propertyAnimation(node,
                        {
                                "top": { start: top, end: top+(coords.top||0) },
                                "left": { start: left, end: left+(coords.left||0) }
                        },
                        duration,
                        easing).connect("beforeBegin", init);

                if(callback){
                        anim.connect("onEnd", function(){ callback(nodes, anim); });
                }

                anims.push(anim);
        });

        return dojo.lfx.combine(anims); // dojo.lfx.Combine
}

dojo.lfx.html.explode = function(/*DOMNode*/ start,
                                                                 /*DOMNode*/ endNode,
                                                                 /*int?*/ duration,
                                                                 /*Function?*/ easing,
                                                                 /*Function?*/ callback){
        // summary: Returns an animation that will 
        // start:
        // endNode:
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        var h = dojo.html;
        start = dojo.byId(start);
        endNode = dojo.byId(endNode);
        var startCoords = h.toCoordinateObject(start, true);
        var outline = document.createElement("div");
        h.copyStyle(outline, endNode);
        if(endNode.explodeClassName){ outline.className = endNode.explodeClassName; }
        with(outline.style){
                position = "absolute";
                display = "none";
                // border = "1px solid black";
                var backgroundStyle = h.getStyle(start, "background-color");
                backgroundColor = backgroundStyle ? backgroundStyle.toLowerCase() : "transparent";
                backgroundColor = (backgroundColor == "transparent") ? "rgb(221, 221, 221)" : backgroundColor;
        }
        dojo.body().appendChild(outline);

        with(endNode.style){
                visibility = "hidden";
                display = "block";
        }
        var endCoords = h.toCoordinateObject(endNode, true);
        with(endNode.style){
                display = "none";
                visibility = "visible";
        }

        var props = { opacity: { start: 0.5, end: 1.0 } };
        dojo.lang.forEach(["height", "width", "top", "left"], function(type){
                props[type] = { start: startCoords[type], end: endCoords[type] }
        });
        
        var anim = new dojo.lfx.propertyAnimation(outline, 
                props,
                duration,
                easing,
                {
                        "beforeBegin": function(){
                                h.setDisplay(outline, "block");
                        },
                        "onEnd": function(){
                                h.setDisplay(endNode, "block");
                                outline.parentNode.removeChild(outline);
                        }
                }
        );

        if(callback){
                anim.connect("onEnd", function(){ callback(endNode, anim); });
        }
        return anim; // dojo.lfx.Animation
}

dojo.lfx.html.implode = function(/*DOMNode*/ startNode,
                                                                 /*DOMNode*/ end,
                                                                 /*int?*/ duration,
                                                                 /*Function?*/ easing,
                                                                 /*Function?*/ callback){
        // summary: Returns an animation that will 
        // startNode:
        // end:
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        var h = dojo.html;
        startNode = dojo.byId(startNode);
        end = dojo.byId(end);
        var startCoords = dojo.html.toCoordinateObject(startNode, true);
        var endCoords = dojo.html.toCoordinateObject(end, true);

        var outline = document.createElement("div");
        dojo.html.copyStyle(outline, startNode);
        if (startNode.explodeClassName) { outline.className = startNode.explodeClassName; }
        dojo.html.setOpacity(outline, 0.3);
        with(outline.style){
                position = "absolute";
                display = "none";
                backgroundColor = h.getStyle(startNode, "background-color").toLowerCase();
        }
        dojo.body().appendChild(outline);

        var props = { opacity: { start: 1.0, end: 0.5 } };
        dojo.lang.forEach(["height", "width", "top", "left"], function(type){
                props[type] = { start: startCoords[type], end: endCoords[type] }
        });
        
        var anim = new dojo.lfx.propertyAnimation(outline,
                props,
                duration,
                easing,
                {
                        "beforeBegin": function(){
                                dojo.html.hide(startNode);
                                dojo.html.show(outline);
                        },
                        "onEnd": function(){
                                outline.parentNode.removeChild(outline);
                        }
                }
        );

        if(callback){
                anim.connect("onEnd", function(){ callback(startNode, anim); });
        }
        return anim; // dojo.lfx.Animation
}

dojo.lfx.html.highlight = function(/*DOMNode[]*/ nodes,
                                                                   /*dojo.gfx.color.Color*/ startColor,
                                                                   /*int?*/ duration,
                                                                   /*Function?*/ easing,
                                                                   /*Function?*/ callback){
        // summary: Returns an animation that will set the background color
        //                      of "nodes" to startColor and transition it to "nodes"
        //                      original color.
        // startColor: Color to transition from.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var anims = [];

        dojo.lang.forEach(nodes, function(node){
                var color = dojo.html.getBackgroundColor(node);
                var bg = dojo.html.getStyle(node, "background-color").toLowerCase();
                var bgImage = dojo.html.getStyle(node, "background-image");
                var wasTransparent = (bg == "transparent" || bg == "rgba(0, 0, 0, 0)");
                while(color.length > 3) { color.pop(); }

                var rgb = new dojo.gfx.color.Color(startColor);
                var endRgb = new dojo.gfx.color.Color(color);

                var anim = dojo.lfx.propertyAnimation(node, 
                        { "background-color": { start: rgb, end: endRgb } }, 
                        duration, 
                        easing,
                        {
                                "beforeBegin": function(){ 
                                        if(bgImage){
                                                node.style.backgroundImage = "none";
                                        }
                                        node.style.backgroundColor = "rgb(" + rgb.toRgb().join(",") + ")";
                                },
                                "onEnd": function(){ 
                                        if(bgImage){
                                                node.style.backgroundImage = bgImage;
                                        }
                                        if(wasTransparent){
                                                node.style.backgroundColor = "transparent";
                                        }
                                        if(callback){
                                                callback(node, anim);
                                        }
                                }
                        }
                );

                anims.push(anim);
        });
        return dojo.lfx.combine(anims); // dojo.lfx.Combine
}

dojo.lfx.html.unhighlight = function(/*DOMNode[]*/ nodes,
                                                                         /*dojo.gfx.color.Color*/ endColor,
                                                                         /*int?*/ duration,
                                                                         /*Function?*/ easing,
                                                                         /*Function?*/ callback){
        // summary: Returns an animation that will transition "nodes" background color
        //                      from its current color to "endColor".
        // endColor: Color to transition to.
        // duration: Duration of the animation in milliseconds.
        // easing: An easing function.
        // callback: Function to run at the end of the animation.
        nodes = dojo.lfx.html._byId(nodes);
        var anims = [];

        dojo.lang.forEach(nodes, function(node){
                var color = new dojo.gfx.color.Color(dojo.html.getBackgroundColor(node));
                var rgb = new dojo.gfx.color.Color(endColor);

                var bgImage = dojo.html.getStyle(node, "background-image");
                
                var anim = dojo.lfx.propertyAnimation(node, 
                        { "background-color": { start: color, end: rgb } },
                        duration, 
                        easing,
                        {
                                "beforeBegin": function(){ 
                                        if(bgImage){
                                                node.style.backgroundImage = "none";
                                        }
                                        node.style.backgroundColor = "rgb(" + color.toRgb().join(",") + ")";
                                },
                                "onEnd": function(){ 
                                        if(callback){
                                                callback(node, anim);
                                        }
                                }
                        }
                );
                anims.push(anim);
        });
        return dojo.lfx.combine(anims); // dojo.lfx.Combine
}

dojo.lang.mixin(dojo.lfx, dojo.lfx.html);

dojo.kwCompoundRequire({
        browser: ["dojo.lfx.html"],
        dashboard: ["dojo.lfx.html"]
});
dojo.provide("dojo.lfx.*");