Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.html"] = true;
dojo.require("dojo._base.lang");
dojo.provide("dojo._base.html");

// FIXME: need to add unit tests for all the semi-public methods

try{
        document.execCommand("BackgroundImageCache", false, true);
}catch(e){
        // sane browsers don't have cache "issues"
}

// =============================
// DOM Functions
// =============================

/*=====
dojo.byId = function(id, 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: String|DOMNode
        //              DOM id or DOM Node
        //      doc: DocumentElement
        //              Document to work in. Defaults to the current value of
        //              dojo.doc.  Can be used to retreive
        //              node references from other documents.
=====*/
if(dojo.isIE || dojo.isOpera){
        dojo.byId = function(id, doc){
                if(dojo.isString(id)){
                        var _d = doc || dojo.doc;
                        var te = _d.getElementById(id);
                        // attributes.id.value is better than just id in case the 
                        // user has a name=id inside a form
                        if(te && te.attributes.id.value == id){
                                return te;
                        }else{
                                var eles = _d.all[id];
                                if(!eles){ return; }
                                if(!eles.length){ return eles; }
                                // if more than 1, choose first with the correct id
                                var i=0;
                                while((te=eles[i++])){
                                        if(te.attributes.id.value == id){ return te; }
                                }
                        }
                }else{
                        return id; // DomNode
                }
        }
}else{
        dojo.byId = function(id, doc){
                if(dojo.isString(id)){
                        return (doc || dojo.doc).getElementById(id);
                }else{
                        return id; // DomNode
                }
        }
}
/*=====
}
=====*/

