http://labirint-doors.com/wp-content/plugins/slideshow-gallery/views/default/js/jquery-ui.js?ver=6.2.6

16
17/*!
18 * jQuery UI Effects 1.11.4
19 * http://jqueryui.com
20 *
21 * Copyright jQuery Foundation and other contributors
22 * Released under the MIT license.
23 * http://jquery.org/license
24 *
25 * http://api.jqueryui.com/category/effects-core/
26 */
27
28
29var dataSpace = "ui-effects-",
30
31	// Create a local jQuery because jQuery Color relies on it and the
32	// global may not exist with AMD and a custom build (#10199)
33	jQuery = $;
34
35$.effects = {
36	effect: {}
37};
38
39/*!
40 * jQuery Color Animations v2.1.2
41 * https://github.com/jquery/jquery-color
42 *
43 * Copyright 2014 jQuery Foundation and other contributors
44 * Released under the MIT license.
45 * http://jquery.org/license
46 *
47 * Date: Wed Jan 16 08:47:09 2013 -0600
48 */
49(function( jQuery, undefined ) {
50
51	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
52
53	// plusequals test for += 100 -= 100
54	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
55	// a set of RE's that can match strings and generate color tuples.
56	stringParsers = [ {
57			re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
58			parse: function( execResult ) {
59				return [
60					execResult[ 1 ],
61					execResult[ 2 ],
62					execResult[ 3 ],
63					execResult[ 4 ]
64				];
65			}
66		}, {
67			re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
68			parse: function( execResult ) {
69				return [
70					execResult[ 1 ] * 2.55,
71					execResult[ 2 ] * 2.55,
72					execResult[ 3 ] * 2.55,
73					execResult[ 4 ]
74				];
75			}
76		}, {
77			// this regex ignores A-F because it's compared against an already lowercased string
78			re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
79			parse: function( execResult ) {
80				return [
81					parseInt( execResult[ 1 ], 16 ),
82					parseInt( execResult[ 2 ], 16 ),
83					parseInt( execResult[ 3 ], 16 )
84				];
85			}
86		}, {
87			// this regex ignores A-F because it's compared against an already lowercased string
88			re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
89			parse: function( execResult ) {
90				return [
91					parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
92					parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
93					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
94				];
95			}
96		}, {
97			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
98			space: "hsla",
99			parse: function( execResult ) {
100				return [
101					execResult[ 1 ],
102					execResult[ 2 ] / 100,
103					execResult[ 3 ] / 100,
104					execResult[ 4 ]
105				];
106			}
107		} ],
108
109	// jQuery.Color( )
110	color = jQuery.Color = function( color, green, blue, alpha ) {
111		return new jQuery.Color.fn.parse( color, green, blue, alpha );
112	},
113	spaces = {
114		rgba: {
115			props: {
116				red: {
117					idx: 0,
118					type: "byte"
119				},
120				green: {
121					idx: 1,
122					type: "byte"
123				},
124				blue: {
125					idx: 2,
126					type: "byte"
127				}
128			}
129		},
130
131		hsla: {
132			props: {
133				hue: {
134					idx: 0,
135					type: "degrees"
136				},
137				saturation: {
138					idx: 1,
139					type: "percent"
140				},
141				lightness: {
142					idx: 2,
143					type: "percent"
144				}
145			}
146		}
147	},
148	propTypes = {
149		"byte": {
150			floor: true,
151			max: 255
152		},
153		"percent": {
154			max: 1
155		},
156		"degrees": {
157			mod: 360,
158			floor: true
159		}
160	},
161	support = color.support = {},
162
163	// element for support tests
164	supportElem = jQuery( "<p>" )[ 0 ],
165
166	// colors = jQuery.Color.names
167	colors,
168
169	// local aliases of functions called often
170	each = jQuery.each;
171
172// determine rgba support immediately
173supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
174support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
175
176// define cache name and alpha properties
177// for rgba and hsla spaces
178each( spaces, function( spaceName, space ) {
179	space.cache = "_" + spaceName;
180	space.props.alpha = {
181		idx: 3,
182		type: "percent",
183		def: 1
184	};
185});
186
187function clamp( value, prop, allowEmpty ) {
188	var type = propTypes[ prop.type ] || {};
189
190	if ( value == null ) {
191		return (allowEmpty || !prop.def) ? null : prop.def;
192	}
193
194	// ~~ is an short way of doing floor for positive numbers
195	value = type.floor ? ~~value : parseFloat( value );
196
197	// IE will pass in empty strings as value for alpha,
198	// which will hit this case
199	if ( isNaN( value ) ) {
200		return prop.def;
201	}
202
203	if ( type.mod ) {
204		// we add mod before modding to make sure that negatives values
205		// get converted properly: -10 -> 350
206		return (value + type.mod) % type.mod;
207	}
208
209	// for now all property types without mod have min and max
210	return 0 > value ? 0 : type.max < value ? type.max : value;
211}
212
213function stringParse( string ) {
214	var inst = color(),
215		rgba = inst._rgba = [];
216
217	string = string.toLowerCase();
218
219	each( stringParsers, function( i, parser ) {
220		var parsed,
221			match = parser.re.exec( string ),
222			values = match && parser.parse( match ),
223			spaceName = parser.space || "rgba";
224
225		if ( values ) {
226			parsed = inst[ spaceName ]( values );
227
228			// if this was an rgba parse the assignment might happen twice
229			// oh well....
230			inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
231			rgba = inst._rgba = parsed._rgba;
232
233			// exit each( stringParsers ) here because we matched
234			return false;
235		}
236	});
237
238	// Found a stringParser that handled it
239	if ( rgba.length ) {
240
241		// if this came from a parsed string, force "transparent" when alpha is 0
242		// chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
243		if ( rgba.join() === "0,0,0,0" ) {
244			jQuery.extend( rgba, colors.transparent );
245		}
246		return inst;
247	}
248
249	// named colors
250	return colors[ string ];
251}
252
253color.fn = jQuery.extend( color.prototype, {
254	parse: function( red, green, blue, alpha ) {
255		if ( red === undefined ) {
256			this._rgba = [ null, null, null, null ];
257			return this;
258		}
259		if ( red.jquery || red.nodeType ) {
260			red = jQuery( red ).css( green );
261			green = undefined;
262		}
263
264		var inst = this,
265			type = jQuery.type( red ),
266			rgba = this._rgba = [];
267
268		// more than 1 argument specified - assume ( red, green, blue, alpha )
269		if ( green !== undefined ) {
270			red = [ red, green, blue, alpha ];
271			type = "array";
272		}
273
274		if ( type === "string" ) {
275			return this.parse( stringParse( red ) || colors._default );
276		}
277
278		if ( type === "array" ) {
279			each( spaces.rgba.props, function( key, prop ) {
280				rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
281			});
282			return this;
283		}
284
285		if ( type === "object" ) {
286			if ( red instanceof color ) {
287				each( spaces, function( spaceName, space ) {
288					if ( red[ space.cache ] ) {
289						inst[ space.cache ] = red[ space.cache ].slice();
290					}
291				});
292			} else {
293				each( spaces, function( spaceName, space ) {
294					var cache = space.cache;
295					each( space.props, function( key, prop ) {
296
297						// if the cache doesn't exist, and we know how to convert
298						if ( !inst[ cache ] && space.to ) {
299
300							// if the value was null, we don't need to copy it
301							// if the key was alpha, we don't need to copy it either
302							if ( key === "alpha" || red[ key ] == null ) {
303								return;
304							}
305							inst[ cache ] = space.to( inst._rgba );
306						}
307
308						// this is the only case where we allow nulls for ALL properties.
309						// call clamp with alwaysAllowEmpty
310						inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
311					});
312
313					// everything defined but alpha?
314					if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
315						// use the default of 1
316						inst[ cache ][ 3 ] = 1;
317						if ( space.from ) {
318							inst._rgba = space.from( inst[ cache ] );
319						}
320					}
321				});
322			}
323			return this;
324		}
325	},
326	is: function( compare ) {
327		var is = color( compare ),
328			same = true,
329			inst = this;
330
331		each( spaces, function( _, space ) {
332			var localCache,
333				isCache = is[ space.cache ];
334			if (isCache) {
335				localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
336				each( space.props, function( _, prop ) {
337					if ( isCache[ prop.idx ] != null ) {
338						same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
339						return same;
340					}
341				});
342			}
343			return same;
344		});
345		return same;
346	},
347	_space: function() {
348		var used = [],
349			inst = this;
350		each( spaces, function( spaceName, space ) {
351			if ( inst[ space.cache ] ) {
352				used.push( spaceName );
353			}
354		});
355		return used.pop();
356	},
357	transition: function( other, distance ) {
358		var end = color( other ),
359			spaceName = end._space(),
360			space = spaces[ spaceName ],
361			startColor = this.alpha() === 0 ? color( "transparent" ) : this,
362			start = startColor[ space.cache ] || space.to( startColor._rgba ),
363			result = start.slice();
364
365		end = end[ space.cache ];
366		each( space.props, function( key, prop ) {
367			var index = prop.idx,
368				startValue = start[ index ],
369				endValue = end[ index ],
370				type = propTypes[ prop.type ] || {};
371
372			// if null, don't override start value
373			if ( endValue === null ) {
374				return;
375			}
376			// if null - use end
377			if ( startValue === null ) {
378				result[ index ] = endValue;
379			} else {
380				if ( type.mod ) {
381					if ( endValue - startValue > type.mod / 2 ) {
382						startValue += type.mod;
383					} else if ( startValue - endValue > type.mod / 2 ) {
384						startValue -= type.mod;
385					}
386				}
387				result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
388			}
389		});
390		return this[ spaceName ]( result );
391	},
392	blend: function( opaque ) {
393		// if we are already opaque - return ourself
394		if ( this._rgba[ 3 ] === 1 ) {
395			return this;
396		}
397
398		var rgb = this._rgba.slice(),
399			a = rgb.pop(),
400			blend = color( opaque )._rgba;
401
402		return color( jQuery.map( rgb, function( v, i ) {
403			return ( 1 - a ) * blend[ i ] + a * v;
404		}));
405	},
406	toRgbaString: function() {
407		var prefix = "rgba(",
408			rgba = jQuery.map( this._rgba, function( v, i ) {
409				return v == null ? ( i > 2 ? 1 : 0 ) : v;
410			});
411
412		if ( rgba[ 3 ] === 1 ) {
413			rgba.pop();
414			prefix = "rgb(";
415		}
416
417		return prefix + rgba.join() + ")";
418	},
419	toHslaString: function() {
420		var prefix = "hsla(",
421			hsla = jQuery.map( this.hsla(), function( v, i ) {
422				if ( v == null ) {
423					v = i > 2 ? 1 : 0;
424				}
425
426				// catch 1 and 2
427				if ( i && i < 3 ) {
428					v = Math.round( v * 100 ) + "%";
429				}
430				return v;
431			});
432
433		if ( hsla[ 3 ] === 1 ) {
434			hsla.pop();
435			prefix = "hsl(";
436		}
437		return prefix + hsla.join() + ")";
438	},
439	toHexString: function( includeAlpha ) {
440		var rgba = this._rgba.slice(),
441			alpha = rgba.pop();
442
443		if ( includeAlpha ) {
444			rgba.push( ~~( alpha * 255 ) );
445		}
446
447		return "#" + jQuery.map( rgba, function( v ) {
448
449			// default to 0 when nulls exist
450			v = ( v || 0 ).toString( 16 );
451			return v.length === 1 ? "0" + v : v;
452		}).join("");
453	},
454	toString: function() {
455		return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
456	}
457});
458color.fn.parse.prototype = color.fn;
459
460// hsla conversions adapted from:
461// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
462
463function hue2rgb( p, q, h ) {
464	h = ( h + 1 ) % 1;
465	if ( h * 6 < 1 ) {
466		return p + ( q - p ) * h * 6;
467	}
468	if ( h * 2 < 1) {
469		return q;
470	}
471	if ( h * 3 < 2 ) {
472		return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
473	}
474	return p;
475}
476
477spaces.hsla.to = function( rgba ) {
478	if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
479		return [ null, null, null, rgba[ 3 ] ];
480	}
481	var r = rgba[ 0 ] / 255,
482		g = rgba[ 1 ] / 255,
483		b = rgba[ 2 ] / 255,
484		a = rgba[ 3 ],
485		max = Math.max( r, g, b ),
486		min = Math.min( r, g, b ),
487		diff = max - min,
488		add = max + min,
489		l = add * 0.5,
490		h, s;
491
492	if ( min === max ) {
493		h = 0;
494	} else if ( r === max ) {
495		h = ( 60 * ( g - b ) / diff ) + 360;
496	} else if ( g === max ) {
497		h = ( 60 * ( b - r ) / diff ) + 120;
498	} else {
499		h = ( 60 * ( r - g ) / diff ) + 240;
500	}
501
502	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
503	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
504	if ( diff === 0 ) {
505		s = 0;
506	} else if ( l <= 0.5 ) {
507		s = diff / add;
508	} else {
509		s = diff / ( 2 - add );
510	}
511	return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
512};
513
514spaces.hsla.from = function( hsla ) {
515	if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
516		return [ null, null, null, hsla[ 3 ] ];
517	}
518	var h = hsla[ 0 ] / 360,
519		s = hsla[ 1 ],
520		l = hsla[ 2 ],
521		a = hsla[ 3 ],
522		q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
523		p = 2 * l - q;
524
525	return [
526		Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
527		Math.round( hue2rgb( p, q, h ) * 255 ),
528		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
529		a
530	];
531};
532
533each( spaces, function( spaceName, space ) {
534	var props = space.props,
535		cache = space.cache,
536		to = space.to,
537		from = space.from;
538
539	// makes rgba() and hsla()
540	color.fn[ spaceName ] = function( value ) {
541
542		// generate a cache for this space if it doesn't exist
543		if ( to && !this[ cache ] ) {
544			this[ cache ] = to( this._rgba );
545		}
546		if ( value === undefined ) {
547			return this[ cache ].slice();
548		}
549
550		var ret,
551			type = jQuery.type( value ),
552			arr = ( type === "array" || type === "object" ) ? value : arguments,
553			local = this[ cache ].slice();
554
555		each( props, function( key, prop ) {
556			var val = arr[ type === "object" ? key : prop.idx ];
557			if ( val == null ) {
558				val = local[ prop.idx ];
559			}
560			local[ prop.idx ] = clamp( val, prop );
561		});
562
563		if ( from ) {
564			ret = color( from( local ) );
565			ret[ cache ] = local;
566			return ret;
567		} else {
568			return color( local );
569		}
570	};
571
572	// makes red() green() blue() alpha() hue() saturation() lightness()
573	each( props, function( key, prop ) {
574		// alpha is included in more than one space
575		if ( color.fn[ key ] ) {
576			return;
577		}
578		color.fn[ key ] = function( value ) {
579			var vtype = jQuery.type( value ),
580				fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
581				local = this[ fn ](),
582				cur = local[ prop.idx ],
583				match;
584
585			if ( vtype === "undefined" ) {
586				return cur;
587			}
588
589			if ( vtype === "function" ) {
590				value = value.call( this, cur );
591				vtype = jQuery.type( value );
592			}
593			if ( value == null && prop.empty ) {
594				return this;
595			}
596			if ( vtype === "string" ) {
597				match = rplusequals.exec( value );
598				if ( match ) {
599					value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
600				}
601			}
602			local[ prop.idx ] = value;
603			return this[ fn ]( local );
604		};
605	});
606});
607
608// add cssHook and .fx.step function for each named hook.
609// accept a space separated string of properties
610color.hook = function( hook ) {
611	var hooks = hook.split( " " );
612	each( hooks, function( i, hook ) {
613		jQuery.cssHooks[ hook ] = {
614			set: function( elem, value ) {
615				var parsed, curElem,
616					backgroundColor = "";
617
618				if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
619					value = color( parsed || value );
620					if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
621						curElem = hook === "backgroundColor" ? elem.parentNode : elem;
622						while (
623							(backgroundColor === "" || backgroundColor === "transparent") &&
624							curElem && curElem.style
625						) {
626							try {
627								backgroundColor = jQuery.css( curElem, "backgroundColor" );
628								curElem = curElem.parentNode;
629							} catch ( e ) {
630							}
631						}
632
633						value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
634							backgroundColor :
635							"_default" );
636					}
637
638					value = value.toRgbaString();
639				}
640				try {
641					elem.style[ hook ] = value;
642				} catch ( e ) {
643					// wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
644				}
645			}
646		};
647		jQuery.fx.step[ hook ] = function( fx ) {
648			if ( !fx.colorInit ) {
649				fx.start = color( fx.elem, hook );
650				fx.end = color( fx.end );
651				fx.colorInit = true;
652			}
653			jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
654		};
655	});
656
657};
658
659color.hook( stepHooks );
660
661jQuery.cssHooks.borderColor = {
662	expand: function( value ) {
663		var expanded = {};
664
665		each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
666			expanded[ "border" + part + "Color" ] = value;
667		});
668		return expanded;
669	}
670};
671
672// Basic color names only.
673// Usage of any of the other color names requires adding yourself or including
674// jquery.color.svg-names.js.
675colors = jQuery.Color.names = {
676	// 4.1. Basic color keywords
677	aqua: "#00ffff",
678	black: "#000000",
679	blue: "#0000ff",
680	fuchsia: "#ff00ff",
681	gray: "#808080",
682	green: "#008000",
683	lime: "#00ff00",
684	maroon: "#800000",
685	navy: "#000080",
686	olive: "#808000",
687	purple: "#800080",
688	red: "#ff0000",
689	silver: "#c0c0c0",
690	teal: "#008080",
691	white: "#ffffff",
692	yellow: "#ffff00",
693
694	// 4.2.3. "transparent" color keyword
695	transparent: [ null, null, null, 0 ],
696
697	_default: "#ffffff"
698};
699
700})( jQuery );
701
702/******************************************************************************/
703/****************************** CLASS ANIMATIONS ******************************/
704/******************************************************************************/
705(function() {
706
707var classAnimationActions = [ "add", "remove", "toggle" ],
708	shorthandStyles = {
709		border: 1,
710		borderBottom: 1,
711		borderColor: 1,
712		borderLeft: 1,
713		borderRight: 1,
714		borderTop: 1,
715		borderWidth: 1,
716		margin: 1,
717		padding: 1
718	};
719
720$.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
721	$.fx.step[ prop ] = function( fx ) {
722		if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
723			jQuery.style( fx.elem, prop, fx.end );
724			fx.setAttr = true;
725		}
726	};
727});
728
729function getElementStyles( elem ) {
730	var key, len,
731		style = elem.ownerDocument.defaultView ?
732			elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
733			elem.currentStyle,
734		styles = {};
735
736	if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
737		len = style.length;
738		while ( len-- ) {
739			key = style[ len ];
740			if ( typeof style[ key ] === "string" ) {
741				styles[ $.camelCase( key ) ] = style[ key ];
742			}
743		}
744	// support: Opera, IE <9
745	} else {
746		for ( key in style ) {
747			if ( typeof style[ key ] === "string" ) {
748				styles[ key ] = style[ key ];
749			}
750		}
751	}
752
753	return styles;
754}
755
756function styleDifference( oldStyle, newStyle ) {
757	var diff = {},
758		name, value;
759
760	for ( name in newStyle ) {
761		value = newStyle[ name ];
762		if ( oldStyle[ name ] !== value ) {
763			if ( !shorthandStyles[ name ] ) {
764				if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
765					diff[ name ] = value;
766				}
767			}
768		}
769	}
770
771	return diff;
772}
773
774// support: jQuery <1.8
775if ( !$.fn.addBack ) {
776	$.fn.addBack = function( selector ) {
777		return this.add( selector == null ?
778			this.prevObject : this.prevObject.filter( selector )
779		);
780	};
781}
782
783$.effects.animateClass = function( value, duration, easing, callback ) {
784	var o = $.speed( duration, easing, callback );
785
786	return this.queue( function() {
787		var animated = $( this ),
788			baseClass = animated.attr( "class" ) || "",
789			applyClassChange,
790			allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
791
792		// map the animated objects to store the original styles.
793		allAnimations = allAnimations.map(function() {
794			var el = $( this );
795			return {
796				el: el,
797				start: getElementStyles( this )
798			};
799		});
800
801		// apply class change
802		applyClassChange = function() {
803			$.each( classAnimationActions, function(i, action) {
804				if ( value[ action ] ) {
805					animated[ action + "Class" ]( value[ action ] );
806				}
807			});
808		};
809		applyClassChange();
810
811		// map all animated objects again - calculate new styles and diff
812		allAnimations = allAnimations.map(function() {
813			this.end = getElementStyles( this.el[ 0 ] );
814			this.diff = styleDifference( this.start, this.end );
815			return this;
816		});
817
818		// apply original class
819		animated.attr( "class", baseClass );
820
821		// map all animated objects again - this time collecting a promise
822		allAnimations = allAnimations.map(function() {
823			var styleInfo = this,
824				dfd = $.Deferred(),
825				opts = $.extend({}, o, {
826					queue: false,
827					complete: function() {
828						dfd.resolve( styleInfo );
829					}
830				});
831
832			this.el.animate( this.diff, opts );
833			return dfd.promise();
834		});
835
836		// once all animations have completed:
837		$.when.apply( $, allAnimations.get() ).done(function() {
838
839			// set the final class
840			applyClassChange();
841
842			// for each animated element,
843			// clear all css properties that were animated
844			$.each( arguments, function() {
845				var el = this.el;
846				$.each( this.diff, function(key) {
847					el.css( key, "" );
848				});
849			});
850
851			// this is guarnteed to be there if you use jQuery.speed()
852			// it also handles dequeuing the next anim...
853			o.complete.call( animated[ 0 ] );
854		});
855	});
856};
857
858$.fn.extend({
859	addClass: (function( orig ) {
860		return function( classNames, speed, easing, callback ) {
861			return speed ?
862				$.effects.animateClass.call( this,
863					{ add: classNames }, speed, easing, callback ) :
864				orig.apply( this, arguments );
865		};
866	})( $.fn.addClass ),
867
868	removeClass: (function( orig ) {
869		return function( classNames, speed, easing, callback ) {
870			return arguments.length > 1 ?
871				$.effects.animateClass.call( this,
872					{ remove: classNames }, speed, easing, callback ) :
873				orig.apply( this, arguments );
874		};
875	})( $.fn.removeClass ),
876
877	toggleClass: (function( orig ) {
878		return function( classNames, force, speed, easing, callback ) {
879			if ( typeof force === "boolean" || force === undefined ) {
880				if ( !speed ) {
881					// without speed parameter
882					return orig.apply( this, arguments );
883				} else {
884					return $.effects.animateClass.call( this,
885						(force ? { add: classNames } : { remove: classNames }),
886						speed, easing, callback );
887				}
888			} else {
889				// without force parameter
890				return $.effects.animateClass.call( this,
891					{ toggle: classNames }, force, speed, easing );
892			}
893		};
894	})( $.fn.toggleClass ),
895
896	switchClass: function( remove, add, speed, easing, callback) {
897		return $.effects.animateClass.call( this, {
898			add: add,
899			remove: remove
900		}, speed, easing, callback );
901	}
902});
903
904})();
905
906/******************************************************************************/
907/*********************************** EFFECTS **********************************/
908/******************************************************************************/
909
910(function() {
911
912$.extend( $.effects, {
913	version: "1.11.4",
914
915	// Saves a set of properties in a data storage
916	save: function( element, set ) {
917		for ( var i = 0; i < set.length; i++ ) {
918			if ( set[ i ] !== null ) {
919				element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
920			}
921		}
922	},
923
924	// Restores a set of previously saved properties from a data storage
925	restore: function( element, set ) {
926		var val, i;
927		for ( i = 0; i < set.length; i++ ) {
928			if ( set[ i ] !== null ) {
929				val = element.data( dataSpace + set[ i ] );
930				// support: jQuery 1.6.2
931				// http://bugs.jquery.com/ticket/9917
932				// jQuery 1.6.2 incorrectly returns undefined for any falsy value.
933				// We can't differentiate between "" and 0 here, so we just assume
934				// empty string since it's likely to be a more common value...
935				if ( val === undefined ) {
936					val = "";
937				}
938				element.css( set[ i ], val );
939			}
940		}
941	},
942
943	setMode: function( el, mode ) {
944		if (mode === "toggle") {
945			mode = el.is( ":hidden" ) ? "show" : "hide";
946		}
947		return mode;
948	},
949
950	// Translates a [top,left] array into a baseline value
951	// this should be a little more flexible in the future to handle a string & hash
952	getBaseline: function( origin, original ) {
953		var y, x;
954		switch ( origin[ 0 ] ) {
955			case "top": y = 0; break;
956			case "middle": y = 0.5; break;
957			case "bottom": y = 1; break;
958			default: y = origin[ 0 ] / original.height;
959		}
960		switch ( origin[ 1 ] ) {
961			case "left": x = 0; break;
962			case "center": x = 0.5; break;
963			case "right": x = 1; break;
964			default: x = origin[ 1 ] / original.width;
965		}
966		return {
967			x: x,
968			y: y
969		};
970	},
971
972	// Wraps the element around a wrapper that copies position properties
973	createWrapper: function( element ) {
974
975		// if the element is already wrapped, return it
976		if ( element.parent().is( ".ui-effects-wrapper" )) {
977			return element.parent();
978		}
979
980		// wrap the element
981		var props = {
982				width: element.outerWidth(true),
983				height: element.outerHeight(true),
984				"float": element.css( "float" )
985			},
986			wrapper = $( "<div></div>" )
987				.addClass( "ui-effects-wrapper" )
988				.css({
989					fontSize: "100%",
990					background: "transparent",
991					border: "none",
992					margin: 0,
993					padding: 0
994				}),
995			// Store the size in case width/height are defined in % - Fixes #5245
996			size = {
997				width: element.width(),
998				height: element.height()
999			},
1000			active = document.activeElement;
1001
1002		// support: Firefox
1003		// Firefox incorrectly exposes anonymous content
1004		// https://bugzilla.mozilla.org/show_bug.cgi?id=561664
1005		try {
1006			active.id;
1007		} catch ( e ) {
1008			active = document.body;
1009		}
1010
1011		element.wrap( wrapper );
1012
1013		// Fixes #7595 - Elements lose focus when wrapped.
1014		if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
1015			$( active ).focus();
1016		}
1017
1018		wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
1019
1020		// transfer positioning properties to the wrapper
1021		if ( element.css( "position" ) === "static" ) {
1022			wrapper.css({ position: "relative" });
1023			element.css({ position: "relative" });
1024		} else {
1025			$.extend( props, {
1026				position: element.css( "position" ),
1027				zIndex: element.css( "z-index" )
1028			});
1029			$.each([ "top", "left", "bottom", "right" ], function(i, pos) {
1030				props[ pos ] = element.css( pos );
1031				if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
1032					props[ pos ] = "auto";
1033				}
1034			});
1035			element.css({
1036				position: "relative",
1037				top: 0,
1038				left: 0,
1039				right: "auto",
1040				bottom: "auto"
1041			});
1042		}
1043		element.css(size);
1044
1045		return wrapper.css( props ).show();
1046	},
1047
1048	removeWrapper: function( element ) {
1049		var active = document.activeElement;
1050
1051		if ( element.parent().is( ".ui-effects-wrapper" ) ) {
1052			element.parent().replaceWith( element );
1053
1054			// Fixes #7595 - Elements lose focus when wrapped.
1055			if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
1056				$( active ).focus();
1057			}
1058		}
1059
1060		return element;
1061	},
1062
1063	setTransition: function( element, list, factor, value ) {
1064		value = value || {};
1065		$.each( list, function( i, x ) {
1066			var unit = element.cssUnit( x );
1067			if ( unit[ 0 ] > 0 ) {
1068				value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
1069			}
1070		});
1071		return value;
1072	}
1073});
1074
1075// return an effect options object for the given parameters:
1076function _normalizeArguments( effect, options, speed, callback ) {
1077
1078	// allow passing all options as the first parameter
1079	if ( $.isPlainObject( effect ) ) {
1080		options = effect;
1081		effect = effect.effect;
1082	}
1083
1084	// convert to an object
1085	effect = { effect: effect };
1086
1087	// catch (effect, null, ...)
1088	if ( options == null ) {
1089		options = {};
1090	}
1091
1092	// catch (effect, callback)
1093	if ( $.isFunction( options ) ) {
1094		callback = options;
1095		speed = null;
1096		options = {};
1097	}
1098
1099	// catch (effect, speed, ?)
1100	if ( typeof options === "number" || $.fx.speeds[ options ] ) {
1101		callback = speed;
1102		speed = options;
1103		options = {};
1104	}
1105
1106	// catch (effect, options, callback)
1107	if ( $.isFunction( speed ) ) {
1108		callback = speed;
1109		speed = null;
1110	}
1111
1112	// add options to effect
1113	if ( options ) {
1114		$.extend( effect, options );
1115	}
1116
1117	speed = speed || options.duration;
1118	effect.duration = $.fx.off ? 0 :
1119		typeof speed === "number" ? speed :
1120		speed in $.fx.speeds ? $.fx.speeds[ speed ] :
1121		$.fx.speeds._default;
1122
1123	effect.complete = callback || options.complete;
1124
1125	return effect;
1126}
1127
1128function standardAnimationOption( option ) {
1129	// Valid standard speeds (nothing, number, named speed)
1130	if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
1131		return true;
1132	}
1133
1134	// Invalid strings - treat as "normal" speed
1135	if ( typeof option === "string" && !$.effects.effect[ option ] ) {
1136		return true;
1137	}
1138
1139	// Complete callback
1140	if ( $.isFunction( option ) ) {
1141		return true;
1142	}
1143
1144	// Options hash (but not naming an effect)
1145	if ( typeof option === "object" && !option.effect ) {
1146		return true;
1147	}
1148
1149	// Didn't match any standard API
1150	return false;
1151}
1152
1153$.fn.extend({
1154	effect: function( /* effect, options, speed, callback */ ) {
1155		var args = _normalizeArguments.apply( this, arguments ),
1156			mode = args.mode,
1157			queue = args.queue,
1158			effectMethod = $.effects.effect[ args.effect ];
1159
1160		if ( $.fx.off || !effectMethod ) {
1161			// delegate to the original method (e.g., .show()) if possible
1162			if ( mode ) {
1163				return this[ mode ]( args.duration, args.complete );
1164			} else {
1165				return this.each( function() {
1166					if ( args.complete ) {
1167						args.complete.call( this );
1168					}
1169				});
1170			}
1171		}
1172
1173		function run( next ) {
1174			var elem = $( this ),
1175				complete = args.complete,
1176				mode = args.mode;
1177
1178			function done() {
1179				if ( $.isFunction( complete ) ) {
1180					complete.call( elem[0] );
1181				}
1182				if ( $.isFunction( next ) ) {
1183					next();
1184				}
1185			}
1186
1187			// If the element already has the correct final state, delegate to
1188			// the core methods so the internal tracking of "olddisplay" works.
1189			if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
1190				elem[ mode ]();
1191				done();
1192			} else {
1193				effectMethod.call( elem[0], args, done );
1194			}
1195		}
1196
1197		return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
1198	},
1199
1200	show: (function( orig ) {
1201		return function( option ) {
1202			if ( standardAnimationOption( option ) ) {
1203				return orig.apply( this, arguments );
1204			} else {
1205				var args = _normalizeArguments.apply( this, arguments );
1206				args.mode = "show";
1207				return this.effect.call( this, args );
1208			}
1209		};
1210	})( $.fn.show ),
1211
1212	hide: (function( orig ) {
1213		return function( option ) {
1214			if ( standardAnimationOption( option ) ) {
1215				return orig.apply( this, arguments );
1216			} else {
1217				var args = _normalizeArguments.apply( this, arguments );
1218				args.mode = "hide";
1219				return this.effect.call( this, args );
1220			}
1221		};
1222	})( $.fn.hide ),
1223
1224	toggle: (function( orig ) {
1225		return function( option ) {
1226			if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
1227				return orig.apply( this, arguments );
1228			} else {
1229				var args = _normalizeArguments.apply( this, arguments );
1230				args.mode = "toggle";
1231				return this.effect.call( this, args );
1232			}
1233		};
1234	})( $.fn.toggle ),
1235
1236	// helper functions
1237	cssUnit: function(key) {
1238		var style = this.css( key ),
1239			val = [];
1240
1241		$.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
1242			if ( style.indexOf( unit ) > 0 ) {
1243				val = [ parseFloat( style ), unit ];
1244			}
1245		});
1246		return val;
1247	}
1248});
1249
1250})();
1251
1252/******************************************************************************/
1253/*********************************** EASING ***********************************/
1254/******************************************************************************/
1255
1256(function() {
1257
1258// based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
1259
1260var baseEasings = {};
1261
1262$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
1263	baseEasings[ name ] = function( p ) {
1264		return Math.pow( p, i + 2 );
1265	};
1266});
1267
1268$.extend( baseEasings, {
1269	Sine: function( p ) {
1270		return 1 - Math.cos( p * Math.PI / 2 );
1271	},
1272	Circ: function( p ) {
1273		return 1 - Math.sqrt( 1 - p * p );
1274	},
1275	Elastic: function( p ) {
1276		return p === 0 || p === 1 ? p :
1277			-Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
1278	},
1279	Back: function( p ) {
1280		return p * p * ( 3 * p - 2 );
1281	},
1282	Bounce: function( p ) {
1283		var pow2,
1284			bounce = 4;
1285
1286		while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
1287		return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
1288	}
1289});
1290
1291$.each( baseEasings, function( name, easeIn ) {
1292	$.easing[ "easeIn" + name ] = easeIn;
1293	$.easing[ "easeOut" + name ] = function( p ) {
1294		return 1 - easeIn( 1 - p );
1295	};
1296	$.easing[ "easeInOut" + name ] = function( p ) {
1297		return p < 0.5 ?
1298			easeIn( p * 2 ) / 2 :
1299			1 - easeIn( p * -2 + 2 ) / 2;
1300	};
1301});
1302
1303})();
1304
1305var effect = $.effects;
1306
1307
1308/*!
1309 * jQuery UI Effects Blind 1.11.4
1310 * http://jqueryui.com
1311 *
1312 * Copyright jQuery Foundation and other contributors
1313 * Released under the MIT license.
1314 * http://jquery.org/license
1315 *
1316 * http://api.jqueryui.com/blind-effect/
1317 */
1318
1319
1320var effectBlind = $.effects.effect.blind = function( o, done ) {
1321	// Create element
1322	var el = $( this ),
1323		rvertical = /up|down|vertical/,
1324		rpositivemotion = /up|left|vertical|horizontal/,
1325		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
1326		mode = $.effects.setMode( el, o.mode || "hide" ),
1327		direction = o.direction || "up",
1328		vertical = rvertical.test( direction ),
1329		ref = vertical ? "height" : "width",
1330		ref2 = vertical ? "top" : "left",
1331		motion = rpositivemotion.test( direction ),
1332		animation = {},
1333		show = mode === "show",
1334		wrapper, distance, margin;
1335
1336	// if already wrapped, the wrapper's properties are my property. #6245
1337	if ( el.parent().is( ".ui-effects-wrapper" ) ) {
1338		$.effects.save( el.parent(), props );
1339	} else {
1340		$.effects.save( el, props );
1341	}
1342	el.show();
1343	wrapper = $.effects.createWrapper( el ).css({
1344		overflow: "hidden"
1345	});
1346
1347	distance = wrapper[ ref ]();
1348	margin = parseFloat( wrapper.css( ref2 ) ) || 0;
1349
1350	animation[ ref ] = show ? distance : 0;
1351	if ( !motion ) {
1352		el
1353			.css( vertical ? "bottom" : "right", 0 )
1354			.css( vertical ? "top" : "left", "auto" )
1355			.css({ position: "absolute" });
1356
1357		animation[ ref2 ] = show ? margin : distance + margin;
1358	}
1359
1360	// start at 0 if we are showing
1361	if ( show ) {
1362		wrapper.css( ref, 0 );
1363		if ( !motion ) {
1364			wrapper.css( ref2, margin + distance );
1365		}
1366	}
1367
1368	// Animate
1369	wrapper.animate( animation, {
1370		duration: o.duration,
1371		easing: o.easing,
1372		queue: false,
1373		complete: function() {
1374			if ( mode === "hide" ) {
1375				el.hide();
1376			}
1377			$.effects.restore( el, props );
1378			$.effects.removeWrapper( el );
1379			done();
1380		}
1381	});
1382};
1383
1384
1385/*!
1386 * jQuery UI Effects Bounce 1.11.4
1387 * http://jqueryui.com
1388 *
1389 * Copyright jQuery Foundation and other contributors
1390 * Released under the MIT license.
1391 * http://jquery.org/license
1392 *
1393 * http://api.jqueryui.com/bounce-effect/
1394 */
1395
1396
1397var effectBounce = $.effects.effect.bounce = function( o, done ) {
1398	var el = $( this ),
1399		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
1400
1401		// defaults:
1402		mode = $.effects.setMode( el, o.mode || "effect" ),
1403		hide = mode === "hide",
1404		show = mode === "show",
1405		direction = o.direction || "up",
1406		distance = o.distance,
1407		times = o.times || 5,
1408
1409		// number of internal animations
1410		anims = times * 2 + ( show || hide ? 1 : 0 ),
1411		speed = o.duration / anims,
1412		easing = o.easing,
1413
1414		// utility:
1415		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
1416		motion = ( direction === "up" || direction === "left" ),
1417		i,
1418		upAnim,
1419		downAnim,
1420
1421		// we will need to re-assemble the queue to stack our animations in place
1422		queue = el.queue(),
1423		queuelen = queue.length;
1424
1425	// Avoid touching opacity to prevent clearType and PNG issues in IE
1426	if ( show || hide ) {
1427		props.push( "opacity" );
1428	}
1429
1430	$.effects.save( el, props );
1431	el.show();
1432	$.effects.createWrapper( el ); // Create Wrapper
1433
1434	// default distance for the BIGGEST bounce is the outer Distance / 3
1435	if ( !distance ) {
1436		distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
1437	}
1438
1439	if ( show ) {
1440		downAnim = { opacity: 1 };
1441		downAnim[ ref ] = 0;
1442
1443		// if we are showing, force opacity 0 and set the initial position
1444		// then do the "first" animation
1445		el.css( "opacity", 0 )
1446			.css( ref, motion ? -distance * 2 : distance * 2 )
1447			.animate( downAnim, speed, easing );
1448	}
1449
1450	// start at the smallest distance if we are hiding
1451	if ( hide ) {
1452		distance = distance / Math.pow( 2, times - 1 );
1453	}
1454
1455	downAnim = {};
1456	downAnim[ ref ] = 0;
1457	// Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
1458	for ( i = 0; i < times; i++ ) {
1459		upAnim = {};
1460		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
1461
1462		el.animate( upAnim, speed, easing )
1463			.animate( downAnim, speed, easing );
1464
1465		distance = hide ? distance * 2 : distance / 2;
1466	}
1467
1468	// Last Bounce when Hiding
1469	if ( hide ) {
1470		upAnim = { opacity: 0 };
1471		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
1472
1473		el.animate( upAnim, speed, easing );
1474	}
1475
1476	el.queue(function() {
1477		if ( hide ) {
1478			el.hide();
1479		}
1480		$.effects.restore( el, props );
1481		$.effects.removeWrapper( el );
1482		done();
1483	});
1484
1485	// inject all the animations we just queued to be first in line (after "inprogress")
1486	if ( queuelen > 1) {
1487		queue.splice.apply( queue,
1488			[ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
1489	}
1490	el.dequeue();
1491
1492};
1493
1494
1495/*!
1496 * jQuery UI Effects Clip 1.11.4
1497 * http://jqueryui.com
1498 *
1499 * Copyright jQuery Foundation and other contributors
1500 * Released under the MIT license.
1501 * http://jquery.org/license
1502 *
1503 * http://api.jqueryui.com/clip-effect/
1504 */
1505
1506
1507var effectClip = $.effects.effect.clip = function( o, done ) {
1508	// Create element
1509	var el = $( this ),
1510		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
1511		mode = $.effects.setMode( el, o.mode || "hide" ),
1512		show = mode === "show",
1513		direction = o.direction || "vertical",
1514		vert = direction === "vertical",
1515		size = vert ? "height" : "width",
1516		position = vert ? "top" : "left",
1517		animation = {},
1518		wrapper, animate, distance;
1519
1520	// Save & Show
1521	$.effects.save( el, props );
1522	el.show();
1523
1524	// Create Wrapper
1525	wrapper = $.effects.createWrapper( el ).css({
1526		overflow: "hidden"
1527	});
1528	animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
1529	distance = animate[ size ]();
1530
1531	// Shift
1532	if ( show ) {
1533		animate.css( size, 0 );
1534		animate.css( position, distance / 2 );
1535	}
1536
1537	// Create Animation Object:
1538	animation[ size ] = show ? distance : 0;
1539	animation[ position ] = show ? 0 : distance / 2;
1540
1541	// Animate
1542	animate.animate( animation, {
1543		queue: false,
1544		duration: o.duration,
1545		easing: o.easing,
1546		complete: function() {
1547			if ( !show ) {
1548				el.hide();
1549			}
1550			$.effects.restore( el, props );
1551			$.effects.removeWrapper( el );
1552			done();
1553		}
1554	});
1555
1556};
1557
1558
1559/*!
1560 * jQuery UI Effects Drop 1.11.4
1561 * http://jqueryui.com
1562 *
1563 * Copyright jQuery Foundation and other contributors
1564 * Released under the MIT license.
1565 * http://jquery.org/license
1566 *
1567 * http://api.jqueryui.com/drop-effect/
1568 */
1569
1570
1571var effectDrop = $.effects.effect.drop = function( o, done ) {
1572
1573	var el = $( this ),
1574		props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
1575		mode = $.effects.setMode( el, o.mode || "hide" ),
1576		show = mode === "show",
1577		direction = o.direction || "left",
1578		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
1579		motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
1580		animation = {
1581			opacity: show ? 1 : 0
1582		},
1583		distance;
1584
1585	// Adjust
1586	$.effects.save( el, props );
1587	el.show();
1588	$.effects.createWrapper( el );
1589
1590	distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
1591
1592	if ( show ) {
1593		el
1594			.css( "opacity", 0 )
1595			.css( ref, motion === "pos" ? -distance : distance );
1596	}
1597
1598	// Animation
1599	animation[ ref ] = ( show ?
1600		( motion === "pos" ? "+=" : "-=" ) :
1601		( motion === "pos" ? "-=" : "+=" ) ) +
1602		distance;
1603
1604	// Animate
1605	el.animate( animation, {
1606		queue: false,
1607		duration: o.duration,
1608		easing: o.easing,
1609		complete: function() {
1610			if ( mode === "hide" ) {
1611				el.hide();
1612			}
1613			$.effects.restore( el, props );
1614			$.effects.removeWrapper( el );
1615			done();
1616		}
1617	});
1618};
1619
1620
1621/*!
1622 * jQuery UI Effects Explode 1.11.4
1623 * http://jqueryui.com
1624 *
1625 * Copyright jQuery Foundation and other contributors
1626 * Released under the MIT license.
1627 * http://jquery.org/license
1628 *
1629 * http://api.jqueryui.com/explode-effect/
1630 */
1631
1632
1633var effectExplode = $.effects.effect.explode = function( o, done ) {
1634
1635	var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
1636		cells = rows,
1637		el = $( this ),
1638		mode = $.effects.setMode( el, o.mode || "hide" ),
1639		show = mode === "show",
1640
1641		// show and then visibility:hidden the element before calculating offset
1642		offset = el.show().css( "visibility", "hidden" ).offset(),
1643
1644		// width and height of a piece
1645		width = Math.ceil( el.outerWidth() / cells ),
1646		height = Math.ceil( el.outerHeight() / rows ),
1647		pieces = [],
1648
1649		// loop
1650		i, j, left, top, mx, my;
1651
1652	// children animate complete:
1653	function childComplete() {
1654		pieces.push( this );
1655		if ( pieces.length === rows * cells ) {
1656			animComplete();
1657		}
1658	}
1659
1660	// clone the element for each row and cell.
1661	for ( i = 0; i < rows ; i++ ) { // ===>
1662		top = offset.top + i * height;
1663		my = i - ( rows - 1 ) / 2 ;
1664
1665		for ( j = 0; j < cells ; j++ ) { // |||
1666			left = offset.left + j * width;
1667			mx = j - ( cells - 1 ) / 2 ;
1668
1669			// Create a clone of the now hidden main element that will be absolute positioned
1670			// within a wrapper div off the -left and -top equal to size of our pieces
1671			el
1672				.clone()
1673				.appendTo( "body" )
1674				.wrap( "<div></div>" )
1675				.css({
1676					position: "absolute",
1677					visibility: "visible",
1678					left: -j * width,
1679					top: -i * height
1680				})
1681
1682			// select the wrapper - make it overflow: hidden and absolute positioned based on
1683			// where the original was located +left and +top equal to the size of pieces
1684				.parent()
1685				.addClass( "ui-effects-explode" )
1686				.css({
1687					position: "absolute",
1688					overflow: "hidden",
1689					width: width,
1690					height: height,
1691					left: left + ( show ? mx * width : 0 ),
1692					top: top + ( show ? my * height : 0 ),
1693					opacity: show ? 0 : 1
1694				}).animate({
1695					left: left + ( show ? 0 : mx * width ),
1696					top: top + ( show ? 0 : my * height ),
1697					opacity: show ? 1 : 0
1698				}, o.duration || 500, o.easing, childComplete );
1699		}
1700	}
1701
1702	function animComplete() {
1703		el.css({
1704			visibility: "visible"
1705		});
1706		$( pieces ).remove();
1707		if ( !show ) {
1708			el.hide();
1709		}
1710		done();
1711	}
1712};
1713
1714
1715/*!
1716 * jQuery UI Effects Fade 1.11.4
1717 * http://jqueryui.com
1718 *
1719 * Copyright jQuery Foundation and other contributors
1720 * Released under the MIT license.
1721 * http://jquery.org/license
1722 *
1723 * http://api.jqueryui.com/fade-effect/
1724 */
1725
1726
1727var effectFade = $.effects.effect.fade = function( o, done ) {
1728	var el = $( this ),
1729		mode = $.effects.setMode( el, o.mode || "toggle" );
1730
1731	el.animate({
1732		opacity: mode
1733	}, {
1734		queue: false,
1735		duration: o.duration,
1736		easing: o.easing,
1737		complete: done
1738	});
1739};
1740
1741
1742/*!
1743 * jQuery UI Effects Fold 1.11.4
1744 * http://jqueryui.com
1745 *
1746 * Copyright jQuery Foundation and other contributors
1747 * Released under the MIT license.
1748 * http://jquery.org/license
1749 *
1750 * http://api.jqueryui.com/fold-effect/
1751 */
1752
1753
1754var effectFold = $.effects.effect.fold = function( o, done ) {
1755
1756	// Create element
1757	var el = $( this ),
1758		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
1759		mode = $.effects.setMode( el, o.mode || "hide" ),
1760		show = mode === "show",
1761		hide = mode === "hide",
1762		size = o.size || 15,
1763		percent = /([0-9]+)%/.exec( size ),
1764		horizFirst = !!o.horizFirst,
1765		widthFirst = show !== horizFirst,
1766		ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
1767		duration = o.duration / 2,
1768		wrapper, distance,
1769		animation1 = {},
1770		animation2 = {};
1771
1772	$.effects.save( el, props );
1773	el.show();
1774
1775	// Create Wrapper
1776	wrapper = $.effects.createWrapper( el ).css({
1777		overflow: "hidden"
1778	});
1779	distance = widthFirst ?
1780		[ wrapper.width(), wrapper.height() ] :
1781		[ wrapper.height(), wrapper.width() ];
1782
1783	if ( percent ) {
1784		size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
1785	}
1786	if ( show ) {
1787		wrapper.css( horizFirst ? {
1788			height: 0,
1789			width: size
1790		} : {
1791			height: size,
1792			width: 0
1793		});
1794	}
1795
1796	// Animation
1797	animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
1798	animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
1799
1800	// Animate
1801	wrapper
1802		.animate( animation1, duration, o.easing )
1803		.animate( animation2, duration, o.easing, function() {
1804			if ( hide ) {
1805				el.hide();
1806			}
1807			$.effects.restore( el, props );
1808			$.effects.removeWrapper( el );
1809			done();
1810		});
1811
1812};
1813
1814
1815/*!
1816 * jQuery UI Effects Highlight 1.11.4
1817 * http://jqueryui.com
1818 *
1819 * Copyright jQuery Foundation and other contributors
1820 * Released under the MIT license.
1821 * http://jquery.org/license
1822 *
1823 * http://api.jqueryui.com/highlight-effect/
1824 */
1825
1826
1827var effectHighlight = $.effects.effect.highlight = function( o, done ) {
1828	var elem = $( this ),
1829		props = [ "backgroundImage", "backgroundColor", "opacity" ],
1830		mode = $.effects.setMode( elem, o.mode || "show" ),
1831		animation = {
1832			backgroundColor: elem.css( "backgroundColor" )
1833		};
1834
1835	if (mode === "hide") {
1836		animation.opacity = 0;
1837	}
1838
1839	$.effects.save( elem, props );
1840
1841	elem
1842		.show()
1843		.css({
1844			backgroundImage: "none",
1845			backgroundColor: o.color || "#ffff99"
1846		})
1847		.animate( animation, {
1848			queue: false,
1849			duration: o.duration,
1850			easing: o.easing,
1851			complete: function() {
1852				if ( mode === "hide" ) {
1853					elem.hide();
1854				}
1855				$.effects.restore( elem, props );
1856				done();
1857			}
1858		});
1859};
1860
1861
1862/*!
1863 * jQuery UI Effects Size 1.11.4
1864 * http://jqueryui.com
1865 *
1866 * Copyright jQuery Foundation and other contributors
1867 * Released under the MIT license.
1868 * http://jquery.org/license
1869 *
1870 * http://api.jqueryui.com/size-effect/
1871 */
1872
1873
1874var effectSize = $.effects.effect.size = function( o, done ) {
1875
1876	// Create element
1877	var original, baseline, factor,
1878		el = $( this ),
1879		props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
1880
1881		// Always restore
1882		props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
1883
1884		// Copy for children
1885		props2 = [ "width", "height", "overflow" ],
1886		cProps = [ "fontSize" ],
1887		vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
1888		hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
1889
1890		// Set options
1891		mode = $.effects.setMode( el, o.mode || "effect" ),
1892		restore = o.restore || mode !== "effect",
1893		scale = o.scale || "both",
1894		origin = o.origin || [ "middle", "center" ],
1895		position = el.css( "position" ),
1896		props = restore ? props0 : props1,
1897		zero = {
1898			height: 0,
1899			width: 0,
1900			outerHeight: 0,
1901			outerWidth: 0
1902		};
1903
1904	if ( mode === "show" ) {
1905		el.show();
1906	}
1907	original = {
1908		height: el.height(),
1909		width: el.width(),
1910		outerHeight: el.outerHeight(),
1911		outerWidth: el.outerWidth()
1912	};
1913
1914	if ( o.mode === "toggle" && mode === "show" ) {
1915		el.from = o.to || zero;
1916		el.to = o.from || original;
1917	} else {
1918		el.from = o.from || ( mode === "show" ? zero : original );
1919		el.to = o.to || ( mode === "hide" ? zero : original );
1920	}
1921
1922	// Set scaling factor
1923	factor = {
1924		from: {
1925			y: el.from.height / original.height,
1926			x: el.from.width / original.width
1927		},
1928		to: {
1929			y: el.to.height / original.height,
1930			x: el.to.width / original.width
1931		}
1932	};
1933
1934	// Scale the css box
1935	if ( scale === "box" || scale === "both" ) {
1936
1937		// Vertical props scaling
1938		if ( factor.from.y !== factor.to.y ) {
1939			props = props.concat( vProps );
1940			el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
1941			el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
1942		}
1943
1944		// Horizontal props scaling
1945		if ( factor.from.x !== factor.to.x ) {
1946			props = props.concat( hProps );
1947			el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
1948			el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
1949		}
1950	}
1951
1952	// Scale the content
1953	if ( scale === "content" || scale === "both" ) {
1954
1955		// Vertical props scaling
1956		if ( factor.from.y !== factor.to.y ) {
1957			props = props.concat( cProps ).concat( props2 );
1958			el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
1959			el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
1960		}
1961	}
1962
1963	$.effects.save( el, props );
1964	el.show();
1965	$.effects.createWrapper( el );
1966	el.css( "overflow", "hidden" ).css( el.from );
1967
1968	// Adjust
1969	if (origin) { // Calculate baseline shifts
1970		baseline = $.effects.getBaseline( origin, original );
1971		el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
1972		el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
1973		el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
1974		el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
1975	}
1976	el.css( el.from ); // set top & left
1977
1978	// Animate
1979	if ( scale === "content" || scale === "both" ) { // Scale the children
1980
1981		// Add margins/font-size
1982		vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
1983		hProps = hProps.concat([ "marginLeft", "marginRight" ]);
1984		props2 = props0.concat(vProps).concat(hProps);
1985
1986		el.find( "*[width]" ).each( function() {
1987			var child = $( this ),
1988				c_original = {
1989					height: child.height(),
1990					width: child.width(),
1991					outerHeight: child.outerHeight(),
1992					outerWidth: child.outerWidth()
1993				};
1994			if (restore) {
1995				$.effects.save(child, props2);
1996			}
1997
1998			child.from = {
1999				height: c_original.height * factor.from.y,
2000				width: c_original.width * factor.from.x,
2001				outerHeight: c_original.outerHeight * factor.from.y,
2002				outerWidth: c_original.outerWidth * factor.from.x
2003			};
2004			child.to = {
2005				height: c_original.height * factor.to.y,
2006				width: c_original.width * factor.to.x,
2007				outerHeight: c_original.height * factor.to.y,
2008				outerWidth: c_original.width * factor.to.x
2009			};
2010
2011			// Vertical props scaling
2012			if ( factor.from.y !== factor.to.y ) {
2013				child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
2014				child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
2015			}
2016
2017			// Horizontal props scaling
2018			if ( factor.from.x !== factor.to.x ) {
2019				child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
2020				child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
2021			}
2022
2023			// Animate children
2024			child.css( child.from );
2025			child.animate( child.to, o.duration, o.easing, function() {
2026
2027				// Restore children
2028				if ( restore ) {
2029					$.effects.restore( child, props2 );
2030				}
2031			});
2032		});
2033	}
2034
2035	// Animate
2036	el.animate( el.to, {
2037		queue: false,
2038		duration: o.duration,
2039		easing: o.easing,
2040		complete: function() {
2041			if ( el.to.opacity === 0 ) {
2042				el.css( "opacity", el.from.opacity );
2043			}
2044			if ( mode === "hide" ) {
2045				el.hide();
2046			}
2047			$.effects.restore( el, props );
2048			if ( !restore ) {
2049
2050				// we need to calculate our new positioning based on the scaling
2051				if ( position === "static" ) {
2052					el.css({
2053						position: "relative",
2054						top: el.to.top,
2055						left: el.to.left
2056					});
2057				} else {
2058					$.each([ "top", "left" ], function( idx, pos ) {
2059						el.css( pos, function( _, str ) {
2060							var val = parseInt( str, 10 ),
2061								toRef = idx ? el.to.left : el.to.top;
2062
2063							// if original was "auto", recalculate the new value from wrapper
2064							if ( str === "auto" ) {
2065								return toRef + "px";
2066							}
2067
2068							return val + toRef + "px";
2069						});
2070					});
2071				}
2072			}
2073
2074			$.effects.removeWrapper( el );
2075			done();
2076		}
2077	});
2078
2079};
2080
2081
2082/*!
2083 * jQuery UI Effects Scale 1.11.4
2084 * http://jqueryui.com
2085 *
2086 * Copyright jQuery Foundation and other contributors
2087 * Released under the MIT license.
2088 * http://jquery.org/license
2089 *
2090 * http://api.jqueryui.com/scale-effect/
2091 */
2092
2093
2094var effectScale = $.effects.effect.scale = function( o, done ) {
2095
2096	// Create element
2097	var el = $( this ),
2098		options = $.extend( true, {}, o ),
2099		mode = $.effects.setMode( el, o.mode || "effect" ),
2100		percent = parseInt( o.percent, 10 ) ||
2101			( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
2102		direction = o.direction || "both",
2103		origin = o.origin,
2104		original = {
2105			height: el.height(),
2106			width: el.width(),
2107			outerHeight: el.outerHeight(),
2108			outerWidth: el.outerWidth()
2109		},
2110		factor = {
2111			y: direction !== "horizontal" ? (percent / 100) : 1,
2112			x: direction !== "vertical" ? (percent / 100) : 1
2113		};
2114
2115	// We are going to pass this effect to the size effect:
2116	options.effect = "size";
2117	options.queue = false;
2118	options.complete = done;
2119
2120	// Set default origin and restore for show/hide
2121	if ( mode !== "effect" ) {
2122		options.origin = origin || [ "middle", "center" ];
2123		options.restore = true;
2124	}
2125
2126	options.from = o.from || ( mode === "show" ? {
2127		height: 0,
2128		width: 0,
2129		outerHeight: 0,
2130		outerWidth: 0
2131	} : original );
2132	options.to = {
2133		height: original.height * factor.y,
2134		width: original.width * factor.x,
2135		outerHeight: original.outerHeight * factor.y,
2136		outerWidth: original.outerWidth * factor.x
2137	};
2138
2139	// Fade option to support puff
2140	if ( options.fade ) {
2141		if ( mode === "show" ) {
2142			options.from.opacity = 0;
2143			options.to.opacity = 1;
2144		}
2145		if ( mode === "hide" ) {
2146			options.from.opacity = 1;
2147			options.to.opacity = 0;
2148		}
2149	}
2150
2151	// Animate
2152	el.effect( options );
2153
2154};
2155
2156
2157/*!
2158 * jQuery UI Effects Puff 1.11.4
2159 * http://jqueryui.com
2160 *
2161 * Copyright jQuery Foundation and other contributors
2162 * Released under the MIT license.
2163 * http://jquery.org/license
2164 *
2165 * http://api.jqueryui.com/puff-effect/
2166 */
2167
2168
2169var effectPuff = $.effects.effect.puff = function( o, done ) {
2170	var elem = $( this ),
2171		mode = $.effects.setMode( elem, o.mode || "hide" ),
2172		hide = mode === "hide",
2173		percent = parseInt( o.percent, 10 ) || 150,
2174		factor = percent / 100,
2175		original = {
2176			height: elem.height(),
2177			width: elem.width(),
2178			outerHeight: elem.outerHeight(),
2179			outerWidth: elem.outerWidth()
2180		};
2181
2182	$.extend( o, {
2183		effect: "scale",
2184		queue: false,
2185		fade: true,
2186		mode: mode,
2187		complete: done,
2188		percent: hide ? percent : 100,
2189		from: hide ?
2190			original :
2191			{
2192				height: original.height * factor,
2193				width: original.width * factor,
2194				outerHeight: original.outerHeight * factor,
2195				outerWidth: original.outerWidth * factor
2196			}
2197	});
2198
2199	elem.effect( o );
2200};
2201
2202
2203/*!
2204 * jQuery UI Effects Pulsate 1.11.4
2205 * http://jqueryui.com
2206 *
2207 * Copyright jQuery Foundation and other contributors
2208 * Released under the MIT license.
2209 * http://jquery.org/license
2210 *
2211 * http://api.jqueryui.com/pulsate-effect/
2212 */
2213
2214
2215var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
2216	var elem = $( this ),
2217		mode = $.effects.setMode( elem, o.mode || "show" ),
2218		show = mode === "show",
2219		hide = mode === "hide",
2220		showhide = ( show || mode === "hide" ),
2221
2222		// showing or hiding leaves of the "last" animation
2223		anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
2224		duration = o.duration / anims,
2225		animateTo = 0,
2226		queue = elem.queue(),
2227		queuelen = queue.length,
2228		i;
2229
2230	if ( show || !elem.is(":visible")) {
2231		elem.css( "opacity", 0 ).show();
2232		animateTo = 1;
2233	}
2234
2235	// anims - 1 opacity "toggles"
2236	for ( i = 1; i < anims; i++ ) {
2237		elem.animate({
2238			opacity: animateTo
2239		}, duration, o.easing );
2240		animateTo = 1 - animateTo;
2241	}
2242
2243	elem.animate({
2244		opacity: animateTo
2245	}, duration, o.easing);
2246
2247	elem.queue(function() {
2248		if ( hide ) {
2249			elem.hide();
2250		}
2251		done();
2252	});
2253
2254	// We just queued up "anims" animations, we need to put them next in the queue
2255	if ( queuelen > 1 ) {
2256		queue.splice.apply( queue,
2257			[ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
2258	}
2259	elem.dequeue();
2260};
2261
2262
2263/*!
2264 * jQuery UI Effects Shake 1.11.4
2265 * http://jqueryui.com
2266 *
2267 * Copyright jQuery Foundation and other contributors
2268 * Released under the MIT license.
2269 * http://jquery.org/license
2270 *
2271 * http://api.jqueryui.com/shake-effect/
2272 */
2273
2274
2275var effectShake = $.effects.effect.shake = function( o, done ) {
2276
2277	var el = $( this ),
2278		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
2279		mode = $.effects.setMode( el, o.mode || "effect" ),
2280		direction = o.direction || "left",
2281		distance = o.distance || 20,
2282		times = o.times || 3,
2283		anims = times * 2 + 1,
2284		speed = Math.round( o.duration / anims ),
2285		ref = (direction === "up" || direction === "down") ? "top" : "left",
2286		positiveMotion = (direction === "up" || direction === "left"),
2287		animation = {},
2288		animation1 = {},
2289		animation2 = {},
2290		i,
2291
2292		// we will need to re-assemble the queue to stack our animations in place
2293		queue = el.queue(),
2294		queuelen = queue.length;
2295
2296	$.effects.save( el, props );
2297	el.show();
2298	$.effects.createWrapper( el );
2299
2300	// Animation
2301	animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
2302	animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
2303	animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
2304
2305	// Animate
2306	el.animate( animation, speed, o.easing );
2307
2308	// Shakes
2309	for ( i = 1; i < times; i++ ) {
2310		el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
2311	}
2312	el
2313		.animate( animation1, speed, o.easing )
2314		.animate( animation, speed / 2, o.easing )
2315		.queue(function() {
2316			if ( mode === "hide" ) {
2317				el.hide();
2318			}
2319			$.effects.restore( el, props );
2320			$.effects.removeWrapper( el );
2321			done();
2322		});
2323
2324	// inject all the animations we just queued to be first in line (after "inprogress")
2325	if ( queuelen > 1) {
2326		queue.splice.apply( queue,
2327			[ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
2328	}
2329	el.dequeue();
2330
2331};
2332
2333
2334/*!
2335 * jQuery UI Effects Slide 1.11.4
2336 * http://jqueryui.com
2337 *
2338 * Copyright jQuery Foundation and other contributors
2339 * Released under the MIT license.
2340 * http://jquery.org/license
2341 *
2342 * http://api.jqueryui.com/slide-effect/
2343 */
2344
2345
2346var effectSlide = $.effects.effect.slide = function( o, done ) {
2347
2348	// Create element
2349	var el = $( this ),
2350		props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
2351		mode = $.effects.setMode( el, o.mode || "show" ),
2352		show = mode === "show",
2353		direction = o.direction || "left",
2354		ref = (direction === "up" || direction === "down") ? "top" : "left",
2355		positiveMotion = (direction === "up" || direction === "left"),
2356		distance,
2357		animation = {};
2358
2359	// Adjust
2360	$.effects.save( el, props );
2361	el.show();
2362	distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
2363
2364	$.effects.createWrapper( el ).css({
2365		overflow: "hidden"
2366	});
2367
2368	if ( show ) {
2369		el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
2370	}
2371
2372	// Animation
2373	animation[ ref ] = ( show ?
2374		( positiveMotion ? "+=" : "-=") :
2375		( positiveMotion ? "-=" : "+=")) +
2376		distance;
2377
2378	// Animate
2379	el.animate( animation, {
2380		queue: false,
2381		duration: o.duration,
2382		easing: o.easing,
2383		complete: function() {
2384			if ( mode === "hide" ) {
2385				el.hide();
2386			}
2387			$.effects.restore( el, props );
2388			$.effects.removeWrapper( el );
2389			done();
2390		}
2391	});
2392};
2393
2394
2395/*!
2396 * jQuery UI Effects Transfer 1.11.4
2397 * http://jqueryui.com
2398 *
2399 * Copyright jQuery Foundation and other contributors
2400 * Released under the MIT license.
2401 * http://jquery.org/license
2402 *
2403 * http://api.jqueryui.com/transfer-effect/
2404 */
2405
2406
2407var effectTransfer = $.effects.effect.transfer = function( o, done ) {
2408	var elem = $( this ),
2409		target = $( o.to ),
2410		targetFixed = target.css( "position" ) === "fixed",
2411		body = $("body"),
2412		fixTop = targetFixed ? body.scrollTop() : 0,
2413		fixLeft = targetFixed ? body.scrollLeft() : 0,
2414		endPosition = target.offset(),
2415		animation = {
2416			top: endPosition.top - fixTop,
2417			left: endPosition.left - fixLeft,
2418			height: target.innerHeight(),
2419			width: target.innerWidth()
2420		},
2421		startPosition = elem.offset(),
2422		transfer = $( "<div class='ui-effects-transfer'></div>" )
2423			.appendTo( document.body )
2424			.addClass( o.className )
2425			.css({
2426				top: startPosition.top - fixTop,
2427				left: startPosition.left - fixLeft,
2428				height: elem.innerHeight(),
2429				width: elem.innerWidth(),
2430				position: targetFixed ? "fixed" : "absolute"
2431			})
2432			.animate( animation, o.duration, o.easing, function() {
2433				transfer.remove();
2434				done();
2435			});
2436};
2437
2438