jssource/src_files/include/javascript/yui3/build/node/node-screen.js

   1 /*
   2 Copyright (c) 2010, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.com/yui/license.html
   5 version: 3.3.0
   6 build: 3167
   7 */
   8 YUI.add('node-screen', function(Y) {
   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 winHeight
  37      * @type {Int}
  38      */
  39     'docWidth',
  40
  41     /**
  42      * Document height
  43      * @config docHeight
  44      * @type {Int}
  45      */
  46     'docHeight',
  47
  48     /**
  49      * Amount page has been scroll vertically
  50      * @config docScrollX
  51      * @type {Int}
  52      */
  53     'docScrollX',
  54
  55     /**
  56      * Amount page has been scroll horizontally
  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 {Y.Node || HTMLElement} otherNode The node to swap with.
 163  * @chainable
 164  */
 165     'swapXY'
 166 ]);
 167
 168 /**
 169  * Returns a region object for the node
 170  * @config region
 171  * @for Node
 172  * @type Node
 173  */
 174 Y.Node.ATTRS.region = {
 175     getter: function() {
 176         var node = Y.Node.getDOMNode(this),
 177             region;
 178
 179         if (node && !node.tagName) {
 180             if (node.nodeType === 9) { // document
 181                 node = node.documentElement;
 182             }
 183         }
 184         if (node.alert) {
 185             region = Y.DOM.viewportRegion(node);
 186         } else {
 187             region = Y.DOM.region(node);
 188         }
 189         return region;
 190     }
 191 };
 192
 193 /**
 194  * Returns a region object for the node's viewport
 195  * @config viewportRegion
 196  * @type Node
 197  */
 198 Y.Node.ATTRS.viewportRegion = {
 199     getter: function() {
 200         return Y.DOM.viewportRegion(Y.Node.getDOMNode(this));
 201     }
 202 };
 203
 204 Y.Node.importMethod(Y.DOM, 'inViewportRegion');
 205
 206 // these need special treatment to extract 2nd node arg
 207 /**
 208  * Compares the intersection of the node with another node or region
 209  * @method intersect
 210  * @for Node
 211  * @param {Node|Object} node2 The node or region to compare with.
 212  * @param {Object} altRegion An alternate region to use (rather than this node's).
 213  * @return {Object} An object representing the intersection of the regions.
 214  */
 215 Y.Node.prototype.intersect = function(node2, altRegion) {
 216     var node1 = Y.Node.getDOMNode(this);
 217     if (Y.instanceOf(node2, Y.Node)) { // might be a region object
 218         node2 = Y.Node.getDOMNode(node2);
 219     }
 220     return Y.DOM.intersect(node1, node2, altRegion);
 221 };
 222
 223 /**
 224  * Determines whether or not the node is within the giving region.
 225  * @method inRegion
 226  * @param {Node|Object} node2 The node or region to compare with.
 227  * @param {Boolean} all Whether or not all of the node must be in the region.
 228  * @param {Object} altRegion An alternate region to use (rather than this node's).
 229  * @return {Object} An object representing the intersection of the regions.
 230  */
 231 Y.Node.prototype.inRegion = function(node2, all, altRegion) {
 232     var node1 = Y.Node.getDOMNode(this);
 233     if (Y.instanceOf(node2, Y.Node)) { // might be a region object
 234         node2 = Y.Node.getDOMNode(node2);
 235     }
 236     return Y.DOM.inRegion(node1, node2, all, altRegion);
 237 };
 238
 239
 240 }, '3.3.0' ,{requires:['dom-screen']});