source: trunk/themes/default/js/ui/jquery.ui.position.js @ 18630

Last change on this file since 18630 was 18630, checked in by rvelices, 12 years ago

feature 2771: upgrade jquery from 1.7.2 to 1.8.2 and jquery.ui from 1.8.16 to 1.9.0
Attention plugins: jquery ui effect script ids change when using combine_script because file names changed ...

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