jquery-ui-1.10.3/ui/jquery.ui.position.js

/*!
 * jQuery UI Position 1.10.3
 * http://jqueryui.com
 *
 * Copyright 2013 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/position/
 */
(function( $, undefined ) {

$.ui = $.ui || {};

var cachedScrollbarWidth,
        max = Math.max,
        abs = Math.abs,
        round = Math.round,
        rhorizontal = /left|center|right/,
        rvertical = /top|center|bottom/,
        roffset = /[\+\-]\d+(\.[\d]+)?%?/,
        rposition = /^\w+/,
        rpercent = /%$/,
        _position = $.fn.position;

function getOffsets( offsets, width, height ) {
        return [
                parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
                parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
        ];
}

function parseCss( element, property ) {
        return parseInt( $.css( element, property ), 10 ) || 0;
}

function getDimensions( elem ) {
        var raw = elem[0];
        if ( raw.nodeType === 9 ) {
                return {
                        width: elem.width(),
                        height: elem.height(),
                        offset: { top: 0, left: 0 }
                };
        }
        if ( $.isWindow( raw ) ) {
                return {
                        width: elem.width(),
                        height: elem.height(),
                        offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
                };
        }
        if ( raw.preventDefault ) {
                return {
                        width: 0,
                        height: 0,
                        offset: { top: raw.pageY, left: raw.pageX }
                };
        }
        return {
                width: elem.outerWidth(),
                height: elem.outerHeight(),
                offset: elem.offset()
        };
}

$.position = {
        scrollbarWidth: function() {
                if ( cachedScrollbarWidth !== undefined ) {
                        return cachedScrollbarWidth;
                }
                var w1, w2,
                        div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
                        innerDiv = div.children()[0];

                $( "body" ).append( div );
                w1 = innerDiv.offsetWidth;
                div.css( "overflow", "scroll" );

                w2 = innerDiv.offsetWidth;

                if ( w1 === w2 ) {
                        w2 = div[0].clientWidth;
                }

                div.remove();

                return (cachedScrollbarWidth = w1 - w2);
        },
        getScrollInfo: function( within ) {
                var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
                        overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
                        hasOverflowX = overflowX === "scroll" ||
                                ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
                        hasOverflowY = overflowY === "scroll" ||
                                ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
                return {
                        width: hasOverflowY ? $.position.scrollbarWidth() : 0,
                        height: hasOverflowX ? $.position.scrollbarWidth() : 0
                };
        },
        getWithinInfo: function( element ) {
                var withinElement = $( element || window ),
                        isWindow = $.isWindow( withinElement[0] );
                return {
                        element: withinElement,
                        isWindow: isWindow,
                        offset: withinElement.offset() || { left: 0, top: 0 },
                        scrollLeft: withinElement.scrollLeft(),
                        scrollTop: withinElement.scrollTop(),
                        width: isWindow ? withinElement.width() : withinElement.outerWidth(),
                        height: isWindow ? withinElement.height() : withinElement.outerHeight()
                };
        }
};

$.fn.position = function( options ) {
        if ( !options || !options.of ) {
                return _position.apply( this, arguments );
        }

        // make a copy, we don't want to modify arguments
        options = $.extend( {}, options );

        var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
                target = $( options.of ),
                within = $.position.getWithinInfo( options.within ),
                scrollInfo = $.position.getScrollInfo( within ),
                collision = ( options.collision || "flip" ).split( " " ),
                offsets = {};

        dimensions = getDimensions( target );
        if ( target[0].preventDefault ) {
                // force left top to allow flipping
                options.at = "left top";
        }
        targetWidth = dimensions.width;
        targetHeight = dimensions.height;
        targetOffset = dimensions.offset;
        // clone to reuse original targetOffset later
        basePosition = $.extend( {}, targetOffset );

        // force my and at to have valid horizontal and vertical positions
        // if a value is missing or invalid, it will be converted to center
        $.each( [ "my", "at" ], function() {
                var pos = ( options[ this ] || "" ).split( " " ),
                        horizontalOffset,
                        verticalOffset;

                if ( pos.length === 1) {
                        pos = rhorizontal.test( pos[ 0 ] ) ?
                                pos.concat( [ "center" ] ) :
                                rvertical.test( pos[ 0 ] ) ?
                                        [ "center" ].concat( pos ) :
                                        [ "center", "center" ];
                }
                pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
                pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";

                // calculate offsets
                horizontalOffset = roffset.exec( pos[ 0 ] );
                verticalOffset = roffset.exec( pos[ 1 ] );
                offsets[ this ] = [
                        horizontalOffset ? horizontalOffset[ 0 ] : 0,
                        verticalOffset ? verticalOffset[ 0 ] : 0
                ];

                // reduce to just the positions without the offsets
                options[ this ] = [
                        rposition.exec( pos[ 0 ] )[ 0 ],
                        rposition.exec( pos[ 1 ] )[ 0 ]
                ];
        });

        // normalize collision option
        if ( collision.length === 1 ) {
                collision[ 1 ] = collision[ 0 ];
        }

        if ( options.at[ 0 ] === "right" ) {
                basePosition.left += targetWidth;
        } else if ( options.at[ 0 ] === "center" ) {
                basePosition.left += targetWidth / 2;
        }

        if ( options.at[ 1 ] === "bottom" ) {
                basePosition.top += targetHeight;
        } else if ( options.at[ 1 ] === "center" ) {
                basePosition.top += targetHeight / 2;
        }

        atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
        basePosition.left += atOffset[ 0 ];
        basePosition.top += atOffset[ 1 ];

        return this.each(function() {
                var collisionPosition, using,
                        elem = $( this ),
                        elemWidth = elem.outerWidth(),
                        elemHeight = elem.outerHeight(),
                        marginLeft = parseCss( this, "marginLeft" ),
                        marginTop = parseCss( this, "marginTop" ),
                        collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
                        collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
                        position = $.extend( {}, basePosition ),
                        myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );

                if ( options.my[ 0 ] === "right" ) {
                        position.left -= elemWidth;
                } else if ( options.my[ 0 ] === "center" ) {
                        position.left -= elemWidth / 2;
                }

                if ( options.my[ 1 ] === "bottom" ) {
                        position.top -= elemHeight;
                } else if ( options.my[ 1 ] === "center" ) {
                        position.top -= elemHeight / 2;
                }

                position.left += myOffset[ 0 ];
                position.top += myOffset[ 1 ];

                // if the browser doesn't support fractions, then round for consistent results
                if ( !$.support.offsetFractions ) {
                        position.left = round( position.left );
                        position.top = round( position.top );
                }

                collisionPosition = {
                        marginLeft: marginLeft,
                        marginTop: marginTop
                };

                $.each( [ "left", "top" ], function( i, dir ) {
                        if ( $.ui.position[ collision[ i ] ] ) {
                                $.ui.position[ collision[ i ] ][ dir ]( position, {
                                        targetWidth: targetWidth,
                                        targetHeight: targetHeight,
                                        elemWidth: elemWidth,
                                        elemHeight: elemHeight,
                                        collisionPosition: collisionPosition,
                                        collisionWidth: collisionWidth,
                                        collisionHeight: collisionHeight,
                                        offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
                                        my: options.my,
                                        at: options.at,
                                        within: within,
                                        elem : elem
                                });
                        }
                });

                if ( options.using ) {
                        // adds feedback as second argument to using callback, if present
                        using = function( props ) {
                                var left = targetOffset.left - position.left,
                                        right = left + targetWidth - elemWidth,
                                        top = targetOffset.top - position.top,
                                        bottom = top + targetHeight - elemHeight,
                                        feedback = {
                                                target: {
                                                        element: target,
                                                        left: targetOffset.left,
                                                        top: targetOffset.top,
                                                        width: targetWidth,
                                                        height: targetHeight
                                                },
                                                element: {
                                                        element: elem,
                                                        left: position.left,
                                                        top: position.top,
                                                        width: elemWidth,
                                                        height: elemHeight
                                                },
                                                horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
                                                vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
                                        };
                                if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
                                        feedback.horizontal = "center";
                                }
                                if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
                                        feedback.vertical = "middle";
                                }
                                if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
                                        feedback.important = "horizontal";
                                } else {
                                        feedback.important = "vertical";
                                }
                                options.using.call( this, props, feedback );
                        };
                }

                elem.offset( $.extend( position, { using: using } ) );
        });
};