(function(){
        /*
        dojo.createElement = function(obj, parent, position){
                // TODO: need to finish this!
        }
        */

        var _destroyContainer = null;
        dojo._destroyElement = function(/*String||DomNode*/node){
                // summary:
                //              removes node from its parent, clobbers it and all of its
                //              children.
                //      node:
                //              the element to be destroyed, either as an ID or a reference

                node = dojo.byId(node);
                try{
                        if(!_destroyContainer){
                                _destroyContainer = document.createElement("div");
                        }
                        _destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);
                        // NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature
                        _destroyContainer.innerHTML = ""; 
                }catch(e){
                        /* squelch */
                }
        };

        dojo.isDescendant = function(/*DomNode|String*/node, /*DomNode|String*/ancestor){
                //      summary:
                //              Returns true if node is a descendant of ancestor
                //      node: id or node reference to test
                //      ancestor: id or node reference of potential parent to test against
                try{
                        node = dojo.byId(node);
                        ancestor = dojo.byId(ancestor);
                        while(node){
                                if(node === ancestor){
                                        return true; // Boolean
                                }
                                node = node.parentNode;
                        }
                }catch(e){ return -1; /* squelch */ }
                return false; // Boolean
        };

        dojo.setSelectable = function(/*DomNode|String*/node, /*Boolean*/selectable){
                //      summary: enable or disable selection on a node
                //      node:
                //              id or reference to node
                //      selectable:
                node = dojo.byId(node);
                if(dojo.isMozilla){
                        node.style.MozUserSelect = selectable ? "" : "none";
                }else if(dojo.isKhtml){
                        node.style.KhtmlUserSelect = selectable ? "auto" : "none";
                }else if(dojo.isIE){
                        node.unselectable = selectable ? "" : "on";
                        dojo.query("*", node).forEach(function(descendant){
                                descendant.unselectable = selectable ? "" : "on";
                        });
                }
                //FIXME: else?  Opera?
        };

        var _insertBefore = function(/*Node*/node, /*Node*/ref){
                ref.parentNode.insertBefore(node, ref);
                return true;    //      boolean
        }

        var _insertAfter = function(/*Node*/node, /*Node*/ref){
                //      summary:
                //              Try to insert node after ref
                var pn = ref.parentNode;
                if(ref == pn.lastChild){
                        pn.appendChild(node);
                }else{
                        return _insertBefore(node, ref.nextSibling);    //      boolean
                }
                return true;    //      boolean
        }

        dojo.place = function(/*String|DomNode*/node, /*String|DomNode*/refNode, /*String|Number*/position){
                //      summary:
                //              attempt to insert node in relation to ref based on position
                //      node: 
                //              id or reference to node to place relative to refNode
                //      refNode: 
                //              id or reference of node to use as basis for placement
                //      position:
                //              string noting the position of node relative to refNode or a
                //              number indicating the location in the childNodes collection of
                //              refNode. Accepted string values are:
                //                      * before
                //                      * after
                //                      * first
                //                      * last
                //              "first" and "last" indicate positions as children of refNode.

                // FIXME: need to write tests for this!!!!
                if(!node || !refNode || position === undefined){ 
                        return false;   //      boolean 
                }
                node = dojo.byId(node);
                refNode = dojo.byId(refNode);
                if(typeof position == "number"){
                        var cn = refNode.childNodes;
                        if((position == 0 && cn.length == 0) ||
                                cn.length == position){
                                refNode.appendChild(node); return true;
                        }
                        if(position == 0){
                                return _insertBefore(node, refNode.firstChild);
                        }
                        return _insertAfter(node, cn[position-1]);
                }
                switch(position.toLowerCase()){
                        case "before":
                                return _insertBefore(node, refNode);    //      boolean
                        case "after":
                                return _insertAfter(node, refNode);             //      boolean
                        case "first":
                                if(refNode.firstChild){
                                        return _insertBefore(node, refNode.firstChild); //      boolean
                                }else{
                                        refNode.appendChild(node);
                                        return true;    //      boolean
                                }
                                break;
                        default: // aka: last
                                refNode.appendChild(node);
                                return true;    //      boolean
                }
        }

        // Box functions will assume this model.
        // On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
        // Can be set to change behavior of box setters.
        
        // can be either:
        //      "border-box"
        //      "content-box" (default)
        dojo.boxModel = "content-box";
        
        // We punt per-node box mode testing completely.
        // If anybody cares, we can provide an additional (optional) unit 
        // that overrides existing code to include per-node box sensitivity.

        // Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
        // but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
        // IIRC, earlier versions of Opera did in fact use border-box.
        // Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.

        if(dojo.isIE /*|| dojo.isOpera*/){
                var _dcm = document.compatMode;
                // client code may have to adjust if compatMode varies across iframes
                dojo.boxModel = (_dcm=="BackCompat")||(_dcm=="QuirksMode")||(dojo.isIE<6) ? "border-box" : "content-box";
        }

        // =============================
        // Style Functions
        // =============================
        
        // getComputedStyle drives most of the style code.
        // Wherever possible, reuse the returned object.
        //
        // API functions below that need to access computed styles accept an 
        // optional computedStyle parameter.
        //
        // If this parameter is omitted, the functions will call getComputedStyle themselves.
        //
        // This way, calling code can access computedStyle once, and then pass the reference to 
        // multiple API functions. 
        //
        // This is a faux declaration to take pity on the doc tool

/*=====
        dojo.getComputedStyle = function(node){
                //      summary:
                //              Returns a "computed style" object.
                //      description:
                //              get "computed style" object which can be used to gather
                //              information about the current state of the rendered node. 
                //
                //              Note that this may behave differently on different browsers.
                //              Values may have different formats and value encodings across
                //              browsers. 
                //
                //              Use the dojo.style() method for more consistent (pixelized)
                //              return values.
                //      node: DOMNode
                //              a reference to a DOM node. Does NOT support taking an
                //              ID string for speed reasons.
                //      example:
                //      |       dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
                return; // CSS2Properties
        }
=====*/

        var gcs, dv = document.defaultView;
        if(dojo.isSafari){
                gcs = function(/*DomNode*/node){
                        var s = dv.getComputedStyle(node, null);
                        if(!s && node.style){ 
                                node.style.display = ""; 
                                s = dv.getComputedStyle(node, null);
                        }
                        return s || {};
                }; 
        }else if(dojo.isIE){
                gcs = function(node){
                        return node.currentStyle;
                };
        }else{
                gcs = function(node){
                        return dv.getComputedStyle(node, null);
                };
        }
        dojo.getComputedStyle = gcs;

        if(!dojo.isIE){
                dojo._toPixelValue = function(element, value){
                        // style values can be floats, client code may want
                        // to round for integer pixels.
                        return parseFloat(value) || 0; 
                }
        }else{
                dojo._toPixelValue = function(element, avalue){
                        if(!avalue){ return 0; }
                        // on IE7, medium is usually 4 pixels
                        if(avalue=="medium"){ return 4; }
                        // style values can be floats, client code may
                        // want to round this value for integer pixels.
                        if(avalue.slice && (avalue.slice(-2)=='px')){ return parseFloat(avalue); }
                        with(element){
                                var sLeft = style.left;
                                var rsLeft = runtimeStyle.left;
                                runtimeStyle.left = currentStyle.left;
                                try{
                                        // 'avalue' may be incompatible with style.left, which can cause IE to throw
                                        // this has been observed for border widths using "thin", "medium", "thick" constants
                                        // those particular constants could be trapped by a lookup
                                        // but perhaps there are more
                                        style.left = avalue;
                                        avalue = style.pixelLeft;
                                }catch(e){
                                        avalue = 0;
                                }
                                style.left = sLeft;
                                runtimeStyle.left = rsLeft;
                        }
                        return avalue;
                }
        }

        // FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
        /*=====
        dojo._getOpacity = function(node){
                        //      summary:
                        //              Returns the current opacity of the passed node as a
                        //              floating-point value between 0 and 1.
                        //      node: DomNode
                        //              a reference to a DOM node. Does NOT support taking an
                        //              ID string for speed reasons.
                        //      return: Number between 0 and 1
        }
        =====*/

        dojo._getOpacity = (dojo.isIE ? function(node){
                        try{
                                return (node.filters.alpha.opacity / 100); // Number
                        }catch(e){
                                return 1; // Number
                        }
                } : function(node){
                        return dojo.getComputedStyle(node).opacity;
                }
        );

        /*=====
        dojo._setOpacity = function(node, opacity){
                        //      summary:
                        //              set the opacity of the passed node portably. Returns the
                        //              new opacity of the node.
                        //      node: DOMNode
                        //              a reference to a DOM node. Does NOT support taking an
                        //              ID string for performance reasons.
                        //      opacity: Number
                        //              A Number between 0 and 1. 0 specifies transparent.
                        //      return: Number between 0 and 1
        }
        =====*/

        dojo._setOpacity = (dojo.isIE ? function(/*DomNode*/node, /*Number*/opacity){
                        if(opacity == 1){
                                // on IE7 Alpha(Filter opacity=100) makes text look fuzzy so remove it altogether (bug #2661)
                                node.style.cssText = node.style.cssText.replace(/FILTER:[^;]*;/i, "");
                                if(node.nodeName.toLowerCase() == "tr"){
                                        dojo.query("> td", node).forEach(function(i){
                                                i.style.cssText = i.style.cssText.replace(/FILTER:[^;]*;/i, "");
                                        });
                                }
                        }else{
                                var o = "Alpha(Opacity="+(opacity*100)+")";
                                node.style.filter = o;
                        }
                        if(node.nodeName.toLowerCase() == "tr"){
                                dojo.query("> td", node).forEach(function(i){
                                        i.style.filter = o;
                                });
                        }
                        return opacity;
                } : function(node, opacity){
                        return node.style.opacity = opacity;
                }
        );

        var _pixelNamesCache = {
                width: true, height: true, left: true, top: true
        };
        var _toStyleValue = function(node, type, value){
                type = type.toLowerCase();
                if(_pixelNamesCache[type] === true){
                        return dojo._toPixelValue(node, value)
                }else if(_pixelNamesCache[type] === false){
                        return value;
                }else{
                        if(dojo.isOpera && type == "cssText"){
                                // FIXME: add workaround for #2855 here
                        }
                        if(
                                (type.indexOf("margin") >= 0) ||
                                // (type.indexOf("border") >= 0) ||
                                (type.indexOf("padding") >= 0) ||
                                (type.indexOf("width") >= 0) ||
                                (type.indexOf("height") >= 0) ||
                                (type.indexOf("max") >= 0) ||
                                (type.indexOf("min") >= 0) ||
                                (type.indexOf("offset") >= 0)
                        ){
                                _pixelNamesCache[type] = true;
                                return dojo._toPixelValue(node, value)
                        }else{
                                _pixelNamesCache[type] = false;
                                return value;
                        }
                }
        }

        // public API
        
        dojo.style = function(/*DomNode|String*/ node, /*String*/style, /*String?*/value){
                //      summary:
                //              gets or sets a style property on node. If 2 arguments are
                //              passed, acts as a getter. If value is passed, acts as a setter
                //              for the property.
                //      node:
                //              id or reference to node to get/set style for
                //      style:
                //              the style property to set in DOM-accessor format
                //              ("borderWidth", not "border-width").
                //      value:
                //              optional. If passed, sets value on the node for style, handling
                //              cross-browser concerns.
                var n=dojo.byId(node), args=arguments.length, op=(style=="opacity");
                if(args==3){
                        return op ? dojo._setOpacity(n, value) : n.style[style] = value; /*Number*/
                }
                if(args==2 && op){
                        return dojo._getOpacity(n);
                }
                var s = dojo.getComputedStyle(n);
                return (args == 1) ? s : _toStyleValue(n, style, s[style]); /* CSS2Properties||String||Number */
        }

        // =============================
        // Box Functions
        // =============================

        dojo._getPadExtents = function(/*DomNode*/n, /*Object*/computedStyle){
                //      summary:
                //              Returns object with special values specifically useful for node
                //              fitting.
                //                      l/t = left/top padding (respectively)
                //                      w = the total of the left and right padding 
                //                      h = the total of the top and bottom padding
                //              If 'node' has position, l/t forms the origin for child nodes. 
                //              The w/h are used for calculating boxes.
                //              Normally application code will not need to invoke this
                //              directly, and will use the ...box... functions instead.
                var 
                        s=computedStyle||gcs(n), 
                        px=dojo._toPixelValue,
                        l=px(n, s.paddingLeft), 
                        t=px(n, s.paddingTop);
                return { 
                        l: l,
                        t: t,
                        w: l+px(n, s.paddingRight),
                        h: t+px(n, s.paddingBottom)
                };
        }

        dojo._getBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){
                //      summary:
                //              returns an object with properties useful for noting the border
                //              dimensions.
                //                      l/t = the sum of left/top border (respectively)
                //                      w = the sum of the left and right border
                //                      h = the sum of the top and bottom border
                //              The w/h are used for calculating boxes.
                //              Normally application code will not need to invoke this
                //              directly, and will use the ...box... functions instead.
                var 
                        ne='none',
                        px=dojo._toPixelValue, 
                        s=computedStyle||gcs(n), 
                        bl=(s.borderLeftStyle!=ne ? px(n, s.borderLeftWidth) : 0),
                        bt=(s.borderTopStyle!=ne ? px(n, s.borderTopWidth) : 0);
                return { 
                        l: bl,
                        t: bt,
                        w: bl + (s.borderRightStyle!=ne ? px(n, s.borderRightWidth) : 0),
                        h: bt + (s.borderBottomStyle!=ne ? px(n, s.borderBottomWidth) : 0)
                };
        }

        dojo._getPadBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){
                //      summary:
                //              returns object with properties useful for box fitting with
                //              regards to padding.
                //                      l/t = the sum of left/top padding and left/top border (respectively)
                //                      w = the sum of the left and right padding and border
                //                      h = the sum of the top and bottom padding and border
                //              The w/h are used for calculating boxes.
                //              Normally application code will not need to invoke this
                //              directly, and will use the ...box... functions instead.
                var 
                        s=computedStyle||gcs(n), 
                        p=dojo._getPadExtents(n, s),
                        b=dojo._getBorderExtents(n, s);
                return { 
                        l: p.l + b.l,
                        t: p.t + b.t,
                        w: p.w + b.w,
                        h: p.h + b.h
                };
        }

        dojo._getMarginExtents = function(n, computedStyle){
                //      summary:
                //              returns object with properties useful for box fitting with
                //              regards to box margins (i.e., the outer-box).
                //                      l/t = marginLeft, marginTop, respectively
                //                      w = total width, margin inclusive
                //                      h = total height, margin inclusive
                //              The w/h are used for calculating boxes.
                //              Normally application code will not need to invoke this
                //              directly, and will use the ...box... functions instead.
                var 
                        s=computedStyle||gcs(n), 
                        px=dojo._toPixelValue,
                        l=px(n, s.marginLeft),
                        t=px(n, s.marginTop),
                        r=px(n, s.marginRight),
                        b=px(n, s.marginBottom);
                if (dojo.isSafari && (s.position != "absolute")){
                        // FIXME: Safari's version of the computed right margin
                        // is the space between our right edge and the right edge 
                        // of our offsetParent. 
                        // What we are looking for is the actual margin value as 
                        // determined by CSS.
                        // Hack solution is to assume left/right margins are the same.
                        r = l;
                }
                return { 
                        l: l,
                        t: t,
                        w: l+r,
                        h: t+b
                };
        }

        // Box getters work in any box context because offsetWidth/clientWidth
        // are invariant wrt box context
        //
        // They do *not* work for display: inline objects that have padding styles
        // because the user agent ignores padding (it's bogus styling in any case)
        //
        // Be careful with IMGs because they are inline or block depending on 
        // browser and browser mode.

        // Although it would be easier to read, there are not separate versions of 
        // _getMarginBox for each browser because:
        // 1. the branching is not expensive
        // 2. factoring the shared code wastes cycles (function call overhead)
        // 3. duplicating the shared code wastes bytes
        
        dojo._getMarginBox = function(/*DomNode*/node, /*Object*/computedStyle){
                // summary:
                //              returns an object that encodes the width, height, left and top
                //              positions of the node's margin box.
                var s = computedStyle||gcs(node), me = dojo._getMarginExtents(node, s);
                var     l = node.offsetLeft - me.l,     t = node.offsetTop - me.t;
                if(dojo.isMoz){
                        // Mozilla:
                        // If offsetParent has a computed overflow != visible, the offsetLeft is decreased
                        // by the parent's border.
                        // We don't want to compute the parent's style, so instead we examine node's
                        // computed left/top which is more stable.
                        var sl = parseFloat(s.left), st = parseFloat(s.top);
                        if(!isNaN(sl) && !isNaN(st)){
                                l = sl, t = st;
                        }else{
                                // If child's computed left/top are not parseable as a number (e.g. "auto"), we
                                // have no choice but to examine the parent's computed style.
                                var p = node.parentNode;
                                if(p && p.style){
                                        var pcs = gcs(p);
                                        if(pcs.overflow != "visible"){
                                                var be = dojo._getBorderExtents(p, pcs);
                                                l += be.l, t += be.t;
                                        }
                                }
                        }
                }else if(dojo.isOpera){
                        // On Opera, offsetLeft includes the parent's border
                        var p = node.parentNode;
                        if(p){
                                var be = dojo._getBorderExtents(p);
                                l -= be.l, t -= be.t;
                        }
                }
                return { 
                        l: l, 
                        t: t, 
                        w: node.offsetWidth + me.w, 
                        h: node.offsetHeight + me.h 
                };
        }
        
        dojo._getContentBox = function(node, computedStyle){
                // summary:
                //              Returns an object that encodes the width, height, left and top
                //              positions of the node's content box, irrespective of the
                //              current box model.

                // clientWidth/Height are important since the automatically account for scrollbars
                // fallback to offsetWidth/Height for special cases (see #3378)
                var s=computedStyle||gcs(node), pe=dojo._getPadExtents(node, s), be=dojo._getBorderExtents(node, s), w=node.clientWidth, h;
                if(!w){
                        w=node.offsetWidth, h=node.offsetHeight;
                }else{
                        h=node.clientHeight, be.w = be.h = 0; 
                }
                // On Opera, offsetLeft includes the parent's border
                if(dojo.isOpera){ pe.l += be.l; pe.t += be.t; };
                return { 
                        l: pe.l, 
                        t: pe.t, 
                        w: w - pe.w - be.w, 
                        h: h - pe.h - be.h
                };
        }

        dojo._getBorderBox = function(node, computedStyle){
                var s=computedStyle||gcs(node), pe=dojo._getPadExtents(node, s), cb=dojo._getContentBox(node, s);
                return { 
                        l: cb.l - pe.l, 
                        t: cb.t - pe.t, 
                        w: cb.w + pe.w, 
                        h: cb.h + pe.h
                };
        }

        // Box setters depend on box context because interpretation of width/height styles
        // vary wrt box context.
        //
        // The value of dojo.boxModel is used to determine box context.
        // dojo.boxModel can be set directly to change behavior.
        //
        // Beware of display: inline objects that have padding styles
        // because the user agent ignores padding (it's a bogus setup anyway)
        //
        // Be careful with IMGs because they are inline or block depending on 
        // browser and browser mode.
        // 
        // Elements other than DIV may have special quirks, like built-in
        // margins or padding, or values not detectable via computedStyle.
        // In particular, margins on TABLE do not seems to appear 
        // at all in computedStyle on Mozilla.
        
        dojo._setBox = function(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){
                //      summary:
                //              sets width/height/left/top in the current (native) box-model
                //              dimentions. Uses the unit passed in u.
                //      node: DOM Node reference. Id string not supported for performance reasons.
                //      l: optional. left offset from parent.
                //      t: optional. top offset from parent.
                //      w: optional. width in current box model.
                //      h: optional. width in current box model.
                //      u: optional. unit measure to use for other measures. Defaults to "px".
                u = u || "px";
                with(node.style){
                        if(!isNaN(l)){ left = l+u; }
                        if(!isNaN(t)){ top = t+u; }
                        if(w>=0){ width = w+u; }
                        if(h>=0){ height = h+u; }
                }
        }

        dojo._usesBorderBox = function(/*DomNode*/node){
                //      summary: 
                //              True if the node uses border-box layout.

                // We could test the computed style of node to see if a particular box
                // has been specified, but there are details and we choose not to bother.
                var n = node.tagName;
                // For whatever reason, TABLE and BUTTON are always border-box by default.
                // If you have assigned a different box to either one via CSS then
                // box functions will break.
                return dojo.boxModel=="border-box" || n=="TABLE" || n=="BUTTON"; // boolean
        }

        dojo._setContentSize = function(/*DomNode*/node, /*Number*/widthPx, /*Number*/heightPx, /*Object*/computedStyle){
                //      summary:
                //              Sets the size of the node's contents, irrespective of margins,
                //              padding, or borders.
                var bb = dojo._usesBorderBox(node);
                if(bb){
                        var pb = dojo._getPadBorderExtents(node, computedStyle);
                        if(widthPx>=0){ widthPx += pb.w; }
                        if(heightPx>=0){ heightPx += pb.h; }
                }
                dojo._setBox(node, NaN, NaN, widthPx, heightPx);
        }

        dojo._setMarginBox = function(/*DomNode*/node,  /*Number?*/leftPx, /*Number?*/topPx, 
                                                                                                        /*Number?*/widthPx, /*Number?*/heightPx, 
                                                                                                        /*Object*/computedStyle){
                //      summary:
                //              sets the size of the node's margin box and palcement
                //              (left/top), irrespective of box model. Think of it as a
                //              passthrough to dojo._setBox that handles box-model vagaries for
                //              you.

                var s = computedStyle || dojo.getComputedStyle(node);
                // Some elements have special padding, margin, and box-model settings. 
                // To use box functions you may need to set padding, margin explicitly.
                // Controlling box-model is harder, in a pinch you might set dojo.boxModel.
                var bb=dojo._usesBorderBox(node),
                                pb=bb ? _nilExtents : dojo._getPadBorderExtents(node, s),
                                mb=dojo._getMarginExtents(node, s);
                if(widthPx>=0){ widthPx = Math.max(widthPx - pb.w - mb.w, 0); }
                if(heightPx>=0){ heightPx = Math.max(heightPx - pb.h - mb.h, 0); }
                dojo._setBox(node, leftPx, topPx, widthPx, heightPx);
        }
        
        var _nilExtents = { l:0, t:0, w:0, h:0 };

        // public API
        
        dojo.marginBox = function(/*DomNode|String*/node, /*Object?*/box){
                //      summary:
                //              getter/setter for the margin-box of node.
                //      description: 
                //              Returns an object in the expected format of box (regardless
                //              if box is passed). The object might look like:
                //                      { l: 50, t: 200, w: 300: h: 150 }
                //              for a node offset from its parent 50px to the left, 200px from
                //              the top with a margin width of 300px and a margin-height of
                //              150px.
                //      node:
                //              id or reference to DOM Node to get/set box for
                //      box:
                //              optional. If passed, denotes that dojo.marginBox() should
                //              update/set the margin box for node. Box is an object in the
                //              above format. All properties are optional if passed.
                var n=dojo.byId(node), s=gcs(n), b=box;
                return !b ? dojo._getMarginBox(n, s) : dojo._setMarginBox(n, b.l, b.t, b.w, b.h, s); // Object
        }

        dojo.contentBox = function(/*DomNode|String*/node, /*Object?*/box){
                //      summary:
                //              getter/setter for the content-box of node.
                //      description:
                //              Returns an object in the expected format of box (regardless if box is passed).
                //              The object might look like:
                //                      { l: 50, t: 200, w: 300: h: 150 }
                //              for a node offset from its parent 50px to the left, 200px from
                //              the top with a content width of 300px and a content-height of
                //              150px. Note that the content box may have a much larger border
                //              or margin box, depending on the box model currently in use and
                //              CSS values set/inherited for node.
                //      node:
                //              id or reference to DOM Node to get/set box for
                //      box:
                //              optional. If passed, denotes that dojo.contentBox() should
                //              update/set the content box for node. Box is an object in the
                //              above format. All properties are optional if passed.
                var n=dojo.byId(node), s=gcs(n), b=box;
                return !b ? dojo._getContentBox(n, s) : dojo._setContentSize(n, b.w, b.h, s); // Object
        }
        
        // =============================
        // Positioning 
        // =============================
        
        var _sumAncestorProperties = function(node, prop){
                if(!(node = (node||0).parentNode)){return 0};
                var val, retVal = 0, _b = dojo.body();
                while(node && node.style){
                        if(gcs(node).position == "fixed"){
                                return 0;
                        }
                        val = node[prop];
                        if(val){
                                retVal += val - 0;
                                // opera and khtml #body & #html has the same values, we only
                                // need one value
                                if(node == _b){ break; }
                        }
                        node = node.parentNode;
                }
                return retVal;  //      integer
        }

        dojo._docScroll = function(){
                var _b = dojo.body();
                var _w = dojo.global;
                var de = dojo.doc.documentElement;
                return {
                        y: (_w.pageYOffset || de.scrollTop || _b.scrollTop || 0),
                        x: (_w.pageXOffset || dojo._fixIeBiDiScrollLeft(de.scrollLeft) || _b.scrollLeft || 0)
                };
        };
        
        dojo._isBodyLtr = function(){
                //FIXME: could check html and body tags directly instead of computed style?  need to ignore case, accept empty values
                return !("_bodyLtr" in dojo) ? 
                        dojo._bodyLtr = dojo.getComputedStyle(dojo.body()).direction == "ltr" :
                        dojo._bodyLtr; // Boolean 
        }
        
        dojo._getIeDocumentElementOffset = function(){
                // summary
                // The following values in IE contain an offset:
                //     event.clientX 
                //     event.clientY 
                //     node.getBoundingClientRect().left
                //     node.getBoundingClientRect().top
                // But other position related values do not contain this offset, such as
                // node.offsetLeft, node.offsetTop, node.style.left and node.style.top.
                // The offset is always (2, 2) in LTR direction. When the body is in RTL
                // direction, the offset counts the width of left scroll bar's width.
                // This function computes the actual offset.

                //NOTE: assumes we're being called in an IE browser

                var de = dojo.doc.documentElement;
                if(dojo.isIE >= 7){
                        return {x: de.getBoundingClientRect().left, y: de.getBoundingClientRect().top}; // Object
                }else{
                        // IE 6.0
                        return {x: dojo._isBodyLtr() || window.parent == window ?
                                de.clientLeft : de.offsetWidth - de.clientWidth - de.clientLeft, 
                                y: de.clientTop}; // Object
                }
        };
        
        dojo._fixIeBiDiScrollLeft = function(/*Integer*/ scrollLeft){
                // In RTL direction, scrollLeft should be a negative value, but IE 
                // returns a positive one. All codes using documentElement.scrollLeft
                // must call this function to fix this error, otherwise the position
                // will offset to right when there is a horizonal scrollbar.
                if(dojo.isIE && !dojo._isBodyLtr()){
                        var de = dojo.doc.documentElement;
                        return scrollLeft + de.clientWidth - de.scrollWidth; // Integer
                }
                return scrollLeft; // Integer
        }
        
        dojo._abs = function(/*DomNode*/node, /*Boolean?*/includeScroll){
                //      summary:
                //              Gets the absolute position of the passed element based on the
                //              document itself. Returns an object of the form:
                //                      { x: 100, y: 300 }
                //              if includeScroll is passed, the x and y values will include any
                //              document offsets that may affect the position relative to the
                //              viewport.

                // FIXME: need to decide in the brave-new-world if we're going to be
                // margin-box or border-box.
                var ownerDocument = node.ownerDocument;
                var ret = {
                        x: 0,
                        y: 0
                };
                var hasScroll = false;

                // targetBoxType == "border-box"
                var db = dojo.body();
                if(dojo.isIE){
                        var client = node.getBoundingClientRect();
                        var offset = dojo._getIeDocumentElementOffset();
                        ret.x = client.left - offset.x;
                        ret.y = client.top - offset.y;
                }else if(ownerDocument["getBoxObjectFor"]){
                        // mozilla
                        var bo = ownerDocument.getBoxObjectFor(node);
                        ret.x = bo.x - _sumAncestorProperties(node, "scrollLeft");
                        ret.y = bo.y - _sumAncestorProperties(node, "scrollTop");
                }else{
                        if(node["offsetParent"]){
                                hasScroll = true;
                                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
                                // FIXME: getting contrary results to the above in latest WebKit.
                                if(dojo.isSafari &&
                                        //(node.style.getPropertyValue("position") == "absolute") &&
                                        (gcs(node).position == "absolute") &&
                                        (node.parentNode == db)){
                                        endNode = db;
                                }else{
                                        endNode = db.parentNode;
                                }
                                if(node.parentNode != db){
                                        var nd = node;
                                        if(dojo.isOpera || (dojo.isSafari >= 3)){ nd = db; }
                                        ret.x -= _sumAncestorProperties(nd, "scrollLeft");
                                        ret.y -= _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(!dojo.isOpera || 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);
                        }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 offsetParent is used, ret value already includes scroll position
                // so we may have to actually remove that value if !includeScroll
                if(hasScroll || includeScroll){
                        var scroll = dojo._docScroll();
                        var m = hasScroll ? (!includeScroll ? -1 : 0) : 1;
                        ret.y += m*scroll.y;
                        ret.x += m*scroll.x;
                }

                return ret; // object
        }

        // FIXME: need a setter for coords or a moveTo!!
        dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
                //      summary:
                //              Returns an object that measures margin box width/height and
                //              absolute positioning data from dojo._abs(). Return value will
                //              be in the form:
                //                      { l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
                //              does not act as a setter. If includeScroll is passed, the x and
                //              y params are affected as one would expect in dojo._abs().
                var n=dojo.byId(node), s=gcs(n), mb=dojo._getMarginBox(n, s);
                var abs = dojo._abs(n, includeScroll);
                mb.x = abs.x;
                mb.y = abs.y;
                return mb;
        }
})();

