From 1354d17270961fff662d40f90521223f8fd0d73b Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Tue, 14 Aug 2012 18:59:10 +0400 Subject: update dojo to 1.7.3 --- lib/dojo/dom-style.js.uncompressed.js | 321 ++++++++++++++++++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 lib/dojo/dom-style.js.uncompressed.js (limited to 'lib/dojo/dom-style.js.uncompressed.js') diff --git a/lib/dojo/dom-style.js.uncompressed.js b/lib/dojo/dom-style.js.uncompressed.js new file mode 100644 index 000000000..e6b3822c9 --- /dev/null +++ b/lib/dojo/dom-style.js.uncompressed.js @@ -0,0 +1,321 @@ +define("dojo/dom-style", ["./_base/sniff", "./dom"], function(has, dom){ + // module: + // dojo/dom-style + // summary: + // This module defines the core dojo DOM style API. + + // ============================= + // 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. + + /*===== + dojo.getComputedStyle = function(node){ + // summary: + // Returns a "computed style" object. + // + // description: + // Gets a "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. + // + // Note also that this method is expensive. Wherever possible, + // reuse the returned object. + // + // 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; + // + // example: + // Reusing the returned object, avoiding multiple lookups: + // | var cs = dojo.getComputedStyle(dojo.byId("someNode")); + // | var w = cs.width, h = cs.height; + return; // CSS2Properties + } + =====*/ + + /*===== + dojo.toPixelValue = function(node, value){ + // summary: + // converts style value to pixels on IE or return a numeric value. + // node: DOMNode + // value: String + // returns: Number + }; + =====*/ + + /*===== + dojo._toPixelValue = function(node, value){ + // summary: + // Existing alias for `dojo._toPixelValue`. Deprecated, will be removed in 2.0. + }; + =====*/ + + /*===== + dojo.getStyle = function(node, name){ + // summary: + // Accesses styles on a node. + // description: + // Getting the style value uses the computed style for the node, so the value + // will be a calculated value, not just the immediate node.style value. + // Also when getting values, use specific style names, + // like "borderBottomWidth" instead of "border" since compound values like + // "border" are not necessarily reflected as expected. + // If you want to get node dimensions, use `dojo.marginBox()`, + // `dojo.contentBox()` or `dojo.position()`. + // node: DOMNode|String + // id or reference to node to get style for + // name: String? + // the style property to get + // example: + // Passing only an ID or node returns the computed style object of + // the node: + // | dojo.getStyle("thinger"); + // example: + // Passing a node and a style property returns the current + // normalized, computed value for that property: + // | dojo.getStyle("thinger", "opacity"); // 1 by default + }; + =====*/ + + /*===== + dojo.setStyle = function(node, name, value){ + // summary: + // Sets styles on a node. + // node: DOMNode|String + // id or reference to node to set style for + // name: String|Object + // the style property to set in DOM-accessor format + // ("borderWidth", not "border-width") or an object with key/value + // pairs suitable for setting each property. + // value: String? + // If passed, sets value on the node for style, handling + // cross-browser concerns. When setting a pixel value, + // be sure to include "px" in the value. For instance, top: "200px". + // Otherwise, in some cases, some browsers will not apply the style. + // + // example: + // Passing a node, a style property, and a value changes the + // current display of the node and returns the new computed value + // | dojo.setStyle("thinger", "opacity", 0.5); // == 0.5 + // + // example: + // Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node: + // | dojo.setStyle("thinger", { + // | "opacity": 0.5, + // | "border": "3px solid black", + // | "height": "300px" + // | }); + // + // example: + // When the CSS style property is hyphenated, the JavaScript property is camelCased. + // font-size becomes fontSize, and so on. + // | dojo.setStyle("thinger",{ + // | fontSize:"14pt", + // | letterSpacing:"1.2em" + // | }); + // + // example: + // dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling + // dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()` + // | dojo.query(".someClassName").style("visibility","hidden"); + // | // or + // | dojo.query("#baz > div").style({ + // | opacity:0.75, + // | fontSize:"13pt" + // | }); + }; + =====*/ + + // Although we normally eschew argument validation at this + // level, here we test argument 'node' for (duck)type, + // by testing nodeType, ecause 'document' is the 'parentNode' of 'body' + // it is frequently sent to this function even + // though it is not Element. + var getComputedStyle, style = {}; + if(has("webkit")){ + getComputedStyle = function(/*DomNode*/node){ + var s; + if(node.nodeType == 1){ + var dv = node.ownerDocument.defaultView; + s = dv.getComputedStyle(node, null); + if(!s && node.style){ + node.style.display = ""; + s = dv.getComputedStyle(node, null); + } + } + return s || {}; + }; + }else if(has("ie") && (has("ie") < 9 || has("quirks"))){ + getComputedStyle = function(node){ + // IE (as of 7) doesn't expose Element like sane browsers + return node.nodeType == 1 /* ELEMENT_NODE*/ ? node.currentStyle : {}; + }; + }else{ + getComputedStyle = function(node){ + return node.nodeType == 1 ? + node.ownerDocument.defaultView.getComputedStyle(node, null) : {}; + }; + } + style.getComputedStyle = getComputedStyle; + + var toPixel; + if(!has("ie")){ + toPixel = function(element, value){ + // style values can be floats, client code may want + // to round for integer pixels. + return parseFloat(value) || 0; + }; + }else{ + toPixel = 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); } + var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle, + sLeft = s.left, rsLeft = rs.left; + rs.left = cs.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 + s.left = avalue; + avalue = s.pixelLeft; + }catch(e){ + avalue = 0; + } + s.left = sLeft; + rs.left = rsLeft; + return avalue; + } + } + style.toPixelValue = toPixel; + + // FIXME: there opacity quirks on FF that we haven't ported over. Hrm. + + var astr = "DXImageTransform.Microsoft.Alpha"; + var af = function(n, f){ + try{ + return n.filters.item(astr); + }catch(e){ + return f ? {} : null; + } + }; + + var _getOpacity = + has("ie") < 9 || (has("ie") && has("quirks")) ? function(node){ + try{ + return af(node).Opacity / 100; // Number + }catch(e){ + return 1; // Number + } + } : + function(node){ + return getComputedStyle(node).opacity; + }; + + var _setOpacity = + has("ie") < 9 || (has("ie") && has("quirks")) ? function(/*DomNode*/node, /*Number*/opacity){ + var ov = opacity * 100, opaque = opacity == 1; + node.style.zoom = opaque ? "" : 1; + + if(!af(node)){ + if(opaque){ + return opacity; + } + node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")"; + }else{ + af(node, 1).Opacity = ov; + } + + // on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661), + //but still update the opacity value so we can get a correct reading if it is read later. + af(node, 1).Enabled = !opaque; + + if(node.tagName.toLowerCase() == "tr"){ + for(var td = node.firstChild; td; td = td.nextSibling){ + if(td.tagName.toLowerCase() == "td"){ + _setOpacity(td, opacity); + } + } + } + return opacity; + } : + function(node, opacity){ + return node.style.opacity = opacity; + }; + + var _pixelNamesCache = { + left: true, top: true + }; + var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border + function _toStyleValue(node, type, value){ + //TODO: should we really be doing string case conversion here? Should we cache it? Need to profile! + type = type.toLowerCase(); + if(has("ie")){ + if(value == "auto"){ + if(type == "height"){ return node.offsetHeight; } + if(type == "width"){ return node.offsetWidth; } + } + if(type == "fontweight"){ + switch(value){ + case 700: return "bold"; + case 400: + default: return "normal"; + } + } + } + if(!(type in _pixelNamesCache)){ + _pixelNamesCache[type] = _pixelRegExp.test(type); + } + return _pixelNamesCache[type] ? toPixel(node, value) : value; + } + + var _floatStyle = has("ie") ? "styleFloat" : "cssFloat", + _floatAliases = {"cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle}; + + // public API + + style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){ + var n = dom.byId(node), l = arguments.length, op = (name == "opacity"); + if(l == 2 && op){ + return _getOpacity(n); + } + name = _floatAliases[name] || name; + var s = style.getComputedStyle(n); + return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */ + }; + + style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){ + var n = dom.byId(node), l = arguments.length, op = (name == "opacity"); + name = _floatAliases[name] || name; + if(l == 3){ + return op ? _setOpacity(n, value) : n.style[name] = value; // Number + } + for(var x in name){ + style.set(node, x, name[x]); + } + return style.getComputedStyle(n); + }; + + return style; +}); -- cgit v1.2.3