diff -r 322d0feea350 -r 89ef5ed3c48b src/cm/media/js/lib/yui/yui_3.10.3/build/dom-screen/dom-screen-debug.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/dom-screen/dom-screen-debug.js Tue Jul 16 14:29:46 2013 +0200 @@ -0,0 +1,618 @@ +/* +YUI 3.10.3 (build 2fb5187) +Copyright 2013 Yahoo! Inc. All rights reserved. +Licensed under the BSD License. +http://yuilibrary.com/license/ +*/ + +YUI.add('dom-screen', function (Y, NAME) { + +(function(Y) { + +/** + * Adds position and region management functionality to DOM. + * @module dom + * @submodule dom-screen + * @for DOM + */ + +var DOCUMENT_ELEMENT = 'documentElement', + COMPAT_MODE = 'compatMode', + POSITION = 'position', + FIXED = 'fixed', + RELATIVE = 'relative', + LEFT = 'left', + TOP = 'top', + _BACK_COMPAT = 'BackCompat', + MEDIUM = 'medium', + BORDER_LEFT_WIDTH = 'borderLeftWidth', + BORDER_TOP_WIDTH = 'borderTopWidth', + GET_BOUNDING_CLIENT_RECT = 'getBoundingClientRect', + GET_COMPUTED_STYLE = 'getComputedStyle', + + Y_DOM = Y.DOM, + + // TODO: how about thead/tbody/tfoot/tr? + // TODO: does caption matter? + RE_TABLE = /^t(?:able|d|h)$/i, + + SCROLL_NODE; + +if (Y.UA.ie) { + if (Y.config.doc[COMPAT_MODE] !== 'BackCompat') { + SCROLL_NODE = DOCUMENT_ELEMENT; + } else { + SCROLL_NODE = 'body'; + } +} + +Y.mix(Y_DOM, { + /** + * Returns the inner height of the viewport (exludes scrollbar). + * @method winHeight + * @return {Number} The current height of the viewport. + */ + winHeight: function(node) { + var h = Y_DOM._getWinSize(node).height; + Y.log('winHeight returning ' + h, 'info', 'dom-screen'); + return h; + }, + + /** + * Returns the inner width of the viewport (exludes scrollbar). + * @method winWidth + * @return {Number} The current width of the viewport. + */ + winWidth: function(node) { + var w = Y_DOM._getWinSize(node).width; + Y.log('winWidth returning ' + w, 'info', 'dom-screen'); + return w; + }, + + /** + * Document height + * @method docHeight + * @return {Number} The current height of the document. + */ + docHeight: function(node) { + var h = Y_DOM._getDocSize(node).height; + Y.log('docHeight returning ' + h, 'info', 'dom-screen'); + return Math.max(h, Y_DOM._getWinSize(node).height); + }, + + /** + * Document width + * @method docWidth + * @return {Number} The current width of the document. + */ + docWidth: function(node) { + var w = Y_DOM._getDocSize(node).width; + Y.log('docWidth returning ' + w, 'info', 'dom-screen'); + return Math.max(w, Y_DOM._getWinSize(node).width); + }, + + /** + * Amount page has been scroll horizontally + * @method docScrollX + * @return {Number} The current amount the screen is scrolled horizontally. + */ + docScrollX: function(node, doc) { + doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; // perf optimization + var dv = doc.defaultView, + pageOffset = (dv) ? dv.pageXOffset : 0; + return Math.max(doc[DOCUMENT_ELEMENT].scrollLeft, doc.body.scrollLeft, pageOffset); + }, + + /** + * Amount page has been scroll vertically + * @method docScrollY + * @return {Number} The current amount the screen is scrolled vertically. + */ + docScrollY: function(node, doc) { + doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; // perf optimization + var dv = doc.defaultView, + pageOffset = (dv) ? dv.pageYOffset : 0; + return Math.max(doc[DOCUMENT_ELEMENT].scrollTop, doc.body.scrollTop, pageOffset); + }, + + /** + * Gets the current position of an element based on page coordinates. + * Element must be part of the DOM tree to have page coordinates + * (display:none or elements not appended return false). + * @method getXY + * @param element The target element + * @return {Array} The XY position of the element + + TODO: test inDocument/display? + */ + getXY: function() { + if (Y.config.doc[DOCUMENT_ELEMENT][GET_BOUNDING_CLIENT_RECT]) { + return function(node) { + var xy = null, + scrollLeft, + scrollTop, + mode, + box, + offX, + offY, + doc, + win, + inDoc, + rootNode; + + if (node && node.tagName) { + doc = node.ownerDocument; + mode = doc[COMPAT_MODE]; + + if (mode !== _BACK_COMPAT) { + rootNode = doc[DOCUMENT_ELEMENT]; + } else { + rootNode = doc.body; + } + + // inline inDoc check for perf + if (rootNode.contains) { + inDoc = rootNode.contains(node); + } else { + inDoc = Y.DOM.contains(rootNode, node); + } + + if (inDoc) { + win = doc.defaultView; + + // inline scroll calc for perf + if (win && 'pageXOffset' in win) { + scrollLeft = win.pageXOffset; + scrollTop = win.pageYOffset; + } else { + scrollLeft = (SCROLL_NODE) ? doc[SCROLL_NODE].scrollLeft : Y_DOM.docScrollX(node, doc); + scrollTop = (SCROLL_NODE) ? doc[SCROLL_NODE].scrollTop : Y_DOM.docScrollY(node, doc); + } + + if (Y.UA.ie) { // IE < 8, quirks, or compatMode + if (!doc.documentMode || doc.documentMode < 8 || mode === _BACK_COMPAT) { + offX = rootNode.clientLeft; + offY = rootNode.clientTop; + } + } + box = node[GET_BOUNDING_CLIENT_RECT](); + xy = [box.left, box.top]; + + if (offX || offY) { + xy[0] -= offX; + xy[1] -= offY; + + } + if ((scrollTop || scrollLeft)) { + if (!Y.UA.ios || (Y.UA.ios >= 4.2)) { + xy[0] += scrollLeft; + xy[1] += scrollTop; + } + + } + } else { + xy = Y_DOM._getOffset(node); + } + } + return xy; + }; + } else { + return function(node) { // manually calculate by crawling up offsetParents + //Calculate the Top and Left border sizes (assumes pixels) + var xy = null, + doc, + parentNode, + bCheck, + scrollTop, + scrollLeft; + + if (node) { + if (Y_DOM.inDoc(node)) { + xy = [node.offsetLeft, node.offsetTop]; + doc = node.ownerDocument; + parentNode = node; + // TODO: refactor with !! or just falsey + bCheck = ((Y.UA.gecko || Y.UA.webkit > 519) ? true : false); + + // TODO: worth refactoring for TOP/LEFT only? + while ((parentNode = parentNode.offsetParent)) { + xy[0] += parentNode.offsetLeft; + xy[1] += parentNode.offsetTop; + if (bCheck) { + xy = Y_DOM._calcBorders(parentNode, xy); + } + } + + // account for any scrolled ancestors + if (Y_DOM.getStyle(node, POSITION) != FIXED) { + parentNode = node; + + while ((parentNode = parentNode.parentNode)) { + scrollTop = parentNode.scrollTop; + scrollLeft = parentNode.scrollLeft; + + //Firefox does something funky with borders when overflow is not visible. + if (Y.UA.gecko && (Y_DOM.getStyle(parentNode, 'overflow') !== 'visible')) { + xy = Y_DOM._calcBorders(parentNode, xy); + } + + + if (scrollTop || scrollLeft) { + xy[0] -= scrollLeft; + xy[1] -= scrollTop; + } + } + xy[0] += Y_DOM.docScrollX(node, doc); + xy[1] += Y_DOM.docScrollY(node, doc); + + } else { + //Fix FIXED position -- add scrollbars + xy[0] += Y_DOM.docScrollX(node, doc); + xy[1] += Y_DOM.docScrollY(node, doc); + } + } else { + xy = Y_DOM._getOffset(node); + } + } + + return xy; + }; + } + }(),// NOTE: Executing for loadtime branching + + /** + Gets the width of vertical scrollbars on overflowed containers in the body + content. + + @method getScrollbarWidth + @return {Number} Pixel width of a scrollbar in the current browser + **/ + getScrollbarWidth: Y.cached(function () { + var doc = Y.config.doc, + testNode = doc.createElement('div'), + body = doc.getElementsByTagName('body')[0], + // 0.1 because cached doesn't support falsy refetch values + width = 0.1; + + if (body) { + testNode.style.cssText = "position:absolute;visibility:hidden;overflow:scroll;width:20px;"; + testNode.appendChild(doc.createElement('p')).style.height = '1px'; + body.insertBefore(testNode, body.firstChild); + width = testNode.offsetWidth - testNode.clientWidth; + + body.removeChild(testNode); + } + + return width; + }, null, 0.1), + + /** + * Gets the current X position of an element based on page coordinates. + * Element must be part of the DOM tree to have page coordinates + * (display:none or elements not appended return false). + * @method getX + * @param element The target element + * @return {Number} The X position of the element + */ + + getX: function(node) { + return Y_DOM.getXY(node)[0]; + }, + + /** + * Gets the current Y position of an element based on page coordinates. + * Element must be part of the DOM tree to have page coordinates + * (display:none or elements not appended return false). + * @method getY + * @param element The target element + * @return {Number} The Y position of the element + */ + + getY: function(node) { + return Y_DOM.getXY(node)[1]; + }, + + /** + * Set the position of an html element in page coordinates. + * The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false). + * @method setXY + * @param element The target element + * @param {Array} xy Contains X & Y values for new position (coordinates are page-based) + * @param {Boolean} noRetry By default we try and set the position a second time if the first fails + */ + setXY: function(node, xy, noRetry) { + var setStyle = Y_DOM.setStyle, + pos, + delta, + newXY, + currentXY; + + if (node && xy) { + pos = Y_DOM.getStyle(node, POSITION); + + delta = Y_DOM._getOffset(node); + if (pos == 'static') { // default to relative + pos = RELATIVE; + setStyle(node, POSITION, pos); + } + currentXY = Y_DOM.getXY(node); + + if (xy[0] !== null) { + setStyle(node, LEFT, xy[0] - currentXY[0] + delta[0] + 'px'); + } + + if (xy[1] !== null) { + setStyle(node, TOP, xy[1] - currentXY[1] + delta[1] + 'px'); + } + + if (!noRetry) { + newXY = Y_DOM.getXY(node); + if (newXY[0] !== xy[0] || newXY[1] !== xy[1]) { + Y_DOM.setXY(node, xy, true); + } + } + + Y.log('setXY setting position to ' + xy, 'info', 'dom-screen'); + } else { + Y.log('setXY failed to set ' + node + ' to ' + xy, 'info', 'dom-screen'); + } + }, + + /** + * Set the X position of an html element in page coordinates, regardless of how the element is positioned. + * The element(s) must be part of the DOM tree to have page coordinates (display:none or elements not appended return false). + * @method setX + * @param element The target element + * @param {Number} x The X values for new position (coordinates are page-based) + */ + setX: function(node, x) { + return Y_DOM.setXY(node, [x, null]); + }, + + /** + * Set the Y position of an html element in page coordinates, regardless of how the element is positioned. + * The element(s) must be part of the DOM tree to have page coordinates (display:none or elements not appended return false). + * @method setY + * @param element The target element + * @param {Number} y The Y values for new position (coordinates are page-based) + */ + setY: function(node, y) { + return Y_DOM.setXY(node, [null, y]); + }, + + /** + * @method swapXY + * @description Swap the xy position with another node + * @param {Node} node The node to swap with + * @param {Node} otherNode The other node to swap with + * @return {Node} + */ + swapXY: function(node, otherNode) { + var xy = Y_DOM.getXY(node); + Y_DOM.setXY(node, Y_DOM.getXY(otherNode)); + Y_DOM.setXY(otherNode, xy); + }, + + _calcBorders: function(node, xy2) { + var t = parseInt(Y_DOM[GET_COMPUTED_STYLE](node, BORDER_TOP_WIDTH), 10) || 0, + l = parseInt(Y_DOM[GET_COMPUTED_STYLE](node, BORDER_LEFT_WIDTH), 10) || 0; + if (Y.UA.gecko) { + if (RE_TABLE.test(node.tagName)) { + t = 0; + l = 0; + } + } + xy2[0] += l; + xy2[1] += t; + return xy2; + }, + + _getWinSize: function(node, doc) { + doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; + var win = doc.defaultView || doc.parentWindow, + mode = doc[COMPAT_MODE], + h = win.innerHeight, + w = win.innerWidth, + root = doc[DOCUMENT_ELEMENT]; + + if ( mode && !Y.UA.opera ) { // IE, Gecko + if (mode != 'CSS1Compat') { // Quirks + root = doc.body; + } + h = root.clientHeight; + w = root.clientWidth; + } + return { height: h, width: w }; + }, + + _getDocSize: function(node) { + var doc = (node) ? Y_DOM._getDoc(node) : Y.config.doc, + root = doc[DOCUMENT_ELEMENT]; + + if (doc[COMPAT_MODE] != 'CSS1Compat') { + root = doc.body; + } + + return { height: root.scrollHeight, width: root.scrollWidth }; + } +}); + +})(Y); +(function(Y) { +var TOP = 'top', + RIGHT = 'right', + BOTTOM = 'bottom', + LEFT = 'left', + + getOffsets = function(r1, r2) { + var t = Math.max(r1[TOP], r2[TOP]), + r = Math.min(r1[RIGHT], r2[RIGHT]), + b = Math.min(r1[BOTTOM], r2[BOTTOM]), + l = Math.max(r1[LEFT], r2[LEFT]), + ret = {}; + + ret[TOP] = t; + ret[RIGHT] = r; + ret[BOTTOM] = b; + ret[LEFT] = l; + return ret; + }, + + DOM = Y.DOM; + +Y.mix(DOM, { + /** + * Returns an Object literal containing the following about this element: (top, right, bottom, left) + * @for DOM + * @method region + * @param {HTMLElement} element The DOM element. + * @return {Object} Object literal containing the following about this element: (top, right, bottom, left) + */ + region: function(node) { + var xy = DOM.getXY(node), + ret = false; + + if (node && xy) { + ret = DOM._getRegion( + xy[1], // top + xy[0] + node.offsetWidth, // right + xy[1] + node.offsetHeight, // bottom + xy[0] // left + ); + } + + return ret; + }, + + /** + * Find the intersect information for the passed nodes. + * @method intersect + * @for DOM + * @param {HTMLElement} element The first element + * @param {HTMLElement | Object} element2 The element or region to check the interect with + * @param {Object} altRegion An object literal containing the region for the first element if we already have the data (for performance e.g. DragDrop) + * @return {Object} Object literal containing the following intersection data: (top, right, bottom, left, area, yoff, xoff, inRegion) + */ + intersect: function(node, node2, altRegion) { + var r = altRegion || DOM.region(node), region = {}, + n = node2, + off; + + if (n.tagName) { + region = DOM.region(n); + } else if (Y.Lang.isObject(node2)) { + region = node2; + } else { + return false; + } + + off = getOffsets(region, r); + return { + top: off[TOP], + right: off[RIGHT], + bottom: off[BOTTOM], + left: off[LEFT], + area: ((off[BOTTOM] - off[TOP]) * (off[RIGHT] - off[LEFT])), + yoff: ((off[BOTTOM] - off[TOP])), + xoff: (off[RIGHT] - off[LEFT]), + inRegion: DOM.inRegion(node, node2, false, altRegion) + }; + + }, + /** + * Check if any part of this node is in the passed region + * @method inRegion + * @for DOM + * @param {Object} node The node to get the region from + * @param {Object} node2 The second node to get the region from or an Object literal of the region + * @param {Boolean} all Should all of the node be inside the region + * @param {Object} altRegion An object literal containing the region for this node if we already have the data (for performance e.g. DragDrop) + * @return {Boolean} True if in region, false if not. + */ + inRegion: function(node, node2, all, altRegion) { + var region = {}, + r = altRegion || DOM.region(node), + n = node2, + off; + + if (n.tagName) { + region = DOM.region(n); + } else if (Y.Lang.isObject(node2)) { + region = node2; + } else { + return false; + } + + if (all) { + return ( + r[LEFT] >= region[LEFT] && + r[RIGHT] <= region[RIGHT] && + r[TOP] >= region[TOP] && + r[BOTTOM] <= region[BOTTOM] ); + } else { + off = getOffsets(region, r); + if (off[BOTTOM] >= off[TOP] && off[RIGHT] >= off[LEFT]) { + return true; + } else { + return false; + } + + } + }, + + /** + * Check if any part of this element is in the viewport + * @method inViewportRegion + * @for DOM + * @param {HTMLElement} element The DOM element. + * @param {Boolean} all Should all of the node be inside the region + * @param {Object} altRegion An object literal containing the region for this node if we already have the data (for performance e.g. DragDrop) + * @return {Boolean} True if in region, false if not. + */ + inViewportRegion: function(node, all, altRegion) { + return DOM.inRegion(node, DOM.viewportRegion(node), all, altRegion); + + }, + + _getRegion: function(t, r, b, l) { + var region = {}; + + region[TOP] = region[1] = t; + region[LEFT] = region[0] = l; + region[BOTTOM] = b; + region[RIGHT] = r; + region.width = region[RIGHT] - region[LEFT]; + region.height = region[BOTTOM] - region[TOP]; + + return region; + }, + + /** + * Returns an Object literal containing the following about the visible region of viewport: (top, right, bottom, left) + * @method viewportRegion + * @for DOM + * @return {Object} Object literal containing the following about the visible region of the viewport: (top, right, bottom, left) + */ + viewportRegion: function(node) { + node = node || Y.config.doc.documentElement; + var ret = false, + scrollX, + scrollY; + + if (node) { + scrollX = DOM.docScrollX(node); + scrollY = DOM.docScrollY(node); + + ret = DOM._getRegion(scrollY, // top + DOM.winWidth(node) + scrollX, // right + scrollY + DOM.winHeight(node), // bottom + scrollX); // left + } + + return ret; + } +}); +})(Y); + + +}, '3.10.3', {"requires": ["dom-base", "dom-style"]});