source: Dev/branches/rest-dojo-ui/client/dojox/jq.js @ 274

//For jQuery 1.3.2

dojo.provide("dojox.jq");
dojo.require("dojo.NodeList-traverse");
dojo.require("dojo.NodeList-manipulate");
dojo.require("dojo.io.script");

/*
To get jquery tests to pass:
- add spaces between span>form selectors, other ones like one,two
- .last() instead of :last
- $("<div>").find("#foo") does not work unless the div is attached to the body.

- trigger .test not work
- No jquery.Event thing.

- jQuery.ajax() modifies incoming arguments?
- test framework not good for our io methods, async, poll.
- Dojo ajax is async: we fire ajaxStop more than jquery.

- jquery makes assumptions of a value to set for an element
by inserting an element and checking display. Does not seem to
account for nested styles, only captures generic tag name style off
of body. Why can't we just set display to empty?





OK for failures:
- test("jQuery.ajax - beforeSend, cancel request (#2688)"
  We cancel the deferred which triggers error and complete callbacks.


Looked at jquery code for:
- how it handled text(): did not use textContent/innerText, but use recursive look over childNodes and nodeValue,
so it may have impact on how <br> is serialized, but it has uniform behavior across browsers.
- Looked at trigger: how it triggered actions on dom nodes. This seemed unsafe.
*/

/*
dojo.query differences that cause some tests to fail:
- does not support XML queries
- $("#sap>form") does not find a match but $("#sap > form") does. Similar issue with comma instead of > (see is() tests)
- "$("form:last") should return the last form object, not if that particular form is that last related
  to its siblings? Same issue with :first?
- $("p").filter("#ap, #sndp"): filter does not work.
- dojo.NodeList uses d.NodeList a few places in the code. Would be nice to use a ctor that can be configured.
  That would make the filter function operate better.
- filterQueryResult, cannot handle queries like "p, div"? See andSelf test with parents().
- adjacent "p + p" not supported?
= a:only-child not supported?
- nth(1)
- even/odd
- eq/gt/lt
- #form :radio:checked does not run the first :radio psuedo selector? Seems to be a general issue where only the last pseud
  is run. For example, "#form :checked:radio" does only the radio pseudo.
*/

