| New file |
|---|
| 0,0 → 1,994 |
|---|
| 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); |
| }; |
| |
| } |