/* Copyright (c) 2007 Paul Bakaus (paul.bakaus@googlemail.com) and Brandon Aaron (brandon.aaron@gmail.com || http://brandonaaron.net)
 * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
 *
 * $LastChangedDate: 2007-06-22 04:38:37 +0200 (Fr, 22 Jun 2007) $
 * $Rev: 2141 $
 *
 * Version: 1.0b2
 */

(function($) {

    // store a copy of the core height and width methods
    var height = $.fn.height,
    width = $.fn.width;

    $.fn.extend({
        /**
        * If used on document, returns the document's height (innerHeight)
        * If used on window, returns the viewport's (window) height
        * See core docs on height() to see what happens when used on an element.
        *
        * @example $("#testdiv").height()
        * @result 200
        *
        * @example $(document).height()
        * @result 800
        *
        * @example $(window).height()
        * @result 400
        *
        * @name height
        * @type Object
        * @cat Plugins/Dimensions
        */
        height: function() {
            if (this[0] == window)
                return self.innerHeight ||
				$.boxModel && document.documentElement.clientHeight ||
				document.body.clientHeight;

            if (this[0] == document)
                return Math.max(document.body.scrollHeight, document.body.offsetHeight);

            return height.apply(this, arguments);
        },

        /**
        * If used on document, returns the document's width (innerWidth)
        * If used on window, returns the viewport's (window) width
        * See core docs on height() to see what happens when used on an element.
        *
        * @example $("#testdiv").width()
        * @result 200
        *
        * @example $(document).width()
        * @result 800
        *
        * @example $(window).width()
        * @result 400
        *
        * @name width
        * @type Object
        * @cat Plugins/Dimensions
        */
        width: function() {
            if (this[0] == window)
                return self.innerWidth ||
				$.boxModel && document.documentElement.clientWidth ||
				document.body.clientWidth;

            if (this[0] == document)
                return Math.max(document.body.scrollWidth, document.body.offsetWidth);

            return width.apply(this, arguments);
        },

        /**
        * Returns the inner height value (without border) for the first matched element.
        * If used on document, returns the document's height (innerHeight)
        * If used on window, returns the viewport's (window) height
        *
        * @example $("#testdiv").innerHeight()
        * @result 800
        *
        * @name innerHeight
        * @type Number
        * @cat Plugins/Dimensions
        */
        innerHeight: function() {
            return this[0] == window || this[0] == document ?
			this.height() :
			this.is(':visible') ?
				this[0].offsetHeight - num(this, 'borderTopWidth') - num(this, 'borderBottomWidth') :
				this.height() + num(this, 'paddingTop') + num(this, 'paddingBottom');
        },

        /**
        * Returns the inner width value (without border) for the first matched element.
        * If used on document, returns the document's Width (innerWidth)
        * If used on window, returns the viewport's (window) width
        *
        * @example $("#testdiv").innerWidth()
        * @result 1000
        *
        * @name innerWidth
        * @type Number
        * @cat Plugins/Dimensions
        */
        innerWidth: function() {
            return this[0] == window || this[0] == document ?
			this.width() :
			this.is(':visible') ?
				this[0].offsetWidth - num(this, 'borderLeftWidth') - num(this, 'borderRightWidth') :
				this.width() + num(this, 'paddingLeft') + num(this, 'paddingRight');
        },

        /**
        * Returns the outer height value (including border) for the first matched element.
        * Cannot be used on document or window.
        *
        * @example $("#testdiv").outerHeight()
        * @result 1000
        *
        * @name outerHeight
        * @type Number
        * @cat Plugins/Dimensions
        */
        outerHeight: function() {
            return this[0] == window || this[0] == document ?
			this.height() :
			this.is(':visible') ?
				this[0].offsetHeight :
				this.height() + num(this, 'borderTopWidth') + num(this, 'borderBottomWidth') + num(this, 'paddingTop') + num(this, 'paddingBottom');
        },

        /**
        * Returns the outer width value (including border) for the first matched element.
        * Cannot be used on document or window.
        *
        * @example $("#testdiv").outerHeight()
        * @result 1000
        *
        * @name outerHeight
        * @type Number
        * @cat Plugins/Dimensions
        */
        outerWidth: function() {
            return this[0] == window || this[0] == document ?
			this.width() :
			this.is(':visible') ?
				this[0].offsetWidth :
				this.width() + num(this, 'borderLeftWidth') + num(this, 'borderRightWidth') + num(this, 'paddingLeft') + num(this, 'paddingRight');
        },

        /**
        * Returns how many pixels the user has scrolled to the right (scrollLeft).
        * Works on containers with overflow: auto and window/document.
        *
        * @example $("#testdiv").scrollLeft()
        * @result 100
        *
        * @name scrollLeft
        * @type Number
        * @cat Plugins/Dimensions
        */
        /**
        * Sets the scrollLeft property and continues the chain.
        * Works on containers with overflow: auto and window/document.
        *
        * @example $("#testdiv").scrollLeft(10).scrollLeft()
        * @result 10
        *
        * @name scrollLeft
        * @param Number value A positive number representing the desired scrollLeft.
        * @type jQuery
        * @cat Plugins/Dimensions
        */
        scrollLeft: function(val) {
            if (val != undefined)
            // set the scroll left
                return this.each(function() {
                    if (this == window || this == document)
                        window.scrollTo(val, $(window).scrollTop());
                    else
                        this.scrollLeft = val;
                });

            // return the scroll left offest in pixels
            if (this[0] == window || this[0] == document)
                return self.pageXOffset ||
				$.boxModel && document.documentElement.scrollLeft ||
				document.body.scrollLeft;

            return this[0].scrollLeft;
        },

        /**
        * Returns how many pixels the user has scrolled to the bottom (scrollTop).
        * Works on containers with overflow: auto and window/document.
        *
        * @example $("#testdiv").scrollTop()
        * @result 100
        *
        * @name scrollTop
        * @type Number
        * @cat Plugins/Dimensions
        */
        /**
        * Sets the scrollTop property and continues the chain.
        * Works on containers with overflow: auto and window/document.
        *
        * @example $("#testdiv").scrollTop(10).scrollTop()
        * @result 10
        *
        * @name scrollTop
        * @param Number value A positive number representing the desired scrollTop.
        * @type jQuery
        * @cat Plugins/Dimensions
        */
        scrollTop: function(val) {
            if (val != undefined)
            // set the scroll top
                return this.each(function() {
                    if (this == window || this == document)
                        window.scrollTo($(window).scrollLeft(), val);
                    else
                        this.scrollTop = val;
                });

            // return the scroll top offset in pixels
            if (this[0] == window || this[0] == document)
                return self.pageYOffset ||
				$.boxModel && document.documentElement.scrollTop ||
				document.body.scrollTop;

            return this[0].scrollTop;
        },

        /** 
        * Returns the top and left positioned offset in pixels.
        * The positioned offset is the offset between a positioned
        * parent and the element itself.
        *
        * @example $("#testdiv").position()
        * @result { top: 100, left: 100 }
        * 
        * @name position
        * @param Map options Optional settings to configure the way the offset is calculated.
        * @option Boolean margin Should the margin of the element be included in the calculations? False by default.
        * @option Boolean border Should the border of the element be included in the calculations? False by default.
        * @option Boolean padding Should the padding of the element be included in the calculations? False by default.
        * @param Object returnObject An object to store the return value in, so as not to break the chain. If passed in the
        *                            chain will not be broken and the result will be assigned to this object.
        * @type Object
        * @cat Plugins/Dimensions
        */
        position: function(options, returnObject) {
            var elem = this[0], parent = elem.parentNode, op = elem.offsetParent,
		    options = $.extend({ margin: false, border: false, padding: false, scroll: false }, options || {}),
			x = elem.offsetLeft,
			y = elem.offsetTop,
			sl = elem.scrollLeft,
			st = elem.scrollTop;

            // Mozilla and IE do not add the border
            if ($.browser.mozilla || $.browser.msie) {
                // add borders to offset
                x += num(elem, 'borderLeftWidth');
                y += num(elem, 'borderTopWidth');
            }

            if ($.browser.mozilla) {
                do {
                    // Mozilla does not add the border for a parent that has overflow set to anything but visible
                    if ($.browser.mozilla && parent != elem && $.css(parent, 'overflow') != 'visible') {
                        x += num(parent, 'borderLeftWidth');
                        y += num(parent, 'borderTopWidth');
                    }

                    if (parent == op) break; // break if we are already at the offestParent
                } while ((parent = parent.parentNode) && (parent.tagName.toLowerCase() != 'body' || parent.tagName.toLowerCase() != 'html'));
            }

            var returnValue = handleOffsetReturn(elem, options, x, y, sl, st);

            if (returnObject) { $.extend(returnObject, returnValue); return this; }
            else { return returnValue; }
        },

        /**
        * Returns the location of the element in pixels from the top left corner of the viewport.
        *
        * For accurate readings make sure to use pixel values for margins, borders and padding.
        * 
        * Known issues:
        *  - Issue: A div positioned relative or static without any content before it and its parent will report an offsetTop of 0 in Safari
        *    Workaround: Place content before the relative div ... and set height and width to 0 and overflow to hidden
        *
        * @example $("#testdiv").offset()
        * @result { top: 100, left: 100, scrollTop: 10, scrollLeft: 10 }
        *
        * @example $("#testdiv").offset({ scroll: false })
        * @result { top: 90, left: 90 }
        *
        * @example var offset = {}
        * $("#testdiv").offset({ scroll: false }, offset)
        * @result offset = { top: 90, left: 90 }
        *
        * @name offset
        * @param Map options Optional settings to configure the way the offset is calculated.
        * @option Boolean margin Should the margin of the element be included in the calculations? True by default.
        * @option Boolean border Should the border of the element be included in the calculations? False by default.
        * @option Boolean padding Should the padding of the element be included in the calculations? False by default.
        * @option Boolean scroll Should the scroll offsets of the parent elements be included in the calculations? True by default.
        *                        When true it adds the totla scroll offets of all parents to the total offset and also adds two properties
        *                        to the returned object, scrollTop and scrollLeft. 
        * @options Boolean lite Will use offsetLite instead of offset when set to true. False by default.
        * @param Object returnObject An object to store the return value in, so as not to break the chain. If passed in the
        *                            chain will not be broken and the result will be assigned to this object.
        * @type Object
        * @cat Plugins/Dimensions
        */
        offset: function(options, returnObject) {
            var x = 0, y = 0, sl = 0, st = 0,
		    elem = this[0], parent = this[0], op, parPos, elemPos = $.css(elem, 'position'),
		    mo = $.browser.mozilla, ie = $.browser.msie, sf = $.browser.safari, oa = $.browser.opera,
		    absparent = false, relparent = false,
		    options = $.extend({ margin: true, border: false, padding: false, scroll: true, lite: false }, options || {});

            // Use offsetLite if lite option is true
            if (options.lite) return this.offsetLite(options, returnObject);

            if (elem.tagName.toLowerCase() == 'body') {
                // Safari is the only one to get offsetLeft and offsetTop properties of the body "correct"
                // Except they all mess up when the body is positioned absolute or relative
                x = elem.offsetLeft;
                y = elem.offsetTop;
                // Mozilla ignores margin and subtracts border from body element
                if (mo) {
                    x += num(elem, 'marginLeft') + (num(elem, 'borderLeftWidth') * 2);
                    y += num(elem, 'marginTop') + (num(elem, 'borderTopWidth') * 2);
                } else
                // Opera ignores margin
                    if (oa) {
                    x += num(elem, 'marginLeft');
                    y += num(elem, 'marginTop');
                } else
                // IE does not add the border in Standards Mode
                    if (ie && jQuery.boxModel) {
                    x += num(elem, 'borderLeftWidth');
                    y += num(elem, 'borderTopWidth');
                }
            } else {
                do {
                    parPos = $.css(parent, 'position');

                    x += parent.offsetLeft;
                    y += parent.offsetTop;

                    // Mozilla and IE do not add the border
                    if (mo || ie) {
                        // add borders to offset
                        x += num(parent, 'borderLeftWidth');
                        y += num(parent, 'borderTopWidth');

                        // Mozilla does not include the border on body if an element isn't positioned absolute and is without an absolute parent
                        if (mo && parPos == 'absolute') absparent = true;
                        // IE does not include the border on the body if an element is position static and without an absolute or relative parent
                        if (ie && parPos == 'relative') relparent = true;
                    }

                    op = parent.offsetParent;
                    if (options.scroll || mo) {
                        do {
                            if (options.scroll) {
                                // get scroll offsets
                                sl += parent.scrollLeft;
                                st += parent.scrollTop;
                            }

                            // Mozilla does not add the border for a parent that has overflow set to anything but visible
                            if (mo && parent != elem && $.css(parent, 'overflow') != 'visible') {
                                x += num(parent, 'borderLeftWidth');
                                y += num(parent, 'borderTopWidth');
                            }

                            parent = parent.parentNode;
                        } while (parent != op);
                    }
                    parent = op;

                    if (parent == null)
                        break;
                        
                    if (parent.tagName.toLowerCase() == 'body' || parent.tagName.toLowerCase() == 'html') {
                        // Safari and IE Standards Mode doesn't add the body margin for elments positioned with static or relative
                        if ((sf || (ie && $.boxModel)) && elemPos != 'absolute' && elemPos != 'fixed') {
                            x += num(parent, 'marginLeft');
                            y += num(parent, 'marginTop');
                        }
                        // Mozilla does not include the border on body if an element isn't positioned absolute and is without an absolute parent
                        // IE does not include the border on the body if an element is positioned static and without an absolute or relative parent
                        if ((mo && !absparent && elemPos != 'fixed') ||
					     (ie && elemPos == 'static' && !relparent)) {
                            x += num(parent, 'borderLeftWidth');
                            y += num(parent, 'borderTopWidth');
                        }
                        break; // Exit the loop
                    }
                } while (parent);
            }

            var returnValue = handleOffsetReturn(elem, options, x, y, sl, st);

            if (returnObject) { $.extend(returnObject, returnValue); return this; }
            else { return returnValue; }
        },

        /**
        * Returns the location of the element in pixels from the top left corner of the viewport.
        * This method is much faster than offset but not as accurate. This method can be invoked
        * by setting the lite option to true in the offset method.
        *
        * @name offsetLite
        * @param Map options Optional settings to configure the way the offset is calculated.
        * @option Boolean margin Should the margin of the element be included in the calculations? True by default.
        * @option Boolean border Should the border of the element be included in the calculations? False by default.
        * @option Boolean padding Should the padding of the element be included in the calculations? False by default.
        * @option Boolean scroll Should the scroll offsets of the parent elements be included in the calculations? True by default.
        *                        When true it adds the totla scroll offets of all parents to the total offset and also adds two properties
        *                        to the returned object, scrollTop and scrollLeft. 
        * @param Object returnObject An object to store the return value in, so as not to break the chain. If passed in the
        *                            chain will not be broken and the result will be assigned to this object.
        * @type Object
        * @cat Plugins/Dimensions
        */
        offsetLite: function(options, returnObject) {
            var x = 0, y = 0, sl = 0, st = 0, parent = this[0], op,
		    options = $.extend({ margin: true, border: false, padding: false, scroll: true }, options || {});

            do {
                x += parent.offsetLeft;
                y += parent.offsetTop;

                op = parent.offsetParent;
                if (options.scroll) {
                    // get scroll offsets
                    do {
                        sl += parent.scrollLeft;
                        st += parent.scrollTop;
                        parent = parent.parentNode;
                    } while (parent != op);
                }
                parent = op;
            } while (parent && parent.tagName.toLowerCase() != 'body' && parent.tagName.toLowerCase() != 'html');

            var returnValue = handleOffsetReturn(this[0], options, x, y, sl, st);

            if (returnObject) { $.extend(returnObject, returnValue); return this; }
            else { return returnValue; }
        }
    });

    /**
    * Handles converting a CSS Style into an Integer.
    * @private
    */
    var num = function(el, prop) {
        return parseInt($.css(el.jquery ? el[0] : el, prop)) || 0;
    };

    /**
    * Handles the return value of the offset and offsetLite methods.
    * @private
    */
    var handleOffsetReturn = function(elem, options, x, y, sl, st) {
        if (!options.margin) {
            x -= num(elem, 'marginLeft');
            y -= num(elem, 'marginTop');
        }

        // Safari and Opera do not add the border for the element
        if (options.border && ($.browser.safari || $.browser.opera)) {
            x += num(elem, 'borderLeftWidth');
            y += num(elem, 'borderTopWidth');
        } else if (!options.border && !($.browser.safari || $.browser.opera)) {
            x -= num(elem, 'borderLeftWidth');
            y -= num(elem, 'borderTopWidth');
        }

        if (options.padding) {
            x += num(elem, 'paddingLeft');
            y += num(elem, 'paddingTop');
        }

        // do not include scroll offset on the element
        if (options.scroll) {
            sl -= elem.scrollLeft;
            st -= elem.scrollTop;
        }

        return options.scroll ? { top: y - st, left: x - sl, scrollTop: st, scrollLeft: sl }
	                      : { top: y, left: x };
    };

})(jQuery);