$.ui.position = {
        fit: {
                left: function( position, data ) {
                        var within = data.within,
                                withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
                                outerWidth = within.width,
                                collisionPosLeft = position.left - data.collisionPosition.marginLeft,
                                overLeft = withinOffset - collisionPosLeft,
                                overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
                                newOverRight;

                        // element is wider than within
                        if ( data.collisionWidth > outerWidth ) {
                                // element is initially over the left side of within
                                if ( overLeft > 0 && overRight <= 0 ) {
                                        newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
                                        position.left += overLeft - newOverRight;
                                // element is initially over right side of within
                                } else if ( overRight > 0 && overLeft <= 0 ) {
                                        position.left = withinOffset;
                                // element is initially over both left and right sides of within
                                } else {
                                        if ( overLeft > overRight ) {
                                                position.left = withinOffset + outerWidth - data.collisionWidth;
                                        } else {
                                                position.left = withinOffset;
                                        }
                                }
                        // too far left -> align with left edge
                        } else if ( overLeft > 0 ) {
                                position.left += overLeft;
                        // too far right -> align with right edge
                        } else if ( overRight > 0 ) {
                                position.left -= overRight;
                        // adjust based on position and margin
                        } else {
                                position.left = max( position.left - collisionPosLeft, position.left );
                        }
                },
                top: function( position, data ) {
                        var within = data.within,
                                withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
                                outerHeight = data.within.height,
                                collisionPosTop = position.top - data.collisionPosition.marginTop,
                                overTop = withinOffset - collisionPosTop,
                                overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
                                newOverBottom;

                        // element is taller than within
                        if ( data.collisionHeight > outerHeight ) {
                                // element is initially over the top of within
                                if ( overTop > 0 && overBottom <= 0 ) {
                                        newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
                                        position.top += overTop - newOverBottom;
                                // element is initially over bottom of within
                                } else if ( overBottom > 0 && overTop <= 0 ) {
                                        position.top = withinOffset;
                                // element is initially over both top and bottom of within
                                } else {
                                        if ( overTop > overBottom ) {
                                                position.top = withinOffset + outerHeight - data.collisionHeight;
                                        } else {
                                                position.top = withinOffset;
                                        }
                                }
                        // too far up -> align with top
                        } else if ( overTop > 0 ) {
                                position.top += overTop;
                        // too far down -> align with bottom edge
                        } else if ( overBottom > 0 ) {
                                position.top -= overBottom;
                        // adjust based on position and margin
                        } else {
                                position.top = max( position.top - collisionPosTop, position.top );
                        }
                }
        },
        flip: {
                left: function( position, data ) {
                        var within = data.within,
                                withinOffset = within.offset.left + within.scrollLeft,
                                outerWidth = within.width,
                                offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
                                collisionPosLeft = position.left - data.collisionPosition.marginLeft,
                                overLeft = collisionPosLeft - offsetLeft,
                                overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
                                myOffset = data.my[ 0 ] === "left" ?
                                        -data.elemWidth :
                                        data.my[ 0 ] === "right" ?
                                                data.elemWidth :
                                                0,
                                atOffset = data.at[ 0 ] === "left" ?
                                        data.targetWidth :
                                        data.at[ 0 ] === "right" ?
                                                -data.targetWidth :
                                                0,
                                offset = -2 * data.offset[ 0 ],
                                newOverRight,
                                newOverLeft;

                        if ( overLeft < 0 ) {
                                newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
                                if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
                                        position.left += myOffset + atOffset + offset;
                                }
                        }
                        else if ( overRight > 0 ) {
                                newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
                                if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
                                        position.left += myOffset + atOffset + offset;
                                }
                        }
                },
                top: function( position, data ) {
                        var within = data.within,
                                withinOffset = within.offset.top + within.scrollTop,
                                outerHeight = within.height,
                                offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
                                collisionPosTop = position.top - data.collisionPosition.marginTop,
                                overTop = collisionPosTop - offsetTop,
                                overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
                                top = data.my[ 1 ] === "top",
                                myOffset = top ?
                                        -data.elemHeight :
                                        data.my[ 1 ] === "bottom" ?
                                                data.elemHeight :
                                                0,
                                atOffset = data.at[ 1 ] === "top" ?
                                        data.targetHeight :
                                        data.at[ 1 ] === "bottom" ?
                                                -data.targetHeight :
                                                0,
                                offset = -2 * data.offset[ 1 ],
                                newOverTop,
                                newOverBottom;
                        if ( overTop < 0 ) {
                                newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
                                if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
                                        position.top += myOffset + atOffset + offset;
                                }
                        }
                        else if ( overBottom > 0 ) {
                                newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
                                if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
                                        position.top += myOffset + atOffset + offset;
                                }
                        }
                }
        },
        flipfit: {
                left: function() {
                        $.ui.position.flip.left.apply( this, arguments );
                        $.ui.position.fit.left.apply( this, arguments );
                },
                top: function() {
                        $.ui.position.flip.top.apply( this, arguments );
                        $.ui.position.fit.top.apply( this, arguments );
                }
        }
};