(function(){
        //Enable io topic publishing
        dojo.config.ioPublish = true;

        //Support stuff for toDom
        var selfClosedTags = "|img|meta|hr|br|input|";

        function toDom(/*String*/html, /*Document?*/doc){
                //summary converts HTML string into DOM nodes.
                //Make sure html is a string.
                html += "";

                //Convert <tag/> into <tag></tag>
                html = html.replace(/<\s*(\w+)([^\/\>]*)\/\s*>/g, function(tag, name, contents){
                        if(selfClosedTags.indexOf("|" + name + "|") == -1){
                                return "<" + name + contents + "></" + name + ">";
                        }else{
                                return tag;
                        }
                });

                return dojo._toDom(html, doc);
        }

        function cssNameToJs(name){
                var index = name.indexOf("-");
                if(index != -1){
                        //Strip off beginning dash
                        if(index == 0){
                                name = name.substring(1);
                        }
                        name = name.replace(/-(\w)/g, function(match, match1){
                                return match1.toUpperCase();
                        });
                }
                return name;
        }

        var _old$ = dojo.global.$;
        var _oldJQuery = dojo.global.jQuery;

        var $ = dojo.global.$ = dojo.global.jQuery = function(){
                var arg = arguments[0];
                if(!arg){
                        return $._wrap([], null, $);
                }else if(dojo.isString(arg)){
                        if(arg.charAt(0) == "<"){
                                //String of html that needs nodes created.
                                arg = toDom(arg);
                                //If a DocumentFragment, convert to use its children
                                //since we want to treat all top level nodes as elements
                                //in the NodeList array.
                                if(arg.nodeType == 11){
                                        arg = arg.childNodes;
                                }else{
                                        return $._wrap([arg], null, $);
                                }
                                //Use end case of nodelist to finish work.
                        }else{
                                //Normal dojo.query selector.
                                //Switch out query's NodeList constructor to be our specialized
                                //NodeList constructor.
                                var listCtor = dojo._NodeListCtor;
                                dojo._NodeListCtor = $;

                                //If the second arg is one of our fake NodeLists then
                                //use the first parent for the call.
                                var arg2 = arguments[1];
                                if(arg2 && arg2._is$){
                                        arg2 = arg2[0];
                                }else if(dojo.isString(arg2)){
                                        arg2 = dojo.query(arg2)[0];
                                }

                                var nl = dojo.query.call(this, arg, arg2);
                                dojo._NodeListCtor = listCtor;
                                return nl;
                        }
                }else if(dojo.isFunction(arg)){
                        //The addOnLoad case
                        $.ready(arg);
                        return $;
                }else if(arg == document || arg == window){
                        //If the arg is the document or window,
                        //then just use it directly.
                        return $._wrap([arg], null, $);
                }else if(dojo.isArray(arg)){
                        //Input is a plain array.
                        //Filter out duplicates.
                        var ary = [];
                        for(var i = 0; i < arg.length; i++){
                                if(dojo.indexOf(ary, arg[i]) == -1){
                                        ary.push(arg[i]);
                                }
                        }
                        return $._wrap(arg, null, $);
                }else if("nodeType" in arg){
                        //A DOM Node
                        return $._wrap([arg], null, $);
                }

                //A native NodeList that does not conform to dojo.isArray().
                //Convert it to a workable array and create new NodeList.
                return $._wrap(dojo._toArray(arg), null, $);

        };

        //Set up plugin extension point.
        var nlProto = dojo.NodeList.prototype;

        //Need a delegate, because at least one method conflicts with jquery
        //API: attr(name) in jQuery only returns a single, first value, where
        //dojo.attr will return an array.
        var f = $.fn = $.prototype = dojo.delegate(nlProto);

        //_wrap is required for proper use in dojo.query, but the _adaptAs* methods
        //do not have to placed on $ -- they can be used directly off dojo.NodeList.
        $._wrap = dojo.NodeList._wrap;

        //Add in some pseudos selectors
        var headerRegExp = /^H\d/i;
        var pseudos = dojo.query.pseudos;
        dojo.mixin(pseudos, {
                has: function(name, condition){
                        return function(elem){
                                return $(condition, elem).length;
                        }
                },
                visible: function(name, condition){
                        return function(elem){
                                return dojo.style(elem, "visible") != "hidden" && dojo.style(elem, "display") != "none";
                        }
                },
                hidden: function(name, condition){
                        return function(elem){
                                return elem.type == "hidden" || dojo.style(elem, "visible") == "hidden" || dojo.style(elem, "display") == "none";
                        }
                },
                selected: function(name, condition){
                        return function(elem){
                                return elem.selected;
                        }
                },
                checked: function(name, condition){
                        return function(elem){
                                return elem.nodeName.toUpperCase() == "INPUT" && elem.checked;
                        }
                },
                disabled: function(name, condition){
                        return function(elem){
                                return elem.getAttribute("disabled");
                        }
                },
                enabled: function(name, condition){
                        return function(elem){
                                return !elem.getAttribute("disabled");
                        }
                },
                input: function(name, condition){
                        return function(elem){
                                var n = elem.nodeName.toUpperCase();
                                return n == "INPUT" || n == "SELECT" || n == "TEXTAREA" || n == "BUTTON";
                        }
                },
                button: function(name, condition){
                        return function(elem){
                                return (elem.nodeName.toUpperCase() == "INPUT" && elem.type == "button") || elem.nodeName.toUpperCase() == "BUTTON";
                        }
                },
                header: function(name, condition){
                        return function(elem){
                                return elem.nodeName.match(headerRegExp);
                        }
                }
                //TODO: implement :animated
        });


        //Add the input type selectors to pseudos
        var inputPseudos = {};
        dojo.forEach([
                "text", "password", "radio", "checkbox", "submit", "image", "reset", "file"
        ], function(type) {
                inputPseudos[type] = function(name, condition){
                        return function(elem){
                                return elem.nodeName.toUpperCase() == "INPUT" && elem.type == type;
                        }
                };
        });
        dojo.mixin(pseudos, inputPseudos);

        //Set up browser sniff.
        $.browser = {
                mozilla: dojo.isMoz,
                msie: dojo.isIE,
                opera: dojo.isOpera,
                safari: dojo.isSafari
        };
        $.browser.version = dojo.isIE || dojo.isMoz || dojo.isOpera || dojo.isSafari || dojo.isWebKit;
        
        //Map back into dojo
        //Hmm maybe this is not so good. Dojo
        //modules may still be holding on to old
        //dojo (example: the d._NodeListCtor in query.js)
        //dojo = dojo.mixin($, dojo);

        // Add $.ready
        $.ready = $.fn.ready = function(callback){
                dojo.addOnLoad(dojo.hitch(null, callback, $));
                return this;
        }

        //START jquery Core API methods
        //http://docs.jquery.com/Core
        f._is$ = true;
        f.size = function(){return this.length; };

        $.prop = function(node, propCheck){
                //TODO: not sure about this one, could not find the docs?
                if(dojo.isFunction(propCheck)){
                        return propCheck.call(node);
                }else{
                        return propCheck;
                }
        }

        $.className = {
                add: dojo.addClass,
                remove: dojo.removeClass,
                has: dojo.hasClass
        };

        $.makeArray = function(thing){
                if(typeof thing == "undefined"){
                        return [];
                }else if(thing.length && !dojo.isString(thing) && !("location" in thing)){
                        //Location check was for excluding window objects that have a length.
                        return dojo._toArray(thing);
                }else{
                        return [thing];
                }
        }
        
        $.merge = function(ary1, ary2){
                //Alters first array by adding in the element.
                var args = [ary1.length, 0];
                args = args.concat(ary2);
                ary1.splice.apply(ary1, args);
                return ary1;
        }

        $.each = function(/*Array||ArrayLike*/list, /*Function*/cb){
                //each differs from dojo.NodeList.forEach in that
                //"this" is the current cycled node. Breaking
                //the loop is also possible. Also, index is first arg
                //to the callback.
                if(dojo.isArrayLike(list)){
                        for(var i = 0; i < list.length; i++){
                                if(cb.call(list[i], i, list[i]) === false){
                                        break;
                                }
                        }
                }else if(dojo.isObject(list)){
                        for(var param in list){
                                if(cb.call(list[param], param, list[param]) === false){
                                        break;
                                }
                        }
                }
                return this;
        };
        f.each = function(/*Function*/cb){
                return $.each.call(this, this, cb);
        };
        //f.length already implemented by NodeList
        f.eq = function(){
                //Direct copy of dojo.NodeList.at, but want
                //to use our NodeList class.
                var nl = $();
                dojo.forEach(arguments, function(i) { if(this[i]) { nl.push(this[i]); } }, this);
                return nl; // dojo.NodeList
        };
        f.get = function(/*Number*/index){
                if(index || index == 0){
                        return this[index];
                }
                return this;
        };
        f.index = function(arg){
                //Hmm, allows passing in a $ nodelist. Apparently in that
                //case take the first item in that array and match
                if(arg._is$){
                        arg = arg[0];
                }
                return this.indexOf(arg);
        }

        //.data implementation
        var dataStore = [];
        var dataId = 0;
        var dataAttr = dojo._scopeName + "DataId";
        
        var getDataId = function(node){
                var id = node.getAttribute(dataAttr);
                if(!id){
                        id = dataId++;
                        node.setAttribute(dataAttr, id);
                }
        }
        
        var getData = function(node){
                var data = {};
                if(node.nodeType == 1){
                        var id = getDataId(node);
                        data = dataStore[id];
                        if(!data){
                                data = dataStore[id] = {};
                        }
                }
                return data;
        }

        $.data = function(/*DOMNode*/node, /*String*/name, /*String*/value){
                var result = null;
                if(name == "events"){
                        //Special case "events", since jquery tests seem to use it to
                        //get the event handler storage for jquery. So for jquery apps
                        //"events" is probably a reserved word anyway.
                        result = listeners[node.getAttribute(eventAttr)];
                        var isEmpty = true;
                        if(result){
                                for(var param in result){
                                        isEmpty = false;
                                        break;
                                }
                        }
                        return isEmpty ? null : result;
                }

                var data = getData(node);
                if(typeof value != "undefined"){
                        data[name] = value;
                }else{
                        result = data[name];
                }
                return value ? this : result;
        }

        $.removeData = function(/*DOMNode*/node, /*String*/name){
                var data = getData(node);
                delete data[name];
                if(node.nodeType == 1){
                        var isEmpty = true;
                        for(var param in data){
                                isEmpty = false;
                                break;
                        }
                        if(isEmpty){
                                node.removeAttribute(dataAttr);
                        }
                }
                return this;
        }

        f.data = function(/*String*/name, /*String*/value){
                var result = null;
                this.forEach(function(node){
                        result = $.data(node, name, value);
                });

                return value ? this : result;
        }

        f.removeData = function(/*String*/name){
                this.forEach(function(node){
                        $.removeData(node, name);
                });
                return this;
        }
        
        function jqMix(obj, props){
                //summary: an attempt at a mixin that follows
                //jquery's .extend rules. Seems odd. Not sure how
                //to resolve this with dojo.mixin and what the use
                //cases are for the jquery version.
                //Copying some code from dojo._mixin.
                if(obj == props){
                        return obj;
                }
                var tobj = {};
                for(var x in props){
                        // the "tobj" condition avoid copying properties in "props"
                        // inherited from Object.prototype.  For example, if obj has a custom
                        // toString() method, don't overwrite it with the toString() method
                        // that props inherited from Object.prototype
                        if((tobj[x] === undefined || tobj[x] != props[x]) && props[x] !== undefined && obj != props[x]){
                                if(dojo.isObject(obj[x]) && dojo.isObject(props[x])){
                                        if(dojo.isArray(props[x])){
                                                obj[x] = props[x];
                                        }else{
                                                obj[x] = jqMix(obj[x], props[x]);
                                        }
                                }else{
                                        obj[x] = props[x];
                                }
                        }
                }
                // IE doesn't recognize custom toStrings in for..in
                if(dojo.isIE && props){
                        var p = props.toString;
                        if(typeof p == "function" && p != obj.toString && p != tobj.toString &&
                                p != "\nfunction toString() {\n    [native code]\n}\n"){
                                        obj.toString = props.toString;
                        }
                }
                return obj; // Object
        }

        f.extend = function(){
                var args = [this];
                args = args.concat(arguments);
                return $.extend.apply($, args);
        }

        $.extend = function(){
                //Could have multiple args to mix in. Similar to dojo.mixin,
                //but has some different rules, and the mixins all get applied
                //to the first arg.
                var args = arguments, finalObj;
                for(var i = 0; i < args.length; i++){
                        var obj = args[i];
                        if(obj && dojo.isObject(obj)){
                                if(!finalObj){
                                        finalObj = obj;
                                }else{
                                        jqMix(finalObj, obj);
                                }
                        }
                }
                return finalObj;
        }

        $.noConflict = function(/*Boolean*/extreme){
                var me = $;
                dojo.global.$ = _old$;
                if(extreme){
                        dojo.global.jQuery = _oldJQuery;
                }
                return me;
        }
        //END jquery Core API methods
        
        //START jquery Attribute API methods
        //http://docs.jquery.com/Attributes
        f.attr = function(name, value){
                //The isObject tests below are to weed out where something
                //like a form node has an input called "action" but we really
                //want to get the attribute "action". But in general, favor
                //a property value over a DOM attribute value.
                if(arguments.length == 1 && dojo.isString(arguments[0])){
                        //The get case, return first match.
                        var first = this[0];
                        
                        //Weed out empty nodes
                        if(!first){
                                return null;
                        }

                        var arg = arguments[0];
                        //favor properties over attributes.
                        var attr = dojo.attr(first, arg);
                        var prop = first[arg];
                        if((arg in first) && !dojo.isObject(prop) && name != "href"){
                                return prop;
                        }else{
                                return attr || prop;
                        }
                }else if(dojo.isObject(name)){
                        //A setter, using an object.
                        for(var param in name){
                                this.attr(param, name[param]);
                        }
                        return this;
                }else{
                        //The setter case. Figure out if value is a function.
                        var isFunc = dojo.isFunction(value);
                        this.forEach(function(node, index){
                                var prop = node[name];
                                if((name in node) && !dojo.isObject(prop) && name != "href"){
                                        node[name] = (isFunc ? value.call(node, index) : value);
                                }else if(node.nodeType == 1){
                                        dojo.attr(node, name, (isFunc ? value.call(node, index) : value));
                                }
                        });
                        return this;
                }
        }

        f.removeAttr = function(name){
                this.forEach(function(node, index){
                        var prop = node[name];
                        if((name in node) && !dojo.isObject(prop) && name != "href"){
                                delete node[name];
                        }else if(node.nodeType == 1){
                                if(name == "class"){
                                        //TODO: push this fix into dojo.removeAttr
                                        node.removeAttribute(name);
                                }else{
                                        dojo.removeAttr(node, name);
                                }
                        }
                });
                return this;
        }

        //addClass, removeClass exist in dojo.NodeList. toggleClass in jQuery case
        //just means add/remove the classname if it missing/exists. So need custom override.
        f.toggleClass = function(/*String*/name, /*Expression?*/condition){
                var hasCondition = arguments.length > 1;
                this.forEach(function(node){
                        dojo.toggleClass(node, name,  hasCondition ? condition : !dojo.hasClass(node, name));
                });
                return this;
        }

        //Action depends on arguments: if an array of functions do one thing,
        //If no args, do a display toggle,
        //If an expression, something that evaluates to true or false,
        //then toggle display accordingly.
        //If first arg is a String/Number, then do animation. Second arg
        //is an optional callback.
        f.toggle = function(){
                //If more than two args and we have a function as first arg, then
                //probably the onclick toggle variant: takes variable args that are
                //functions and cycles through them on click actions.
                var args = arguments;
                if(arguments.length > 1 && dojo.isFunction(arguments[0])){
                        var index = 0;
                        var func = function(){
                                var result = args[index].apply(this, arguments);
                                index += 1;
                                if(index > args.length - 1){
                                        index = 0;
                                }
                        };
                        return this.bind("click", func);
                }else{
                        //The display/hide/show case.
                        var condition = arguments.length == 1 ? arguments[0] : undefined;
                        this.forEach(function(node){
                                var result = typeof condition == "undefined" ? dojo.style(node, "display") == "none" : condition;
                                var action = (result ? "show" : "hide");
                                var nl = $(node);
                                nl[action].apply(nl, args);
                        });
                        return this;
                }
        }

        //hasClass just returns true if any of the nodes has the class.
        f.hasClass = function(/*String*/name){
                return this.some(function(node){
                        return dojo.hasClass(node, name);
                });
        }

        //use the html method from dojo.NodeList-manipulate.
        f.html = f.innerHTML;

        //END jquery Attribute API methods

        
        //START jquery Traversing API methods
        //http://docs.jquery.com/Traversing
        dojo.forEach(["filter", "slice"], function(item){
                f[item] = function(){
                        //Convert the "this" value for functions passed in:
                        var nl;
                        if(dojo.isFunction(arguments[0])){
                                var origFunc = arguments[0];
                                arguments[0] = function(item, index){
                                        return origFunc.call(item, item, index);
                                }
                        }
                        
                        if(item == "filter" && dojo.isString(arguments[0])){
                                var nl = this._filterQueryResult(this, arguments[0]);
                        }else{
                                var oldCtor = dojo._NodeListCtor;
                                dojo._NodeListCtor = f;
                                //Need to wrap in a $() call since internally some
                                //dojo.NodeList functions reference dojo.NodeList directly.
                                //Need to get a configurable constructor for dojo.NodeList.
                                nl = $(nlProto[item].apply(this, arguments));
                                dojo._NodeListCtor = oldCtor;
                        }

                        return nl._stash(this);
                }
        });

        f.map = function(/*Function*/callback){
                //Hmm, this is not like array map/dojo.map where you get one item back for
                //each input.
                return this._buildArrayFromCallback(callback);
        }
        $.map = function(/*Array*/ary, /*Function*/callback){
                //Hmm, this is not like array map/dojo.map where you get one item back for
                //each input.
                return f._buildArrayFromCallback.call(ary, callback);
        }

        $.inArray = function(value, /*Array*/ary){
                return dojo.indexOf(ary, value);
        }

        f.is = function(query){
                return (query ? !!this.filter(query).length : false);
        }

        //TODO: probably a better way to do this.
        f.not = function(){
                var notList = $.apply($, arguments);
                //TODO: another place where if dojo.NodeList can configure a constructor,
                //then we could avoid the $() wrapper below.
                var nl = $(nlProto.filter.call(this, function(node){
                        return notList.indexOf(node) == -1;
                }));
                return nl._stash(this);
        }

        f.add = function(){
                return this.concat.apply(this, arguments);
        }

        function iframeDoc(/*DOMNode*/iframeNode){
                //summary: Returns the document object associated with the iframe DOM Node argument.
                //Taken from dojo.io.iframe.doc(). Needed for contents() function below.
                var doc = iframeNode.contentDocument || // W3
                        (
                                (
                                        (iframeNode.name) && (iframeNode.document) &&
                                        (document.getElementsByTagName("iframe")[iframeNode.name].contentWindow) &&
                                        (document.getElementsByTagName("iframe")[iframeNode.name].contentWindow.document)
                                )
                        ) ||  // IE
                        (
                                (iframeNode.name)&&(document.frames[iframeNode.name])&&
                                (document.frames[iframeNode.name].document)
                        ) || null;
                return doc;
        }

        f.contents = function(){
                var ary = [];
                this.forEach(function(node){
                        if(node.nodeName.toUpperCase() == "IFRAME"){
                                var doc = iframeDoc(node);
                                if(doc){
                                        ary.push(doc);
                                }
                        }else{
                                //TODO: code similar to children() function. Refactor?
                                var children = node.childNodes;
                                //Using for loop for better speed.
                                for(var i = 0; i < children.length; i++){
                                        ary.push(children[i]);
                                }
                        }
                });
                return this._wrap(ary)._stash(this);
        }

        f.find = function(/*String*/query){
                var ary = [];
                this.forEach(function(node){
                        if(node.nodeType == 1){
                                ary = ary.concat(dojo._toArray($(query, node)));
                        }
                });
                return this._getUniqueAsNodeList(ary)._stash(this);
        }

        f.andSelf = function(){
                return this.add(this._parent);
        }

        //END jquery Traversing API methods

        //START jquery Manipulation API methods
        //http://docs.jquery.com/Manipulation

        f.remove = function(/*String?*/query){
                //Override NodeList-manipulate's remove so we can remove data.
                var nl = (query ? this._filterQueryResult(this, query) : this);
                
                //Remove data
                nl.removeData();
                
                //Remove event listeners.
                //TODO! do this, once event stuff is built out.
                
                //Remove the items from the DOM, but keep them in this
                //node list.
                nl.forEach(function(node){
                        node.parentNode.removeChild(node);
                });
                
                return this;
        }

        //START jquery CSS API methods
        //http://docs.jquery.com/CSS
        $.css = function(/*DOMNode*/node, /*String|Object*/name, /*String|Number?*/value){
                name = cssNameToJs(name);
                
                //Hmm, dojo.style does an arguments. length check.
                var result = (value ? dojo.style(node, name, value) : dojo.style(node, name));
                return result;
        }

        f.css = function(/*String|Object*/name, /*String|Number?*/value){
                if(dojo.isString(name)){
                        //Convert name to JS name if needed.
                        name = cssNameToJs(name);
                        if(arguments.length == 2){
                                //set the value. Cannot directly delegate to
                                //this.style, since non-element nodes may be in the mix?
                                //this.contents() in particular will return some funky stuff.
                                
                                //Need to be sure to add "px" if appropriate.
                                if(!dojo.isString(value) && name != "zIndex"){
                                        value = value + "px";
                                }

                                this.forEach(function(node){
                                        if(node.nodeType == 1){
                                                dojo.style(node, name, value);
                                        }
                                });
                                return this;
                        }else{
                                //return the value
                                value = dojo.style(this[0], name);
                                //Need to be sure to add "px" if appropriate.
                                if(!dojo.isString(value) && name != "zIndex"){
                                        value = value + "px";
                                }
                                return value;
                        }
                }else{
                        for(var param in name){
                                this.css(param, name[param]);
                        }
                        return this;
                }
        }
        
        function doBox(/*NodeList*/nl, /*String*/boxType, /*String*/prop, /*String||Number*/value){;
                if(value){
                        //Set height for all elements.
                        var mod = {};
                        mod[prop] = value;
                        nl.forEach(function(node){
                                dojo[boxType](node, mod);
                        });
                        return nl;
                }else{
                        //Just get first node's height.
                        //Hmm. width is negative when element is display none in FF3?
                        return Math.abs(Math.round(dojo[boxType](nl[0])[prop]));
                }
        }

        f.height = function(value){
                return doBox(this, "contentBox", "h", value);
        }

        f.width = function(value){
                return doBox(this, "contentBox", "w", value);
        }

        function getDimensions(/*DOMNode*/node, /*String*/type, /*Boolean*/usePadding, /*Boolean*/useBorder, /*Boolean*/useMargin){
                //summary: sums up the different parts of the width/height based on arguments.
                //If hidden, temporarily show it, do measurements then close.
                var rehide = false;
                if((rehide = node.style.display == "none")){
                        node.style.display = "block";
                }

                var cs = dojo.getComputedStyle(node);
                var content = Math.abs(Math.round(dojo._getContentBox(node, cs)[type]));
                var pad = usePadding ? Math.abs(Math.round(dojo._getPadExtents(node, cs)[type])) : 0;
                var border = useBorder ? Math.abs(Math.round(dojo._getBorderExtents(node, cs)[type])) : 0;
                var margin = useMargin ? Math.abs(Math.round(dojo._getMarginExtents(node, cs)[type])) : 0;
                
                if(rehide){
                        node.style.display = "none";
                }

                return pad + content + border + margin;
        }

        f.innerHeight = function(){
                return getDimensions(this[0], "h", true);
        }

        f.innerWidth = function(){
                return getDimensions(this[0], "w", true);
        }

        f.outerHeight = function(useMargin){
                return getDimensions(this[0], "h", true, true, useMargin);
        }

        f.outerWidth = function(useMargin){
                return getDimensions(this[0], "w", true, true, useMargin);
        }

        //END jquery CSS API methods


        //START jquery Events API methods
        //http://docs.jquery.com/Events
        
        //ready() already defined above.

        //Event plumbing.
        var listeners = [];
        var listenId = 1;
        var eventAttr = dojo._scopeName + "eventid";
        var currentEvtData;

        function getNonNamespacedName(/*String*/evtName){
                //summary: gets name of the event before the first ".".
                //The $$ stuff is special ids used to create unique names
                //for bound functions that did not have a unique namespace name.
                evtName = evtName.split("$$")[0];
                var dotIndex = evtName.indexOf(".");
                if(dotIndex != -1){
                        evtName = evtName.substring(0, dotIndex);
                }
                return evtName;
        }

        function domConnect(/*DOMNode*/node, /*String*/evtName){
                //summary: handles creating the connection with a real DOM event.
                //This work should only be done one time per evName type.
                //If the event if an ajax event, use dojo.subscribe instead.
                if(evtName.indexOf("ajax") == 0){
                        return dojo.subscribe(topics[evtName], function(dfd, res){
                                var fakeEvt = new $.Event(evtName);
                                if("ajaxComplete|ajaxSend|ajaxSuccess".indexOf(evtName) != -1){
                                        triggerHandlers(node, [fakeEvt, dfd.ioArgs.xhr, dfd.ioArgs.args]);
                                }else if(evtName == "ajaxError"){
                                        triggerHandlers(node, [fakeEvt, dfd.ioArgs.xhr, dfd.ioArgs.args, res]);
                                }else{
                                        //ajaxStart|ajaxStop
                                        triggerHandlers(node, [fakeEvt]);
                                }
                        });
                }else{
                        return dojo.connect(node, "on" + evtName, function(e){
                                triggerHandlers(node, arguments);
                        }); //Object
                }
        }

        //Event object for compatibility for some tests.
        $.Event = function(/*String*/type){
                //Allow for calling function without "new"
                if(this == $){
                        return new $.Event(type);
                }
                if(typeof type == "string"){
                        this.type = type.replace(/!/, "");
                }else{
                        dojo.mixin(this, type);
                }
                this.timeStamp = (new Date()).getTime();
                this._isFake = true;
                this._isStrict = (this.type.indexOf("!") != -1);
                
        }
        
        var ep = $.Event.prototype = {
                preventDefault: function(){
                        this.isDefaultPrevented = this._true;
                },
                stopPropagation: function(){
                        this.isPropagationStopped = this._true;
                },
                stopImmediatePropagation: function(){
                        this.isPropagationStopped = this._true;
                        this.isImmediatePropagationStopped = this._true;
                },
                _true: function(){ return true; },
                _false: function(){ return false; }
        }
        dojo.mixin(ep, {
                isPropagationStopped: ep._false,
                isImmediatePropagationStopped: ep._false,
                isDefaultPrevented: ep._false
        });

        function makeTriggerData(data, type){
                //summary: makes sure that the data array is copied
                //and has an event as the first arg. If this function generates
                //a fake event (known by the data[0]._isFake property being true)
                //then the data[0].target needs to be set by the consumer of this function.
                
                data = data || [];
                data = [].concat(data);

                //If first data item is not an event, make one up.
                //Need to set up target: prop in the consumers of this
                //function.
                var evt = data[0];
                if(!evt || !evt.preventDefault){
                        evt = type && type.preventDefault ? type : new $.Event(type);
                        data.unshift(evt);
                }
                return data;
        }
        
        var triggerHandlersCalled = false;

        function triggerHandlers(/*DOMNode*/node, /*Array*/data, /*Function?*/extraFunc){
                //summary: handles the actual callbacks to the handlers.
                
                //Indicate triggerHandlers was called.
                triggerHandlersCalled = true;
                
                //Uses currentEvtData if this is a simulated event.
                data = data || currentEvtData;
                extraFunc = extraFunc;

                //Normalize on a real element if dealing with a document.
                if(node.nodeType == 9){
                        node = node.documentElement;
                }

                var nodeId = node.getAttribute(eventAttr);
                if(!nodeId){
                        return;
                }

                var evt = data[0];
                var evtFullName = evt.type;
                var evtName = getNonNamespacedName(evtFullName);

                var cbs = listeners[nodeId][evtName];

                var result;
                //Apply the extra function. What is that about? Not mentioned in the
                //public APIs?
                if(extraFunc){
                        result = extraFunc.apply(node, data);
                }

                if (result !== false){
                        for(var param in cbs){
                                if(param != "_connectId" && (!evt._isStrict && (param.indexOf(evtFullName) == 0) || (evt._isStrict && param == evtFullName))){
                                        //Store the callback ID in case unbind is called with this event
                                        //so we can only unbind that one callback.
                                        evt[dojo._scopeName + "callbackId"] = param;

                                        var cb = cbs[param];
                                        if(typeof cb.data != "undefined"){
                                                evt.data = cb.data;
                                        }else{
                                                evt.data = null;
                                        }
        
                                        //Do the actual callback.
                                        if ((result = cb.fn.apply(evt.target, data)) === false && !evt._isFake){
                                                dojo.stopEvent(evt);
                                        }
                                        evt.result = result;
                                }
                        }
                }

                return result;
        }

        f.triggerHandler = function(/*String*/type, /*Array?*/data, /*Function?*/extraFunc){
                //Only triggers handlers on the first node. Huh.
                var node = this[0];
                if(node && node.nodeType != 3 && node.nodeType != 8){
                        data = makeTriggerData(data, type);
                        return triggerHandlers(node, data, extraFunc);
                }else{
                        return undefined;
                }
        }

        f.trigger = function(/*String*/type, /*Array?*/data, /*Function?*/extraFunc){
                //Copy data since we may need to modify by adding a
                data = makeTriggerData(data, type);
                var evt = data[0];
                var type = getNonNamespacedName(evt.type);
                
                //Store the current event data in case handlers need
                //to reference it because of a simulated event.
                currentEvtData = data;
                currentExtraFunc = extraFunc;

                var result = null;
                var needTarget = !evt.target;
                this.forEach(function(node){
                        //Only handle non text/comment nodes.
                        if(node.nodeType != 3 && node.nodeType != 8){

                                //Normalize on a real element if dealing with a document.
                                if(node.nodeType == 9){
                                        node = node.documentElement;
                                }

                                //Set the node target appropriately for fake events.
                                if(evt._isFake){
                                        evt.currentTarget = node;
                                        if(needTarget){
                                                evt.target = node;
                                        }
                                }

                                //Bizarre extra function thing. Not really demonstrated in public
                                //API docs.
                                if(extraFunc){
                                        var funcData = data.slice(1);
                                        result = extraFunc.apply(node, (result = null ? funcData : funcData.concat(result)));
                                }

                                if(result !== false){
                                        //Trigger DOM event. onclick is handled differently than
                                        //others.
                                        /*
                                        if(type == 'click' && node.onclick && node.nodeName.toUpperCase() == "A"){
                                                result = node.onclick.apply(node, data);
                                        }
                                        */
                                        
                                        //Set the "global" flag that indicates if triggerHandlers was called.
                                        //If the direct node.event/onevent does not trigger the handlers, do so
                                        //manually at the end.
                                        triggerHandlersCalled = false;
                                        
                                        //Trigger functions registered directly on the DOM node.
                                        if(node[type]){
                                                try{
                                                        result = node[type]();
                                                }catch(e){
                                                        //Apparently IE throws on some hidden elements. Just eat it.
                                                }
                                        }else if(node["on" + type]){
                                                try{
                                                        result = node["on" + type]();
                                                }catch(e){
                                                        //Apparently IE throws on some hidden elements. Just eat it.
                                                }
                                        }
                                        
                                        if(!triggerHandlersCalled){
                                                //Finally triggerHandlers directly if the above code did not trigger it yet.
                                                result = triggerHandlers(node, data);
                                        }

                                        //Bubble the event up.
                                        //TODO: optimize this path so we don't have to do forEach and NodeList work.
                                        var parentNode = node.parentNode;
                                        if(result !== false && !evt.isImmediatePropagationStopped() && !evt.isPropagationStopped() && parentNode && parentNode.nodeType == 1){
                                                $(parentNode).trigger(type, data, extraFunc);
                                        }
                                }
                        }
                });

                //Clear current event data.
                currentEvtData = null;
                currentExtraFunc = null;

                return this;
        }

        var bindIdCounter = 0;

        f.bind = function(/*String*/type, /*Array||Function?*/data, /*Function*/fn){
                //Type can be space separated values.
                type = type.split(" ");
                
                //May not have data argument.
                if(!fn){
                        fn = data;
                        data = null;
                }

                this.forEach(function(node){
                        //Only handle non text/comment nodes.
                        if(node.nodeType != 3 && node.nodeType != 8){
                        
                                //If document, bind to documentElement
                                if(node.nodeType == 9){
                                        node = node.documentElement;
                                }

                                //If no nodeId, then create one and attach it to the DOM node.
                                var nodeId = node.getAttribute(eventAttr);
                                if(!nodeId){
                                        nodeId = listenId++;
                                        node.setAttribute(eventAttr, nodeId);
                                        listeners[nodeId] = {};
                                }
        
                                //Process each event type.
                                for(var i = 0; i < type.length; i++){
                                        //Get event name, if have a dot on it, it is namespaced,
                                        //be sure to get the core event name.
                                        var evtFullName = type[i];
                                        var evtName = getNonNamespacedName(evtFullName);
                                        if(evtName == evtFullName){
                                                //Generate a unique ID for this function binding
                                                evtFullName = evtName + "$$" + (bindIdCounter++);
                                        }
        
                                        //Get the event listeners for the event name, the complete name.
                                        var lls = listeners[nodeId];
                                        if(!lls[evtName]){
                                                lls[evtName] = {
                                                        _connectId: domConnect(node, evtName)
                                                };
                                        }
        
                                        //Add the callback to the list of listeners.
                                        lls[evtName][evtFullName] = {
                                                fn: fn,
                                                data: data
                                        };
                                }
                        }
                });
                
                return this;
        }

        function copyEventHandlers(/*DOMNode*/ src, /*DOMNode*/ target){
                // summary:
                //              copies the event handlers from onne src *element* node to
                //              another target *element* node. Assumes that target had
                //              no previous events on it, and is a clone of the src node.

                //Get src listeners.
                var srcNodeId = target.getAttribute(eventAttr);
                var sls = listeners[srcNodeId];
                if(!sls){
                        return;
                }

                //Generate listeners area for target.
                var nodeId = nodeId = listenId++;
                target.setAttribute(eventAttr, nodeId);
                var tls = listeners[nodeId] = {};

                //Loope through events in source. Protect against bad
                //code modifying Object.prototype.
                var empty = {};
                for (var evtName in sls){
                        var tEvtData = tls[evtName] = {
                                _connectId: domConnect(target, evtName)
                        };
                        var sEvtData = sls[evtName];

                        for (var evtFullName in sEvtData){
                                tEvtData[evtFullName] = {
                                        fn: sEvtData[evtFullName].fn,
                                        data: sEvtData[evtFullName].data
                                };
                        }
                }
        }

        function listenerUnbind(lls, evtName, evtFullName, callbackId, fn){
                //Handles the real remove of an event and dojo.disconnects DOM handler if necessary.
                //This has to be broken out of the main unbind function because we have to support
                //things like unbind(".test") that go across major event names. Yuck.
                var handles = lls[evtName];
                if(handles){
                        var hasDot = evtFullName.indexOf(".") != -1;
                        var forceDelete = false;

                        if(callbackId){
                                //Only need to unbind that one callback
                                delete handles[callbackId];
                        }else if(!hasDot && !fn){
                                forceDelete = true;
                        }else if(hasDot){
                                //A namespaced event.
                                //Problem is the namespaced event could be something like
                                //".test" which means remove all that end in .test. Yuck.
                                if(evtFullName.charAt(0) == "."){
                                        for(var param in handles){
                                                if(param.indexOf(evtFullName) == param.length - evtFullName.length){
                                                        delete handles[param];
                                                }
                                        }
                                }else{
                                        delete handles[evtFullName];
                                }
                        }else{
                                //Not a namespaced event. Cycle through the $$ names
                                //to find a function match.
                                for(var param in handles){
                                        if(param.indexOf("$$") != -1 && handles[param].fn == fn){
                                                delete handles[param];
                                                break;
                                        }
                                }
                        }

                        //Remove handles/disconnect dom if no other params.
                        var allDone = true;
                        for(var param in handles){
                                if(param != "_connectId"){
                                        allDone = false;
                                        break;
                                }
                        }
                        if(forceDelete || allDone){
                                if(evtName.indexOf("ajax") != -1){
                                        dojo.unsubscribe(handles._connectId);
                                }else{
                                        dojo.disconnect(handles._connectId);
                                }
                                delete lls[evtName];
                        }
                }
        }

        f.unbind = function(/*String*/type, /*Function*/fn){
                
                //See if event has a callbackId, if so, then we only unbind
                //that one callback.
                var callbackId = type ? type[dojo._scopeName + "callbackId"] : null;

                //Type can be space separated values.
                type = type && type.type ? type.type : type;
                type = type ? type.split(" ") : type;

                this.forEach(function(node){
                        //Only handle non text/comment nodes.
                        if(node.nodeType != 3 && node.nodeType != 8){
                                //If document, bind to documentElement
                                if(node.nodeType == 9){
                                        node = node.documentElement;
                                }

                                //If no nodeId, then create one and attach it to the DOM node.
                                var nodeId = node.getAttribute(eventAttr);
                                
                                if(nodeId){
                                        //Get the event listeners for the event name, the complete name.
                                        var lls = listeners[nodeId];
                                        if(lls){
                                                //If no type, then it means do all bound types. Make a list of them.
                                                var etypes = type;
                                                if(!etypes){
                                                        etypes = [];
                                                        for(var param in lls){
                                                                etypes.push(param);
                                                        }
                                                }

                                                //Process each event type.
                                                for(var i = 0; i < etypes.length; i++){
                                                        //Get event name, if have a dot on it, it is namespaced,
                                                        //be sure to get the core event name.
                                                        var evtFullName = etypes[i];
                                                        var evtName = getNonNamespacedName(evtFullName);
                        
                                                        //Problem is the namespaced event could be something like
                                                        //".test" which means remove all that end in .test. Yuck.
                                                        if(evtFullName.charAt(0) == "."){
                                                                for(var param in lls) {
                                                                        listenerUnbind(lls, param, evtFullName, callbackId, fn);
                                                                }
                                                        }else{
                                                                listenerUnbind(lls, evtName, evtFullName, callbackId, fn);
                                                        }
                                                }
                                        }
                                }
                        }
                });

                return this;
        }

        f.one = function(/*String*/evtName, /*Function*/func){
                var oneFunc = function(){
                        $(this).unbind(evtName, arguments.callee);
                        return func.apply(this, arguments);
                }

                return this.bind(evtName, oneFunc);
        };

        f._cloneNode = function(/*DOMNode*/ src){
                // summary:
                //              private utiltity to clone a node. Copies event handlers too.
                var target = src.cloneNode(true);

                if(src.nodeType == 1){
                        //Look for event handlers in target.
                        var evNodes = dojo.query("[" + eventAttr + "]", target);
                        for(var i = 0, newNode; newNode = evNodes[i]; i++){
                                var oldNode = dojo.query('[' + eventAttr + '="' + newNode.getAttribute(eventAttr) + '"]', src)[0];
                                if(oldNode){
                                        copyEventHandlers(oldNode, newNode);
                                }
                        }
                }
                return target;
        };

        //Temporary testing shim to get past jquery test setup errors.
        dojo.getObject("$.event.global", true);

        //Set up event handlers
        dojo.forEach([
                "blur", "focus", "dblclick", "click", "error", "keydown", "keypress", "keyup", "load", "mousedown",
                "mouseenter", "mouseleave", "mousemove", "mouseout", "mouseover", "mouseup", "submit",
                "ajaxStart", "ajaxSend", "ajaxSuccess", "ajaxError", "ajaxComplete", "ajaxStop"
                ], function(evt){
                        f[evt] = function(callback){
                                if(callback){
                                        this.bind(evt, callback);
                                }else{
                                        this.trigger(evt);
                                }
                                return this;
                        }
                }
        );

        //END jquery Events API methods


        //START jquery Effects API methods
        //http://docs.jquery.com/Effects
        function speedInt(speed){
                //Fix speed setting, translate string values to numbers.
                if(dojo.isString(speed)){
                        if(speed == "slow"){
                                speed = 700;
                        }else if(speed = "fast"){
                                speed = 300;
                        }else{
                                //Everything else is considered normal speed.
                                speed = 500;
                        }
                }
                return speed;
        }
        
        f.hide = function(/*String||Number*/speed, /*Function?*/callback){
                //Fix speed setting, translate string values to numbers.
                speed = speedInt(speed);

                this.forEach(function(node){
                        var style = node.style;
                        
                        //Skip if already hidden
                        var cs = dojo.getComputedStyle(node);
                        if(cs.display == "none"){
                                return;
                        }

                        style.overflow = "hidden";
                        style.display = "block";
                        
                        if(speed){
                                //It is alive!
                                dojo.anim(
                                        node,
                                        {
                                                width: 0,
                                                height: 0,
                                                opacity: 0
                                        },
                                        speed,
                                        null,
                                        function(){
                                                style.width = "";
                                                style.height = "";
                                                style.display = "none";
                                                return callback && callback.call(node);
                                        }
                                );
                        }else{
                                //No need for animation, fast path it.
                                dojo.style(node, "display", "none");
                                if(callback){
                                        callback.call(node);
                                }
                        }
                });
                return this;
        }

        f.show = function(/*String||Number*/speed, /*Function?*/callback){
                //Fix speed setting, translate string values to numbers.
                speed = speedInt(speed);

                this.forEach(function(node){
                        var style = node.style;
                        //Skip if the node is already showing.
                        var cs = dojo.getComputedStyle(node);
                        if(cs.display != "none"){
                                return;
                        }

                        if(speed){
                                //Figure out size of element
                                //so we know when to stop animation.
                                //Try the easy path first.
                                var width = parseFloat(style.width);
                                var height = parseFloat(style.height);
                                if(!width || !height){
                                        //temporarily show the element to get
                                        //dimensions
                                        style.display = "block";
                                        var box = dojo.marginBox(node);
                                        width = box.w;
                                        height = box.h;
                                }

                                //Make sure values are set to hidden state.
                                style.width = 0;
                                style.height = 0;
                                style.overflow = "hidden";
                                dojo.attr(node, "opacity", 0);
                                style.display = "block";

                                //It is alive!
                                dojo.anim(
                                        node,
                                        {
                                                width: width,
                                                height: height,
                                                opacity: 1
                                        },
                                        speed,
                                        null,
                                        callback ? dojo.hitch(node, callback) : undefined
                                );
                        }else{
                                dojo.style(node, "display", "block");
                                if(callback){
                                        callback.call(node);
                                }
                        }
                });
                return this;
        }


        //END jquery Effects API methods


        //START jquery Ajax API methods
        //http://docs.jquery.com/Ajax
        
        $.ajaxSettings = {
        };

        $.ajaxSetup = function(/*Object*/args){
                dojo.mixin($.ajaxSettings, args);
        }

        var topics = {
                "ajaxStart": "/dojo/io/start",
                "ajaxSend": "/dojo/io/send",
                "ajaxSuccess": "/dojo/io/load",
                "ajaxError": "/dojo/io/error",
                "ajaxComplete": "/dojo/io/done",
                "ajaxStop": "/dojo/io/stop"
        };

        for(var fnName in topics){
                //Make sure we are dealing with properties
                //we care about and not something another toolkit added.
                if(fnName.indexOf("ajax") == 0){
                        ;(function(fnName){
                                f[fnName] = function(callback){
                                        this.forEach(function(node){
                                                dojo.subscribe(topics[fnName], function(){
                                                        var fakeEvt = new $.Event(fnName);
                                                        var ioArgs = arguments[0] && arguments[0].ioArgs;
                                                        var xhr = ioArgs && ioArgs.xhr;
                                                        var args = ioArgs && ioArgs.args;
                                                        var res = arguments[1];
                                                        if("ajaxComplete|ajaxSend|ajaxSuccess".indexOf(fnName) != -1){
                                                                return callback.call(node, fakeEvt, xhr, args);
                                                        }else if(fnName == "ajaxError"){
                                                                return callback.call(node, fakeEvt, xhr, args, res);
                                                        }else{
                                                                //ajaxStart|ajaxStop
                                                                return callback.call(node, fakeEvt);
                                                        }
                                                });
                                        });
                                        return this;
                                }
                        })(fnName);
                }
        };

        //Override dojo._xhrObj(dfd.ioArgs.args) to support beforeSend
        //Do not understand the reason for beforeSend, particularly
        //returning false stops the request.
        //WARNING: even with this code, the error and complete callbacks
        //will be fired because the deferred is cancelled. I feel this is
        //correct behavior for dojo, and not sure why beforeSend is needed.
        var _oldXhrObj = dojo._xhrObj;
        dojo._xhrObj = function(args){
                var xhr = _oldXhrObj.apply(dojo, arguments);
                if(args && args.beforeSend){
                        if(args.beforeSend(xhr) === false){
                                return false;
                        }
                }
                return xhr;
        }

        $.ajax = function(/*Object*/args){
                //Not sure if the args are considered mutable.
                //Copy them to be safe.
                var temp = dojo.delegate($.ajaxSettings);
                for(var param in args){
                        //For data objects merge the data do not overwrite.
                        if(param == "data" && dojo.isObject(args[param]) && dojo.isObject(temp.data)){
                                for(var prop in args[param]){
                                        temp.data[prop] = args[param][prop];
                                }
                        }else{
                                temp[param] = args[param];
                        }
                }
                args = temp;
                var url = args.url;

                if("async" in args){
                        args.sync = !args.async;
                }

                //Turn off topic publications
                if(args.global === false){
                        args.ioPublish = false;
                }

                if(args.data){
                        var data = args.data;
                        if(dojo.isString(data)){
                                //convert to an object.
                                args.content = dojo.queryToObject(data);
                        }else{
                                //data property values could be a function, be sure to call them if so.
                                //Hmm, this seems to be of dubious value.
                                for(var param in data){
                                        if(dojo.isFunction(data[param])){
                                                data[param] = data[param]();
                                        }
                                }
                                args.content = data;
                        }
                }

                //dataType
                var dataType = args.dataType;
                if("dataType" in args){
                        if(dataType == "script"){
                                dataType = "javascript";
                        }else if(dataType == "html"){
                                dataType = "text";
                        }
                        args.handleAs = dataType;
                }else{
                        //Make a guess based on the URL.
                        dataType = args.handleAs = "text";
                        args.guessedType = true;
                }

                //cache:
                if("cache" in args){
                        args.preventCache = !args.cache;
                }else{
                        if(args.dataType == "script" || args.dataType == "jsonp"){
                                args.preventCache = true;
                        }
                }

                //Hide error since dojo treats it different.
                if(args.error){
                        args._jqueryError = args.error;
                        delete args.error;
                }
                
                //TODO: dataFilter

                //Set up callbacks.
                args.handle = function(result, ioArgs){
                        var textStatus = "success";
                        if(result instanceof Error){
                                textStatus = (result.dojoType == "timeout" ? "timeout" : "error");
                                if(args._jqueryError){
                                        args._jqueryError(ioArgs.xhr, textStatus, result);
                                }
                        }else{
                                //If we guessed the type, see if it should be XML.
                                var xml = (ioArgs.args.guessedType && ioArgs.xhr && ioArgs.xhr.responseXML);
                                if(xml){
                                        result = xml;
                                }

                                if(args.success){
                                        args.success(result, textStatus, ioArgs.xhr);
                                }
                        }
                        if(args.complete){
                                args.complete(result, textStatus, ioArgs.xhr);
                        }
                        
                        return result;
                };
                
                //Use a script tag if the request is xdomain or a jsonp thing.
                var useScript = (dataType == "jsonp");
                if(dataType == "javascript"){
                        //Get protocol and domain.
                        var colonIndex = url.indexOf(":");
                        var slashIndex = url.indexOf("/");
                        if(colonIndex > 0 && colonIndex < slashIndex){
                                //Possibly xdomain. Peel off protocol and hostname to find out.
                                var lastSlash = url.indexOf("/", slashIndex + 2);
                                if(lastSlash == -1){
                                        lastSlash = url.length;
                                }
                                if(location.protocol != url.substring(0, colonIndex + 1) ||
                                        location.hostname != url.substring(slashIndex + 2, lastSlash)){
                                        useScript = true;
                                }
                        }
                }

                if(useScript){
                        if(dataType == "jsonp"){
                                //Look for callback param
                                var cb = args.jsonp;
                                if(!cb){
                                        //Look in the URL
                                        var params = args.url.split("?")[1];
                                        if(params && (params = dojo.queryToObject(params))){
                                                cb = findJsonpCallback(params);
                                                if(cb){
                                                        //Remove the cb from the url.
                                                        var regex = new RegExp("([&\\?])?" + cb + "=?");
                                                        args.url = args.url.replace(regex + "=?");
                                                }
                                        }
                                        //Look in the content.
                                        if(!cb){
                                                cb = findJsonpCallback(args.content);
                                                if(cb){
                                                        delete args.content[cb];
                                                }
                                        }
                                }
                                args.jsonp = cb || "callback";
                        }
                        var dfd = dojo.io.script.get(args);
                        return dfd;
                }else{
                        var dfd = dojo.xhr(args.type || "GET", args);
                        //If the XHR object is false, it means beforeSend canceled the request.
                        return dfd.ioArgs.xhr === false ? false : dfd.ioArgs.xhr;
                }
        }

        function findJsonpCallback(obj){
                for(var prop in obj){
                        if(prop.indexOf("callback") == prop.length - 8){
                                return prop;
                        }
                }
                return null;
        }
        
        $.getpost = function(httpType, url, data, callback, dataType){
                var args = {
                        url: url,
                        type: httpType
                };

                //Normalize data, considering it may be the real
                //callback.
                if(data){
                        if(dojo.isFunction(data) && !callback){
                                args.complete = data;
                        }else{
                                args.data = data;
                        }
                }

                //Normalize callback, considering it may be
                //the datatype.
                if(callback){
                        if(dojo.isString(callback) && !dataType){
                                dataType = callback;
                        }else{
                                args.complete = callback;
                        }
                }

                if(dataType){
                        args.dataType = dataType;
                }

                return $.ajax(args);
        };

        $.get = dojo.hitch($, "getpost", "GET");
        $.post = dojo.hitch($, "getpost", "POST");
        $.getJSON = function(url, data, callback){
                return $.getpost("GET", url, data, callback, "json");
        }
        $.getScript = function(url, callback){
                return $.ajax({
                        url: url,
                        success: callback,
                        dataType: "script"
                });
        }

        f.load = function(url, data, callback){
                
                //See if this is a window or document. If so, then want to
                //register onload handler.
                var node = this[0];
                if(!node || !node.nodeType || node.nodeType == 9){
                        dojo.addOnLoad(url);
                        return this;
                }

                //The rest of this function is the ajax HTML load case.
                //Pull off selector if it is on the url.
                var parts = url.split(/\s+/);
                url = parts[0];
                var query = parts[1];
                
                var finalCb = callback || data;

                var cb = dojo.hitch(this, function(result, textStatus, xhr){
                        //Try to find all the body content.
                        var match = result.match(/\<\s*body[^>]+>.*<\/body\s*>/i);
                        if(match){
                                result = match;
                        }

                        //Convert to DOM nodes.
                        var nodes = dojo._toDom(result);

                        //Apply query, using a temp div to do the filtering.
                        if(query){
                                var temp = $(dojo.create("div"));
                                temp.append(nodes);
                                nodes = temp.find(query);
                        }else{
                                nodes = $(nodes.nodeType == 11 ? nodes.childNodes : nodes);
                        }

                        //Add the HTML to all nodes in this node list.
                        this.html(nodes);

                        //Call the user's callback.
                        //Use a timeout to allow any embedded scripts that
                        //were just inserted to run.
                        if(finalCb){
                                setTimeout(dojo.hitch(this, function(){
                                        this.forEach(function(node){
                                                finalCb.call(node, result, textStatus, xhr);
                                        });
                                }), 10);
                        }
                });

                //Adjust parameters since they are variable.
                if(!callback){
                        data = cb;
                }else{
                        callback = cb;
                }

                //Set HTTP method. If the data is a string, use get, if it is an object,
                //use post.
                var method = "GET";
                if(data && dojo.isObject(data)){
                        method = "POST";
                }

                $.getpost(method, url, data, callback, "html");
                return this;
        }

        var serializeExclude = "file|submit|image|reset|button|";
        f.serialize = function(){
                var ret = "";
                var strs = this.map(function(node){
                        if(node.nodeName.toUpperCase() == "FORM"){
                                return dojo.formToQuery(node);
                        }else{
                                var type = (node.type||"").toLowerCase();
                                if(serializeExclude.indexOf(type) == -1){
                                        var val = dojo.fieldToObject(node);
                                        if(node.name && val != null){
                                                var q = {};
                                                q[node.name] = val;
                                                return dojo.objectToQuery(q);
                                        }
                                }
                        }
                });
                return ret + strs.join("&");
        }

        $.param = function(obj){
                if(obj._is$ && obj.serialize){
                        return obj.serialize();
                }else if(dojo.isArray(obj)){
                        return dojo.map(obj, function(item){
                                return $.param(item);
                        }).join("&");
                }else{
                        return dojo.objectToQuery(obj);
                }
        }
        
        //END jquery Ajax API methods

        //START jquery Utilities API methods
        //http://docs.jquery.com/Utilities
        //TODO:
        
        $.isFunction = function(){
                var result = dojo.isFunction.apply(dojo, arguments);
                //Make sure Object does not return true
                if(result){
                        result = (typeof(arguments[0]) != "object");
                }
                return result;
        }

        //END jquery Utilities API methods

        
})();