You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
497 lines
15 KiB
497 lines
15 KiB
/*! |
|
* 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 ) );
|
|
|