/*!

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