// =============================
// (CSS) Class Functions
// =============================

dojo.hasClass = function(/*DomNode|String*/node, /*String*/classStr){
        //      summary:
        //              Returns whether or not the specified classes are a portion of the
        //              class list currently applied to the node. 
        return ((" "+dojo.byId(node).className+" ").indexOf(" "+classStr+" ") >= 0);  // Boolean
};

dojo.addClass = function(/*DomNode|String*/node, /*String*/classStr){
        //      summary:
        //              Adds the specified classes to the end of the class list on the
        //              passed node.
        node = dojo.byId(node);
        var cls = node.className;
        if((" "+cls+" ").indexOf(" "+classStr+" ") < 0){
                node.className = cls + (cls ? ' ' : '') + classStr;
        }
};

dojo.removeClass = function(/*DomNode|String*/node, /*String*/classStr){
        // summary: Removes the specified classes from node.
        node = dojo.byId(node);
        var t = dojo.trim((" " + node.className + " ").replace(" " + classStr + " ", " "));
        if(node.className != t){ node.className = t; }
};

dojo.toggleClass = function(/*DomNode|String*/node, /*String*/classStr, /*Boolean?*/condition){
        //      summary:        
        //              Adds a class to node if not present, or removes if present.
        //              Pass a boolean condition if you want to explicitly add or remove.
        //      condition:
        //              If passed, true means to add the class, false means to remove.
        if(condition === undefined){
                condition = !dojo.hasClass(node, classStr);
        }
        dojo[condition ? "addClass" : "removeClass"](node, classStr);
};

}