function IESafeOffsetParent(elem)
{
    try
    {
       return elem.offsetParent;
    }
    catch(e)
    {        
      return document.body;
    }
}

/*
 * 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-03-27 16:29:43 -0500 (Tue, 27 Mar 2007) $
 * $Rev: 1601 $
 */

jQuery.fn._height = jQuery.fn.height;
jQuery.fn._width  = jQuery.fn.width;

/**
 * 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
 */
jQuery.fn.height = function() {
	if ( this[0] == window )
		return self.innerHeight ||
			jQuery.boxModel && document.documentElement.clientHeight ||
			document.body.clientHeight;

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

	return this._height(arguments[0]);
};

/**
 * 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
 */
jQuery.fn.width = function() {
	if ( this[0] == window )
		return self.innerWidth ||
			jQuery.boxModel && document.documentElement.clientWidth ||
			document.body.clientWidth;

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

	return this._width(arguments[0]);
};

/**
 * 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
 */
jQuery.fn.innerHeight = function() {
	return this[0] == window || this[0] == document ?
		this.height() :
		this.css('display') != 'none' ?
		 	this[0].offsetHeight - (parseInt(this.css("borderTopWidth")) || 0) - (parseInt(this.css("borderBottomWidth")) || 0) :
			this.height() + (parseInt(this.css("paddingTop")) || 0) + (parseInt(this.css("paddingBottom")) || 0);
};

/**
 * 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
 */
jQuery.fn.innerWidth = function() {
	return this[0] == window || this[0] == document ?
		this.width() :
		this.css('display') != 'none' ?
			this[0].offsetWidth - (parseInt(this.css("borderLeftWidth")) || 0) - (parseInt(this.css("borderRightWidth")) || 0) :
			this.height() + (parseInt(this.css("paddingLeft")) || 0) + (parseInt(this.css("paddingRight")) || 0);
};

/**
 * 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
 */
jQuery.fn.outerHeight = function() {
	return this[0] == window || this[0] == document ?
		this.height() :
		this.css('display') != 'none' ?
			this[0].offsetHeight :
			this.height() + (parseInt(this.css("borderTopWidth")) || 0) + (parseInt(this.css("borderBottomWidth")) || 0)
				+ (parseInt(this.css("paddingTop")) || 0) + (parseInt(this.css("paddingBottom")) || 0);
};

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

/**
 * 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
 */
jQuery.fn.scrollLeft = function() {
	if ( this[0] == window || this[0] == document )
		return self.pageXOffset ||
			jQuery.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
 */
jQuery.fn.scrollTop = function() {
	if ( this[0] == window || this[0] == document )
		return self.pageYOffset ||
			jQuery.boxModel && document.documentElement.scrollTop ||
			document.body.scrollTop;

	return this[0].scrollTop;
};

/**
 * 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.
 *
 * @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 Object options A hash of options describing what should be included in the final calculations of the offset.
 *                       The options include:
 *                           margin: Should the margin of the element be included in the calculations? True by default.
 *                                   If set to false the margin of the element is subtracted from the total offset.
 *                           border: Should the border of the element be included in the calculations? True by default.
 *                                   If set to false the border of the element is subtracted from the total offset.
 *                           padding: Should the padding of the element be included in the calculations? False by default.
 *                                    If set to true the padding of the element is added to the total offset.
 *                           scroll: Should the scroll offsets of the parent elements be included in the calculations?
 *                                   True by default. When true, it adds the total scroll offsets of all parents to the
 *                                   total offset and also adds two properties to the returned object, scrollTop and
 *                                   scrollLeft. If set to false the scroll offsets of parent elements are ignored.
 *                                   If scroll offsets are not needed, set to false to get a performance boost.
 * @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
 * @author Brandon Aaron (brandon.aaron@gmail.com || http://brandonaaron.net)
 */
jQuery.fn.offset = function() {
///     <summary>
///             Gets the current offset of the first matched element relative to the viewport.
///     </summary>
///     <returns type="Object">An object with two Integer properties, 'top' and 'left'.</returns>

var left = 0, top = 0, elem = this[0], results;

if ( elem ) with ( jQuery.browser ) {
        var parent         = elem.parentNode,
                offsetChild  = elem,
                offsetParent = IESafeOffsetParent(elem),
                doc               = elem.ownerDocument,
                safari2   = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
                css               = jQuery.curCSS,
                fixed           = css(elem, "position") == "fixed";

        // Use getBoundingClientRect if available
        if (false && elem.getBoundingClientRect) {
                var box = elem.getBoundingClientRect();

                // Add the document scroll offsets
                add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
                        box.top  + Math.max(doc.documentElement.scrollTop,  doc.body.scrollTop));

                // IE adds the HTML element's border, by default it is medium which is 2px
                // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
                // IE 7 standards mode, the border is always 2px
                // This border/offset is typically represented by the clientLeft and clientTop properties
                // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
                // Therefore this method will be off by 2px in IE while in quirksmode
                add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );

        // Otherwise loop through the offsetParents and parentNodes
        } else {

                // Initial element offsets
                add( elem.offsetLeft, elem.offsetTop );

                // Get parent offsets
                while ( offsetParent ) {
                        // Add offsetParent offsets
                        add( offsetParent.offsetLeft, offsetParent.offsetTop );

                        // Mozilla and Safari > 2 does not include the border on offset parents
                        // However Mozilla adds the border for table or table cells
                        if ( mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2 )
                                border( offsetParent );

                        // Add the document scroll offsets if position is fixed on any offsetParent
                        if ( !fixed && css(offsetParent, "position") == "fixed" )
                                fixed = true;

                        // Set offsetChild to previous offsetParent unless it is the body element
                        offsetChild  = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
                        // Get next offsetParent
                        offsetParent = offsetParent.offsetParent;
                }

                // Get parent scroll offsets
                while ( parent && parent.tagName && !/^body|html$/i.test(parent.tagName) ) {
                        // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
                        if ( !/^inline|table.*$/i.test(css(parent, "display")) )
                                // Subtract parent scroll offsets
                                add( -parent.scrollLeft, -parent.scrollTop );

                        // Mozilla does not add the border for a parent that has overflow != visible
                        if ( mozilla && css(parent, "overflow") != "visible" )
                                border( parent );

                        // Get next parent
                        parent = parent.parentNode;
                }

                // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
                // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
                if ( (safari2 && (fixed || css(offsetChild, "position") == "absolute")) ||
                        (mozilla && css(offsetChild, "position") != "absolute") )
                                add( -doc.body.offsetLeft, -doc.body.offsetTop );

                // Add the document scroll offsets if position is fixed
                if ( fixed )
                        add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
                                Math.max(doc.documentElement.scrollTop,  doc.body.scrollTop));
        }

        // Return an object with top and left properties
        results = { top: top, left: left };
}

function border(elem) {
        ///     <summary>
        ///             This method is internal.
        ///     </summary>
        ///     <private />
        add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
}

function add(l, t) {
        ///     <summary>
        ///             This method is internal.
        ///     </summary>
        ///     <private />
        left += parseInt(l, 10) || 0;
        top += parseInt(t, 10) || 0;
}

return results;
};