lib/yuilib/3.13.0/node-screen/node-screen.js

   1 /*
   2 YUI 3.13.0 (build 508226d)
   3 Copyright 2013 Yahoo! Inc. All rights reserved.
   4 Licensed under the BSD License.
   5 http://yuilibrary.com/license/
   6 */
   7
   8 YUI.add('node-screen', function (Y, NAME) {
   9
  10 /**
  11  * Extended Node interface for managing regions and screen positioning.
  12  * Adds support for positioning elements and normalizes window size and scroll detection.
  13  * @module node
  14  * @submodule node-screen
  15  */
  16
  17 // these are all "safe" returns, no wrapping required
  18 Y.each([
  19     /**
  20      * Returns the inner width of the viewport (exludes scrollbar).
  21      * @config winWidth
  22      * @for Node
  23      * @type {Int}
  24      */
  25     'winWidth',
  26
  27     /**
  28      * Returns the inner height of the viewport (exludes scrollbar).
  29      * @config winHeight
  30      * @type {Int}
  31      */
  32     'winHeight',
  33
  34     /**
  35      * Document width
  36      * @config docWidth
  37      * @type {Int}
  38      */
  39     'docWidth',
  40
  41     /**
  42      * Document height
  43      * @config docHeight
  44      * @type {Int}
  45      */
  46     'docHeight',
  47
  48     /**
  49      * Pixel distance the page has been scrolled horizontally
  50      * @config docScrollX
  51      * @type {Int}
  52      */
  53     'docScrollX',
  54
  55     /**
  56      * Pixel distance the page has been scrolled vertically
  57      * @config docScrollY
  58      * @type {Int}
  59      */
  60     'docScrollY'
  61     ],
  62     function(name) {
  63         Y.Node.ATTRS[name] = {
  64             getter: function() {
  65                 var args = Array.prototype.slice.call(arguments);
  66                 args.unshift(Y.Node.getDOMNode(this));
  67
  68                 return Y.DOM[name].apply(this, args);
  69             }
  70         };
  71     }
  72 );
  73
  74 Y.Node.ATTRS.scrollLeft = {
  75     getter: function() {
  76         var node = Y.Node.getDOMNode(this);
  77         return ('scrollLeft' in node) ? node.scrollLeft : Y.DOM.docScrollX(node);
  78     },
  79
  80     setter: function(val) {
  81         var node = Y.Node.getDOMNode(this);
  82         if (node) {
  83             if ('scrollLeft' in node) {
  84                 node.scrollLeft = val;
  85             } else if (node.document || node.nodeType === 9) {
  86                 Y.DOM._getWin(node).scrollTo(val, Y.DOM.docScrollY(node)); // scroll window if win or doc
  87             }
  88         } else {
  89         }
  90     }
  91 };
  92
  93 Y.Node.ATTRS.scrollTop = {
  94     getter: function() {
  95         var node = Y.Node.getDOMNode(this);
  96         return ('scrollTop' in node) ? node.scrollTop : Y.DOM.docScrollY(node);
  97     },
  98
  99     setter: function(val) {
 100         var node = Y.Node.getDOMNode(this);
 101         if (node) {
 102             if ('scrollTop' in node) {
 103                 node.scrollTop = val;
 104             } else if (node.document || node.nodeType === 9) {
 105                 Y.DOM._getWin(node).scrollTo(Y.DOM.docScrollX(node), val); // scroll window if win or doc
 106             }
 107         } else {
 108         }
 109     }
 110 };
 111
 112 Y.Node.importMethod(Y.DOM, [
 113 /**
 114  * Gets the current position of the node in page coordinates.
 115  * @method getXY
 116  * @for Node
 117  * @return {Array} The XY position of the node
 118 */
 119     'getXY',
 120
 121 /**
 122  * Set the position of the node in page coordinates, regardless of how the node is positioned.
 123  * @method setXY
 124  * @param {Array} xy Contains X & Y values for new position (coordinates are page-based)
 125  * @chainable
 126  */
 127     'setXY',
 128
 129 /**
 130  * Gets the current position of the node in page coordinates.
 131  * @method getX
 132  * @return {Int} The X position of the node
 133 */
 134     'getX',
 135
 136 /**
 137  * Set the position of the node in page coordinates, regardless of how the node is positioned.
 138  * @method setX
 139  * @param {Int} x X value for new position (coordinates are page-based)
 140  * @chainable
 141  */
 142     'setX',
 143
 144 /**
 145  * Gets the current position of the node in page coordinates.
 146  * @method getY
 147  * @return {Int} The Y position of the node
 148 */
 149     'getY',
 150
 151 /**
 152  * Set the position of the node in page coordinates, regardless of how the node is positioned.
 153  * @method setY
 154  * @param {Int} y Y value for new position (coordinates are page-based)
 155  * @chainable
 156  */
 157     'setY',
 158
 159 /**
 160  * Swaps the XY position of this node with another node.
 161  * @method swapXY
 162  * @param {Node | HTMLElement} otherNode The node to swap with.
 163  * @chainable
 164  */
 165     'swapXY'
 166 ]);
 167
 168 /**
 169  * @module node
 170  * @submodule node-screen
 171  */
 172
 173 /**
 174  * Returns a region object for the node
 175  * @config region
 176  * @for Node
 177  * @type Node
 178  */
 179 Y.Node.ATTRS.region = {
 180     getter: function() {
 181         var node = this.getDOMNode(),
 182             region;
 183
 184         if (node && !node.tagName) {
 185             if (node.nodeType === 9) { // document
 186                 node = node.documentElement;
 187             }
 188         }
 189         if (Y.DOM.isWindow(node)) {
 190             region = Y.DOM.viewportRegion(node);
 191         } else {
 192             region = Y.DOM.region(node);
 193         }
 194         return region;
 195     }
 196 };
 197
 198 /**
 199  * Returns a region object for the node's viewport
 200  * @config viewportRegion
 201  * @type Node
 202  */
 203 Y.Node.ATTRS.viewportRegion = {
 204     getter: function() {
 205         return Y.DOM.viewportRegion(Y.Node.getDOMNode(this));
 206     }
 207 };
 208
 209 Y.Node.importMethod(Y.DOM, 'inViewportRegion');
 210
 211 // these need special treatment to extract 2nd node arg
 212 /**
 213  * Compares the intersection of the node with another node or region
 214  * @method intersect
 215  * @for Node
 216  * @param {Node|Object} node2 The node or region to compare with.
 217  * @param {Object} altRegion An alternate region to use (rather than this node's).
 218  * @return {Object} An object representing the intersection of the regions.
 219  */
 220 Y.Node.prototype.intersect = function(node2, altRegion) {
 221     var node1 = Y.Node.getDOMNode(this);
 222     if (Y.instanceOf(node2, Y.Node)) { // might be a region object
 223         node2 = Y.Node.getDOMNode(node2);
 224     }
 225     return Y.DOM.intersect(node1, node2, altRegion);
 226 };
 227
 228 /**
 229  * Determines whether or not the node is within the giving region.
 230  * @method inRegion
 231  * @param {Node|Object} node2 The node or region to compare with.
 232  * @param {Boolean} all Whether or not all of the node must be in the region.
 233  * @param {Object} altRegion An alternate region to use (rather than this node's).
 234  * @return {Boolean} True if in region, false if not.
 235  */
 236 Y.Node.prototype.inRegion = function(node2, all, altRegion) {
 237     var node1 = Y.Node.getDOMNode(this);
 238     if (Y.instanceOf(node2, Y.Node)) { // might be a region object
 239         node2 = Y.Node.getDOMNode(node2);
 240     }
 241     return Y.DOM.inRegion(node1, node2, all, altRegion);
 242 };
 243
 244
 245 }, '3.13.0', {"requires": ["dom-screen", "node-base"]});