// fraction support test
(function () {
        var testElement, testElementParent, testElementStyle, offsetLeft, i,
                body = document.getElementsByTagName( "body" )[ 0 ],
                div = document.createElement( "div" );

        //Create a "fake body" for testing based on method used in jQuery.support
        testElement = document.createElement( body ? "div" : "body" );
        testElementStyle = {
                visibility: "hidden",
                width: 0,
                height: 0,
                border: 0,
                margin: 0,
                background: "none"
        };
        if ( body ) {
                $.extend( testElementStyle, {
                        position: "absolute",
                        left: "-1000px",
                        top: "-1000px"
                });
        }
        for ( i in testElementStyle ) {
                testElement.style[ i ] = testElementStyle[ i ];
        }
        testElement.appendChild( div );
        testElementParent = body || document.documentElement;
        testElementParent.insertBefore( testElement, testElementParent.firstChild );

        div.style.cssText = "position: absolute; left: 10.7432222px;";

        offsetLeft = $( div ).offset().left;
        $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;

        testElement.innerHTML = "";
        testElementParent.removeChild( testElement );
})();

}( jQuery ) );
1	/*!
2	* jQuery UI Position 1.10.3
3	* http://jqueryui.com
4	*
5	* Copyright 2013 jQuery Foundation and other contributors
6	* Released under the MIT license.
7	* http://jquery.org/license
8	*
9	* http://api.jqueryui.com/position/
10	*/
11	(function( $, undefined ) {
12
13	$.ui = $.ui \|\| {};
14
15	var cachedScrollbarWidth,
16	max = Math.max,
17	abs = Math.abs,
18	round = Math.round,
19	rhorizontal = /left\|center\|right/,
20	rvertical = /top\|center\|bottom/,
21	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
22	rposition = /^\w+/,
23	rpercent = /%$/,
24	_position = $.fn.position;
25
26	function getOffsets( offsets, width, height ) {
27	return [
28	parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
29	parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
30	];
31	}
32
33	function parseCss( element, property ) {
34	return parseInt( $.css( element, property ), 10 ) \|\| 0;
35	}
36
37	function getDimensions( elem ) {
38	var raw = elem[0];
39	if ( raw.nodeType === 9 ) {
40	return {
41	width: elem.width(),
42	height: elem.height(),
43	offset: { top: 0, left: 0 }
44	};
45	}
46	if ( $.isWindow( raw ) ) {
47	return {
48	width: elem.width(),
49	height: elem.height(),
50	offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
51	};
52	}
53	if ( raw.preventDefault ) {
54	return {
55	width: 0,
56	height: 0,
57	offset: { top: raw.pageY, left: raw.pageX }
58	};
59	}
60	return {
61	width: elem.outerWidth(),
62	height: elem.outerHeight(),
63	offset: elem.offset()
64	};
65	}
66
67	$.position = {
68	scrollbarWidth: function() {
69	if ( cachedScrollbarWidth !== undefined ) {
70	return cachedScrollbarWidth;
71	}
72	var w1, w2,
73	div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
74	innerDiv = div.children()[0];
75
76	$( "body" ).append( div );
77	w1 = innerDiv.offsetWidth;
78	div.css( "overflow", "scroll" );
79
80	w2 = innerDiv.offsetWidth;
81
82	if ( w1 === w2 ) {
83	w2 = div[0].clientWidth;
84	}
85
86	div.remove();
87
88	return (cachedScrollbarWidth = w1 - w2);
89	},
90	getScrollInfo: function( within ) {
91	var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
92	overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
93	hasOverflowX = overflowX === "scroll" \|\|
94	( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
95	hasOverflowY = overflowY === "scroll" \|\|
96	( overflowY === "auto" && within.height < within.element[0].scrollHeight );
97	return {
98	width: hasOverflowY ? $.position.scrollbarWidth() : 0,
99	height: hasOverflowX ? $.position.scrollbarWidth() : 0
100	};
101	},
102	getWithinInfo: function( element ) {
103	var withinElement = $( element \|\| window ),
104	isWindow = $.isWindow( withinElement[0] );
105	return {
106	element: withinElement,
107	isWindow: isWindow,
108	offset: withinElement.offset() \|\| { left: 0, top: 0 },
109	scrollLeft: withinElement.scrollLeft(),
110	scrollTop: withinElement.scrollTop(),
111	width: isWindow ? withinElement.width() : withinElement.outerWidth(),
112	height: isWindow ? withinElement.height() : withinElement.outerHeight()
113	};
114	}
115	};
116
117	$.fn.position = function( options ) {
118	if ( !options \|\| !options.of ) {
119	return _position.apply( this, arguments );
120	}
121
122	// make a copy, we don't want to modify arguments
123	options = $.extend( {}, options );
124
125	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
126	target = $( options.of ),
127	within = $.position.getWithinInfo( options.within ),
128	scrollInfo = $.position.getScrollInfo( within ),
129	collision = ( options.collision \|\| "flip" ).split( " " ),
130	offsets = {};
131
132	dimensions = getDimensions( target );
133	if ( target[0].preventDefault ) {
134	// force left top to allow flipping
135	options.at = "left top";
136	}
137	targetWidth = dimensions.width;
138	targetHeight = dimensions.height;
139	targetOffset = dimensions.offset;
140	// clone to reuse original targetOffset later
141	basePosition = $.extend( {}, targetOffset );
142
143	// force my and at to have valid horizontal and vertical positions
144	// if a value is missing or invalid, it will be converted to center
145	$.each( [ "my", "at" ], function() {
146	var pos = ( options[ this ] \|\| "" ).split( " " ),
147	horizontalOffset,
148	verticalOffset;
149
150	if ( pos.length === 1) {
151	pos = rhorizontal.test( pos[ 0 ] ) ?
152	pos.concat( [ "center" ] ) :
153	rvertical.test( pos[ 0 ] ) ?
154	[ "center" ].concat( pos ) :
155	[ "center", "center" ];
156	}
157	pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
158	pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
159
160	// calculate offsets
161	horizontalOffset = roffset.exec( pos[ 0 ] );
162	verticalOffset = roffset.exec( pos[ 1 ] );
163	offsets[ this ] = [
164	horizontalOffset ? horizontalOffset[ 0 ] : 0,
165	verticalOffset ? verticalOffset[ 0 ] : 0
166	];
167
168	// reduce to just the positions without the offsets
169	options[ this ] = [
170	rposition.exec( pos[ 0 ] )[ 0 ],
171	rposition.exec( pos[ 1 ] )[ 0 ]
172	];
173	});
174
175	// normalize collision option
176	if ( collision.length === 1 ) {
177	collision[ 1 ] = collision[ 0 ];
178	}
179
180	if ( options.at[ 0 ] === "right" ) {
181	basePosition.left += targetWidth;
182	} else if ( options.at[ 0 ] === "center" ) {
183	basePosition.left += targetWidth / 2;
184	}
185
186	if ( options.at[ 1 ] === "bottom" ) {
187	basePosition.top += targetHeight;
188	} else if ( options.at[ 1 ] === "center" ) {
189	basePosition.top += targetHeight / 2;
190	}
191
192	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
193	basePosition.left += atOffset[ 0 ];
194	basePosition.top += atOffset[ 1 ];
195
196	return this.each(function() {
197	var collisionPosition, using,
198	elem = $( this ),
199	elemWidth = elem.outerWidth(),
200	elemHeight = elem.outerHeight(),
201	marginLeft = parseCss( this, "marginLeft" ),
202	marginTop = parseCss( this, "marginTop" ),
203	collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
204	collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
205	position = $.extend( {}, basePosition ),
206	myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
207
208	if ( options.my[ 0 ] === "right" ) {
209	position.left -= elemWidth;
210	} else if ( options.my[ 0 ] === "center" ) {
211	position.left -= elemWidth / 2;
212	}
213
214	if ( options.my[ 1 ] === "bottom" ) {
215	position.top -= elemHeight;
216	} else if ( options.my[ 1 ] === "center" ) {
217	position.top -= elemHeight / 2;
218	}
219
220	position.left += myOffset[ 0 ];
221	position.top += myOffset[ 1 ];
222
223	// if the browser doesn't support fractions, then round for consistent results
224	if ( !$.support.offsetFractions ) {
225	position.left = round( position.left );
226	position.top = round( position.top );
227	}
228
229	collisionPosition = {
230	marginLeft: marginLeft,
231	marginTop: marginTop
232	};
233
234	$.each( [ "left", "top" ], function( i, dir ) {
235	if ( $.ui.position[ collision[ i ] ] ) {
236	$.ui.position[ collision[ i ] ][ dir ]( position, {
237	targetWidth: targetWidth,
238	targetHeight: targetHeight,
239	elemWidth: elemWidth,
240	elemHeight: elemHeight,
241	collisionPosition: collisionPosition,
242	collisionWidth: collisionWidth,
243	collisionHeight: collisionHeight,
244	offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
245	my: options.my,
246	at: options.at,
247	within: within,
248	elem : elem
249	});
250	}
251	});
252
253	if ( options.using ) {
254	// adds feedback as second argument to using callback, if present
255	using = function( props ) {
256	var left = targetOffset.left - position.left,
257	right = left + targetWidth - elemWidth,
258	top = targetOffset.top - position.top,
259	bottom = top + targetHeight - elemHeight,
260	feedback = {
261	target: {
262	element: target,
263	left: targetOffset.left,
264	top: targetOffset.top,
265	width: targetWidth,
266	height: targetHeight
267	},
268	element: {
269	element: elem,
270	left: position.left,
271	top: position.top,
272	width: elemWidth,
273	height: elemHeight
274	},
275	horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
276	vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
277	};
278	if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
279	feedback.horizontal = "center";
280	}
281	if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
282	feedback.vertical = "middle";
283	}
284	if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
285	feedback.important = "horizontal";
286	} else {
287	feedback.important = "vertical";
288	}
289	options.using.call( this, props, feedback );
290	};
291	}
292
293	elem.offset( $.extend( position, { using: using } ) );
294	});
295	};
296
297	$.ui.position = {
298	fit: {
299	left: function( position, data ) {
300	var within = data.within,
301	withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
302	outerWidth = within.width,
303	collisionPosLeft = position.left - data.collisionPosition.marginLeft,
304	overLeft = withinOffset - collisionPosLeft,
305	overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
306	newOverRight;
307
308	// element is wider than within
309	if ( data.collisionWidth > outerWidth ) {
310	// element is initially over the left side of within
311	if ( overLeft > 0 && overRight <= 0 ) {
312	newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
313	position.left += overLeft - newOverRight;
314	// element is initially over right side of within
315	} else if ( overRight > 0 && overLeft <= 0 ) {
316	position.left = withinOffset;
317	// element is initially over both left and right sides of within
318	} else {
319	if ( overLeft > overRight ) {
320	position.left = withinOffset + outerWidth - data.collisionWidth;
321	} else {
322	position.left = withinOffset;
323	}
324	}
325	// too far left -> align with left edge
326	} else if ( overLeft > 0 ) {
327	position.left += overLeft;
328	// too far right -> align with right edge
329	} else if ( overRight > 0 ) {
330	position.left -= overRight;
331	// adjust based on position and margin
332	} else {
333	position.left = max( position.left - collisionPosLeft, position.left );
334	}
335	},
336	top: function( position, data ) {
337	var within = data.within,
338	withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
339	outerHeight = data.within.height,
340	collisionPosTop = position.top - data.collisionPosition.marginTop,
341	overTop = withinOffset - collisionPosTop,
342	overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
343	newOverBottom;
344
345	// element is taller than within
346	if ( data.collisionHeight > outerHeight ) {
347	// element is initially over the top of within
348	if ( overTop > 0 && overBottom <= 0 ) {
349	newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
350	position.top += overTop - newOverBottom;
351	// element is initially over bottom of within
352	} else if ( overBottom > 0 && overTop <= 0 ) {
353	position.top = withinOffset;
354	// element is initially over both top and bottom of within
355	} else {
356	if ( overTop > overBottom ) {
357	position.top = withinOffset + outerHeight - data.collisionHeight;
358	} else {
359	position.top = withinOffset;
360	}
361	}
362	// too far up -> align with top
363	} else if ( overTop > 0 ) {
364	position.top += overTop;
365	// too far down -> align with bottom edge
366	} else if ( overBottom > 0 ) {
367	position.top -= overBottom;
368	// adjust based on position and margin
369	} else {
370	position.top = max( position.top - collisionPosTop, position.top );
371	}
372	}
373	},
374	flip: {
375	left: function( position, data ) {
376	var within = data.within,
377	withinOffset = within.offset.left + within.scrollLeft,
378	outerWidth = within.width,
379	offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
380	collisionPosLeft = position.left - data.collisionPosition.marginLeft,
381	overLeft = collisionPosLeft - offsetLeft,
382	overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
383	myOffset = data.my[ 0 ] === "left" ?
384	-data.elemWidth :
385	data.my[ 0 ] === "right" ?
386	data.elemWidth :
387	0,
388	atOffset = data.at[ 0 ] === "left" ?
389	data.targetWidth :
390	data.at[ 0 ] === "right" ?
391	-data.targetWidth :
392	0,
393	offset = -2 * data.offset[ 0 ],
394	newOverRight,
395	newOverLeft;
396
397	if ( overLeft < 0 ) {
398	newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
399	if ( newOverRight < 0 \|\| newOverRight < abs( overLeft ) ) {
400	position.left += myOffset + atOffset + offset;
401	}
402	}
403	else if ( overRight > 0 ) {
404	newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
405	if ( newOverLeft > 0 \|\| abs( newOverLeft ) < overRight ) {
406	position.left += myOffset + atOffset + offset;
407	}
408	}
409	},
410	top: function( position, data ) {
411	var within = data.within,
412	withinOffset = within.offset.top + within.scrollTop,
413	outerHeight = within.height,
414	offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
415	collisionPosTop = position.top - data.collisionPosition.marginTop,
416	overTop = collisionPosTop - offsetTop,
417	overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
418	top = data.my[ 1 ] === "top",
419	myOffset = top ?
420	-data.elemHeight :
421	data.my[ 1 ] === "bottom" ?
422	data.elemHeight :
423	0,
424	atOffset = data.at[ 1 ] === "top" ?
425	data.targetHeight :
426	data.at[ 1 ] === "bottom" ?
427	-data.targetHeight :
428	0,
429	offset = -2 * data.offset[ 1 ],
430	newOverTop,
431	newOverBottom;
432	if ( overTop < 0 ) {
433	newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
434	if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 \|\| newOverBottom < abs( overTop ) ) ) {
435	position.top += myOffset + atOffset + offset;
436	}
437	}
438	else if ( overBottom > 0 ) {
439	newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
440	if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 \|\| abs( newOverTop ) < overBottom ) ) {
441	position.top += myOffset + atOffset + offset;
442	}
443	}
444	}
445	},
446	flipfit: {
447	left: function() {
448	$.ui.position.flip.left.apply( this, arguments );
449	$.ui.position.fit.left.apply( this, arguments );
450	},
451	top: function() {
452	$.ui.position.flip.top.apply( this, arguments );
453	$.ui.position.fit.top.apply( this, arguments );
454	}
455	}
456	};
457
458	// fraction support test
459	(function () {
460	var testElement, testElementParent, testElementStyle, offsetLeft, i,
461	body = document.getElementsByTagName( "body" )[ 0 ],
462	div = document.createElement( "div" );
463
464	//Create a "fake body" for testing based on method used in jQuery.support
465	testElement = document.createElement( body ? "div" : "body" );
466	testElementStyle = {
467	visibility: "hidden",
468	width: 0,
469	height: 0,
470	border: 0,
471	margin: 0,
472	background: "none"
473	};
474	if ( body ) {
475	$.extend( testElementStyle, {
476	position: "absolute",
477	left: "-1000px",
478	top: "-1000px"
479	});
480	}
481	for ( i in testElementStyle ) {
482	testElement.style[ i ] = testElementStyle[ i ];
483	}
484	testElement.appendChild( div );
485	testElementParent = body \|\| document.documentElement;
486	testElementParent.insertBefore( testElement, testElementParent.firstChild );
487
488	div.style.cssText = "position: absolute; left: 10.7432222px;";
489
490	offsetLeft = $( div ).offset().left;
491	$.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
492
493	testElement.innerHTML = "";
494	testElementParent.removeChild( testElement );
495	})();
496
497	}( jQuery ) );