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