/*

Copyright (c) 2009, Yahoo! Inc. All rights reserved.

Code licensed under the BSD License:

http://developer.yahoo.net/yui/license.txt

version: 3.0.0b1

build: 1163

*/

YUI.add('dom-screen', function(Y) {

(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',

    // TODO: how about thead/tbody/tfoot/tr?

    // TODO: does caption matter?

    RE_TABLE = /^t(?:able|d|h)$/i;

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) {

        var doc = Y.DOM._getDoc(node);

        return Math.max(doc[DOCUMENT_ELEMENT].scrollLeft, doc.body.scrollLeft);

    },

    /**

     * Amount page has been scroll vertically 

     * @method docScrollY

     * @return {Number} The current amount the screen is scrolled vertically.

     */

    docScrollY:  function(node) {

        var doc = Y.DOM._getDoc(node);

        return Math.max(doc[DOCUMENT_ELEMENT].scrollTop, doc.body.scrollTop);

    },

    /**

     * 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 (document[DOCUMENT_ELEMENT][GET_BOUNDING_CLIENT_RECT]) {

            return function(node) {

                var xy = null,

                    scrollLeft,

                    scrollTop,

                    box,

                    off1, off2,

                    bLeft, bTop,

                    mode,

                    doc;

                if (node) {

                    if (Y.DOM.inDoc(node)) {

                        scrollLeft = Y.DOM.docScrollX(node);

                        scrollTop = Y.DOM.docScrollY(node);

                        box = node[GET_BOUNDING_CLIENT_RECT]();

                        doc = Y.DOM._getDoc(node);

                        xy = [box.left, box.top];

                            if (Y.UA.ie) {

                                off1 = 2;

                                off2 = 2;

                                mode = doc[COMPAT_MODE];

                                bLeft = Y.DOM[GET_COMPUTED_STYLE](doc[DOCUMENT_ELEMENT], BORDER_LEFT_WIDTH);

                                bTop = Y.DOM[GET_COMPUTED_STYLE](doc[DOCUMENT_ELEMENT], BORDER_TOP_WIDTH);

                                if (Y.UA.ie === 6) {

                                    if (mode !== _BACK_COMPAT) {

                                        off1 = 0;

                                        off2 = 0;

                                    }

                                }

                                if ((mode == _BACK_COMPAT)) {

                                    if (bLeft !== MEDIUM) {

                                        off1 = parseInt(bLeft, 10);

                                    }

                                    if (bTop !== MEDIUM) {

                                        off2 = parseInt(bTop, 10);

                                    }

                                }

                                xy[0] -= off1;

                                xy[1] -= off2;

                            }

                        if ((scrollTop || scrollLeft)) {

                            xy[0] += scrollLeft;

                            xy[1] += scrollTop;

                        }

                    } else { // default to current offsets

                        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,

                    parentNode,

                    bCheck,

                    scrollTop,

                    scrollLeft;

                if (node) {

                    if (Y.DOM.inDoc(node)) {

                        xy = [node.offsetLeft, node.offsetTop];

                        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);

                            xy[1] += Y.DOM.docScrollY(node);

                        } else {

                            //Fix FIXED position -- add scrollbars

                            xy[0] += Y.DOM.docScrollX(node);

                            xy[1] += Y.DOM.docScrollY(node);

                        }

                    } else {

                        xy = Y.DOM._getOffset(node);

                    }

                }

                return xy;                

            };

        }

    }(),// NOTE: Executing for loadtime branching

    _getOffset: function(node) {

        var pos,

            xy = null;

        if (node) {

            pos = Y.DOM.getStyle(node, POSITION);

            xy = [

                parseInt(Y.DOM[GET_COMPUTED_STYLE](node, LEFT), 10),

                parseInt(Y.DOM[GET_COMPUTED_STYLE](node, TOP), 10)

            ];

            if ( isNaN(xy[0]) ) { // in case of 'auto'

                xy[0] = parseInt(Y.DOM.getStyle(node, LEFT), 10); // try inline

                if ( isNaN(xy[0]) ) { // default to offset value

                    xy[0] = (pos === RELATIVE) ? 0 : node.offsetLeft || 0;

                }

            } 

            if ( isNaN(xy[1]) ) { // in case of 'auto'

                xy[1] = parseInt(Y.DOM.getStyle(node, TOP), 10); // try inline

                if ( isNaN(xy[1]) ) { // default to offset value

                    xy[1] = (pos === RELATIVE) ? 0 : node.offsetTop || 0;

                }

            } 

        }

        return xy;

    },

    /**

     * 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 {Int} 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 {Int} 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 {Int} 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 {Int} y The Y values for new position (coordinates are page-based)

     */

    setY: function(node, y) {

        return Y.DOM.setXY(node, [null, y]);

    },

    _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) {

        var doc = Y.DOM._getDoc(),