https://www.djrosenberg.ru/wp-content/themes/me-3-9-3/scripts/effects.js

1/*! jQuery UI - v1.10.3 - 2013-07-18
2* http://jqueryui.com
3* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.effect.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js
4* Copyright 2013 jQuery Foundation and other contributors Licensed MIT */
5
6(function( $, undefined ) {
7
8var uuid = 0,
9	runiqueId = /^ui-id-\d+$/;
10
11// $.ui might exist from components with no dependencies, e.g., $.ui.position
12$.ui = $.ui || {};
13
14$.extend( $.ui, {
15	version: "1.10.3",
16
17	keyCode: {
18		BACKSPACE: 8,
19		COMMA: 188,
20		DELETE: 46,
21		DOWN: 40,
22		END: 35,
23		ENTER: 13,
24		ESCAPE: 27,
25		HOME: 36,
26		LEFT: 37,
27		NUMPAD_ADD: 107,
28		NUMPAD_DECIMAL: 110,
29		NUMPAD_DIVIDE: 111,
30		NUMPAD_ENTER: 108,
31		NUMPAD_MULTIPLY: 106,
32		NUMPAD_SUBTRACT: 109,
33		PAGE_DOWN: 34,
34		PAGE_UP: 33,
35		PERIOD: 190,
36		RIGHT: 39,
37		SPACE: 32,
38		TAB: 9,
39		UP: 38
40	}
41});
42
43// plugins
44$.fn.extend({
45	focus: (function( orig ) {
46		return function( delay, fn ) {
47			return typeof delay === "number" ?
48				this.each(function() {
49					var elem = this;
50					setTimeout(function() {
51						$( elem ).focus();
52						if ( fn ) {
53							fn.call( elem );
54						}
55					}, delay );
56				}) :
57				orig.apply( this, arguments );
58		};
59	})( $.fn.focus ),
60
61	scrollParent: function() {
62		var scrollParent;
63		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
64			scrollParent = this.parents().filter(function() {
65				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
66			}).eq(0);
67		} else {
68			scrollParent = this.parents().filter(function() {
69				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
70			}).eq(0);
71		}
72
73		return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
74	},
75
76	zIndex: function( zIndex ) {
77		if ( zIndex !== undefined ) {
78			return this.css( "zIndex", zIndex );
79		}
80
81		if ( this.length ) {
82			var elem = $( this[ 0 ] ), position, value;
83			while ( elem.length && elem[ 0 ] !== document ) {
84				// Ignore z-index if position is set to a value where z-index is ignored by the browser
85				// This makes behavior of this function consistent across browsers
86				// WebKit always returns auto if the element is positioned
87				position = elem.css( "position" );
88				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
89					// IE returns 0 when zIndex is not specified
90					// other browsers return a string
91					// we ignore the case of nested elements with an explicit value of 0
92					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
93					value = parseInt( elem.css( "zIndex" ), 10 );
94					if ( !isNaN( value ) && value !== 0 ) {
95						return value;
96					}
97				}
98				elem = elem.parent();
99			}
100		}
101
102		return 0;
103	},
104
105	uniqueId: function() {
106		return this.each(function() {
107			if ( !this.id ) {
108				this.id = "ui-id-" + (++uuid);
109			}
110		});
111	},
112
113	removeUniqueId: function() {
114		return this.each(function() {
115			if ( runiqueId.test( this.id ) ) {
116				$( this ).removeAttr( "id" );
117			}
118		});
119	}
120});
121
122// selectors
123function focusable( element, isTabIndexNotNaN ) {
124	var map, mapName, img,
125		nodeName = element.nodeName.toLowerCase();
126	if ( "area" === nodeName ) {
127		map = element.parentNode;
128		mapName = map.name;
129		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
130			return false;
131		}
132		img = $( "img[usemap=#" + mapName + "]" )[0];
133		return !!img && visible( img );
134	}
135	return ( /input|select|textarea|button|object/.test( nodeName ) ?
136		!element.disabled :
137		"a" === nodeName ?
138			element.href || isTabIndexNotNaN :
139			isTabIndexNotNaN) &&
140		// the element and all of its ancestors must be visible
141		visible( element );
142}
143
144function visible( element ) {
145	return $.expr.filters.visible( element ) &&
146		!$( element ).parents().addBack().filter(function() {
147			return $.css( this, "visibility" ) === "hidden";
148		}).length;
149}
150
151$.extend( $.expr[ ":" ], {
152	data: $.expr.createPseudo ?
153		$.expr.createPseudo(function( dataName ) {
154			return function( elem ) {
155				return !!$.data( elem, dataName );
156			};
157		}) :
158		// support: jQuery <1.8
159		function( elem, i, match ) {
160			return !!$.data( elem, match[ 3 ] );
161		},
162
163	focusable: function( element ) {
164		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
165	},
166
167	tabbable: function( element ) {
168		var tabIndex = $.attr( element, "tabindex" ),
169			isTabIndexNaN = isNaN( tabIndex );
170		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
171	}
172});
173
174// support: jQuery <1.8
175if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
176	$.each( [ "Width", "Height" ], function( i, name ) {
177		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
178			type = name.toLowerCase(),
179			orig = {
180				innerWidth: $.fn.innerWidth,
181				innerHeight: $.fn.innerHeight,
182				outerWidth: $.fn.outerWidth,
183				outerHeight: $.fn.outerHeight
184			};
185
186		function reduce( elem, size, border, margin ) {
187			$.each( side, function() {
188				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
189				if ( border ) {
190					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
191				}
192				if ( margin ) {
193					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
194				}
195			});
196			return size;
197		}
198

199		$.fn[ "inner" + name ] = function( size ) {
200			if ( size === undefined ) {
201				return orig[ "inner" + name ].call( this );
202			}
203
204			return this.each(function() {
205				$( this ).css( type, reduce( this, size ) + "px" );
206			});
207		};
208
209		$.fn[ "outer" + name] = function( size, margin ) {
210			if ( typeof size !== "number" ) {
211				return orig[ "outer" + name ].call( this, size );
212			}
213
214			return this.each(function() {
215				$( this).css( type, reduce( this, size, true, margin ) + "px" );
216			});
217		};
218	});
219}
220
221// support: jQuery <1.8
222if ( !$.fn.addBack ) {
223	$.fn.addBack = function( selector ) {
224		return this.add( selector == null ?
225			this.prevObject : this.prevObject.filter( selector )
226		);
227	};
228}
229
230// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
231if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
232	$.fn.removeData = (function( removeData ) {
233		return function( key ) {
234			if ( arguments.length ) {
235				return removeData.call( this, $.camelCase( key ) );
236			} else {
237				return removeData.call( this );
238			}
239		};
240	})( $.fn.removeData );
241}
242
243
244
245
246
247// deprecated
248$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
249
250$.support.selectstart = "onselectstart" in document.createElement( "div" );
251$.fn.extend({
252	disableSelection: function() {
253		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
254			".ui-disableSelection", function( event ) {
255				event.preventDefault();
256			});
257	},
258
259	enableSelection: function() {
260		return this.unbind( ".ui-disableSelection" );
261	}
262});
263
264$.extend( $.ui, {
265	// $.ui.plugin is deprecated. Use $.widget() extensions instead.
266	plugin: {
267		add: function( module, option, set ) {
268			var i,
269				proto = $.ui[ module ].prototype;
270			for ( i in set ) {
271				proto.plugins[ i ] = proto.plugins[ i ] || [];
272				proto.plugins[ i ].push( [ option, set[ i ] ] );
273			}
274		},
275		call: function( instance, name, args ) {
276			var i,
277				set = instance.plugins[ name ];
278			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
279				return;
280			}
281
282			for ( i = 0; i < set.length; i++ ) {
283				if ( instance.options[ set[ i ][ 0 ] ] ) {
284					set[ i ][ 1 ].apply( instance.element, args );
285				}
286			}
287		}
288	},
289
290	// only used by resizable
291	hasScroll: function( el, a ) {
292
293		//If overflow is hidden, the element might have extra content, but the user wants to hide it
294		if ( $( el ).css( "overflow" ) === "hidden") {
295			return false;
296		}
297
298		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
299			has = false;
300
301		if ( el[ scroll ] > 0 ) {
302			return true;
303		}
304
305		// TODO: determine which cases actually cause this to happen
306		// if the element doesn't have the scroll set, see if it's possible to
307		// set the scroll
308		el[ scroll ] = 1;
309		has = ( el[ scroll ] > 0 );
310		el[ scroll ] = 0;
311		return has;
312	}
313});
314
315})( jQuery );
316(function( $, undefined ) {
317
318var uuid = 0,
319	slice = Array.prototype.slice,
320	_cleanData = $.cleanData;
321$.cleanData = function( elems ) {
322	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
323		try {
324			$( elem ).triggerHandler( "remove" );
325		// http://bugs.jquery.com/ticket/8235
326		} catch( e ) {}
327	}
328	_cleanData( elems );
329};
330
331$.widget = function( name, base, prototype ) {
332	var fullName, existingConstructor, constructor, basePrototype,
333		// proxiedPrototype allows the provided prototype to remain unmodified
334		// so that it can be used as a mixin for multiple widgets (#8876)
335		proxiedPrototype = {},
336		namespace = name.split( "." )[ 0 ];
337
338	name = name.split( "." )[ 1 ];
339	fullName = namespace + "-" + name;
340
341	if ( !prototype ) {
342		prototype = base;
343		base = $.Widget;
344	}
345
346	// create selector for plugin
347	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
348		return !!$.data( elem, fullName );
349	};
350
351	$[ namespace ] = $[ namespace ] || {};
352	existingConstructor = $[ namespace ][ name ];
353	constructor = $[ namespace ][ name ] = function( options, element ) {
354		// allow instantiation without "new" keyword
355		if ( !this._createWidget ) {
356			return new constructor( options, element );
357		}
358
359		// allow instantiation without initializing for simple inheritance
360		// must use "new" keyword (the code above always passes args)
361		if ( arguments.length ) {
362			this._createWidget( options, element );
363		}
364	};
365	// extend with the existing constructor to carry over any static properties
366	$.extend( constructor, existingConstructor, {
367		version: prototype.version,
368		// copy the object used to create the prototype in case we need to
369		// redefine the widget later
370		_proto: $.extend( {}, prototype ),
371		// track widgets that inherit from this widget in case this widget is
372		// redefined after a widget inherits from it
373		_childConstructors: []
374	});
375
376	basePrototype = new base();
377	// we need to make the options hash a property directly on the new instance
378	// otherwise we'll modify the options hash on the prototype that we're
379	// inheriting from
380	basePrototype.options = $.widget.extend( {}, basePrototype.options );
381	$.each( prototype, function( prop, value ) {
382		if ( !$.isFunction( value ) ) {
383			proxiedPrototype[ prop ] = value;
384			return;
385		}
386		proxiedPrototype[ prop ] = (function() {
387			var _super = function() {
388					return base.prototype[ prop ].apply( this, arguments );
389				},
390				_superApply = function( args ) {
391					return base.prototype[ prop ].apply( this, args );
392				};
393			return function() {
394				var __super = this._super,
395					__superApply = this._superApply,
396					returnValue;
397
398				this._super = _super;
399				this._superApply = _superApply;
400

401				returnValue = value.apply( this, arguments );
402
403				this._super = __super;
404				this._superApply = __superApply;
405
406				return returnValue;
407			};
408		})();
409	});
410	constructor.prototype = $.widget.extend( basePrototype, {
411		// TODO: remove support for widgetEventPrefix
412		// always use the name + a colon as the prefix, e.g., draggable:start
413		// don't prefix for widgets that aren't DOM-based
414		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
415	}, proxiedPrototype, {
416		constructor: constructor,
417		namespace: namespace,
418		widgetName: name,
419		widgetFullName: fullName
420	});
421
422	// If this widget is being redefined then we need to find all widgets that
423	// are inheriting from it and redefine all of them so that they inherit from
424	// the new version of this widget. We're essentially trying to replace one
425	// level in the prototype chain.
426	if ( existingConstructor ) {
427		$.each( existingConstructor._childConstructors, function( i, child ) {
428			var childPrototype = child.prototype;
429
430			// redefine the child widget using the same prototype that was
431			// originally used, but inherit from the new version of the base
432			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
433		});
434		// remove the list of existing child constructors from the old constructor
435		// so the old child constructors can be garbage collected
436		delete existingConstructor._childConstructors;
437	} else {
438		base._childConstructors.push( constructor );
439	}
440
441	$.widget.bridge( name, constructor );
442};
443
444$.widget.extend = function( target ) {
445	var input = slice.call( arguments, 1 ),
446		inputIndex = 0,
447		inputLength = input.length,
448		key,
449		value;
450	for ( ; inputIndex < inputLength; inputIndex++ ) {
451		for ( key in input[ inputIndex ] ) {
452			value = input[ inputIndex ][ key ];
453			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
454				// Clone objects
455				if ( $.isPlainObject( value ) ) {
456					target[ key ] = $.isPlainObject( target[ key ] ) ?
457						$.widget.extend( {}, target[ key ], value ) :
458						// Don't extend strings, arrays, etc. with objects
459						$.widget.extend( {}, value );
460				// Copy everything else by reference
461				} else {
462					target[ key ] = value;
463				}
464			}
465		}
466	}
467	return target;
468};
469
470$.widget.bridge = function( name, object ) {
471	var fullName = object.prototype.widgetFullName || name;
472	$.fn[ name ] = function( options ) {
473		var isMethodCall = typeof options === "string",
474			args = slice.call( arguments, 1 ),
475			returnValue = this;
476
477		// allow multiple hashes to be passed on init
478		options = !isMethodCall && args.length ?
479			$.widget.extend.apply( null, [ options ].concat(args) ) :
480			options;
481
482		if ( isMethodCall ) {
483			this.each(function() {
484				var methodValue,
485					instance = $.data( this, fullName );
486				if ( !instance ) {
487					return $.error( "cannot call methods on " + name + " prior to initialization; " +
488						"attempted to call method '" + options + "'" );
489				}
490				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
491					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
492				}
493				methodValue = instance[ options ].apply( instance, args );
494				if ( methodValue !== instance && methodValue !== undefined ) {
495					returnValue = methodValue && methodValue.jquery ?
496						returnValue.pushStack( methodValue.get() ) :
497						methodValue;
498					return false;
499				}
500			});
501		} else {
502			this.each(function() {
503				var instance = $.data( this, fullName );
504				if ( instance ) {
505					instance.option( options || {} )._init();
506				} else {
507					$.data( this, fullName, new object( options, this ) );
508				}
509			});
510		}
511
512		return returnValue;
513	};
514};
515
516$.Widget = function( /* options, element */ ) {};
517$.Widget._childConstructors = [];
518
519$.Widget.prototype = {
520	widgetName: "widget",
521	widgetEventPrefix: "",
522	defaultElement: "<div>",
523	options: {
524		disabled: false,
525
526		// callbacks
527		create: null
528	},
529	_createWidget: function( options, element ) {
530		element = $( element || this.defaultElement || this )[ 0 ];
531		this.element = $( element );
532		this.uuid = uuid++;
533		this.eventNamespace = "." + this.widgetName + this.uuid;
534		this.options = $.widget.extend( {},
535			this.options,
536			this._getCreateOptions(),
537			options );
538
539		this.bindings = $();
540		this.hoverable = $();
541		this.focusable = $();
542
543		if ( element !== this ) {
544			$.data( element, this.widgetFullName, this );
545			this._on( true, this.element, {
546				remove: function( event ) {
547					if ( event.target === element ) {
548						this.destroy();
549					}
550				}
551			});
552			this.document = $( element.style ?
553				// element within the document
554				element.ownerDocument :
555				// element is window or document
556				element.document || element );
557			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
558		}
559
560		this._create();
561		this._trigger( "create", null, this._getCreateEventData() );
562		this._init();
563	},
564	_getCreateOptions: $.noop,
565	_getCreateEventData: $.noop,
566	_create: $.noop,
567	_init: $.noop,
568
569	destroy: function() {
570		this._destroy();
571		// we can probably remove the unbind calls in 2.0
572		// all event bindings should go through this._on()
573		this.element
574			.unbind( this.eventNamespace )
575			// 1.9 BC for #7810
576			// TODO remove dual storage
577			.removeData( this.widgetName )
578			.removeData( this.widgetFullName )
579			// support: jquery <1.6.3
580			// http://bugs.jquery.com/ticket/9413
581			.removeData( $.camelCase( this.widgetFullName ) );
582		this.widget()
583			.unbind( this.eventNamespace )
584			.removeAttr( "aria-disabled" )
585			.removeClass(
586				this.widgetFullName + "-disabled " +
587				"ui-state-disabled" );
588
589		// clean up events and states
590		this.bindings.unbind( this.eventNamespace );
591		this.hoverable.removeClass( "ui-state-hover" );
592		this.focusable.removeClass( "ui-state-focus" );
593	},
594	_destroy: $.noop,
595
596	widget: function() {
597		return this.element;
598	},
599
600	option: function( key, value ) {
601		var options = key,
602			parts,
603			curOption,
604			i;
605
606		if ( arguments.length === 0 ) {
607			// don't return a reference to the internal hash
608			return $.widget.extend( {}, this.options );
609		}
610
611		if ( typeof key === "string" ) {
612			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
613			options = {};
614			parts = key.split( "." );
615			key = parts.shift();
616			if ( parts.length ) {
617				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
618				for ( i = 0; i < parts.length - 1; i++ ) {
619					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
620					curOption = curOption[ parts[ i ] ];
621				}
622				key = parts.pop();
623				if ( value === undefined ) {
624					return curOption[ key ] === undefined ? null : curOption[ key ];
625				}
626				curOption[ key ] = value;
627			} else {
628				if ( value === undefined ) {
629					return this.options[ key ] === undefined ? null : this.options[ key ];
630				}
631				options[ key ] = value;
632			}
633		}
634
635		this._setOptions( options );
636
637		return this;
638	},
639	_setOptions: function( options ) {
640		var key;
641
642		for ( key in options ) {
643			this._setOption( key, options[ key ] );
644		}
645
646		return this;
647	},
648	_setOption: function( key, value ) {
649		this.options[ key ] = value;
650
651		if ( key === "disabled" ) {
652			this.widget()
653				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
654				.attr( "aria-disabled", value );
655			this.hoverable.removeClass( "ui-state-hover" );
656			this.focusable.removeClass( "ui-state-focus" );
657		}
658
659		return this;
660	},
661
662	enable: function() {
663		return this._setOption( "disabled", false );
664	},
665	disable: function() {
666		return this._setOption( "disabled", true );
667	},
668
669	_on: function( suppressDisabledCheck, element, handlers ) {
670		var delegateElement,
671			instance = this;
672
673		// no suppressDisabledCheck flag, shuffle arguments
674		if ( typeof suppressDisabledCheck !== "boolean" ) {
675			handlers = element;
676			element = suppressDisabledCheck;
677			suppressDisabledCheck = false;
678		}
679
680		// no element argument, shuffle and use this.element
681		if ( !handlers ) {
682			handlers = element;
683			element = this.element;
684			delegateElement = this.widget();
685		} else {
686			// accept selectors, DOM elements
687			element = delegateElement = $( element );
688			this.bindings = this.bindings.add( element );
689		}
690
691		$.each( handlers, function( event, handler ) {
692			function handlerProxy() {
693				// allow widgets to customize the disabled handling
694				// - disabled as an array instead of boolean
695				// - disabled class as method for disabling individual parts
696				if ( !suppressDisabledCheck &&
697						( instance.options.disabled === true ||
698							$( this ).hasClass( "ui-state-disabled" ) ) ) {
699					return;
700				}
701				return ( typeof handler === "string" ? instance[ handler ] : handler )
702					.apply( instance, arguments );
703			}
704
705			// copy the guid so direct unbinding works
706			if ( typeof handler !== "string" ) {
707				handlerProxy.guid = handler.guid =
708					handler.guid || handlerProxy.guid || $.guid++;
709			}
710
711			var match = event.match( /^(\w+)\s*(.*)$/ ),
712				eventName = match[1] + instance.eventNamespace,
713				selector = match[2];
714			if ( selector ) {
715				delegateElement.delegate( selector, eventName, handlerProxy );
716			} else {
717				element.bind( eventName, handlerProxy );
718			}
719		});
720	},
721
722	_off: function( element, eventName ) {
723		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
724		element.unbind( eventName ).undelegate( eventName );
725	},
726
727	_delay: function( handler, delay ) {
728		function handlerProxy() {
729			return ( typeof handler === "string" ? instance[ handler ] : handler )
730				.apply( instance, arguments );
731		}
732		var instance = this;
733		return setTimeout( handlerProxy, delay || 0 );
734	},
735
736	_hoverable: function( element ) {
737		this.hoverable = this.hoverable.add( element );
738		this._on( element, {
739			mouseenter: function( event ) {
740				$( event.currentTarget ).addClass( "ui-state-hover" );
741			},
742			mouseleave: function( event ) {
743				$( event.currentTarget ).removeClass( "ui-state-hover" );
744			}
745		});
746	},
747
748	_focusable: function( element ) {
749		this.focusable = this.focusable.add( element );
750		this._on( element, {
751			focusin: function( event ) {
752				$( event.currentTarget ).addClass( "ui-state-focus" );
753			},
754			focusout: function( event ) {
755				$( event.currentTarget ).removeClass( "ui-state-focus" );
756			}
757		});
758	},
759
760	_trigger: function( type, event, data ) {
761		var prop, orig,
762			callback = this.options[ type ];
763
764		data = data || {};
765		event = $.Event( event );
766		event.type = ( type === this.widgetEventPrefix ?
767			type :
768			this.widgetEventPrefix + type ).toLowerCase();
769		// the original event may come from any element
770		// so we need to reset the target on the new event
771		event.target = this.element[ 0 ];
772
773		// copy original event properties over to the new event
774		orig = event.originalEvent;
775		if ( orig ) {
776			for ( prop in orig ) {
777				if ( !( prop in event ) ) {
778					event[ prop ] = orig[ prop ];
779				}
780			}
781		}
782
783		this.element.trigger( event, data );
784		return !( $.isFunction( callback ) &&
785			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
786			event.isDefaultPrevented() );
787	}
788};
789
790$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
791	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
792		if ( typeof options === "string" ) {
793			options = { effect: options };
794		}
795		var hasOptions,
796			effectName = !options ?
797				method :
798				options === true || typeof options === "number" ?
799					defaultEffect :
800					options.effect || defaultEffect;
801		options = options || {};
802		if ( typeof options === "number" ) {
803			options = { duration: options };
804		}
805		hasOptions = !$.isEmptyObject( options );
806		options.complete = callback;
807		if ( options.delay ) {
808			element.delay( options.delay );
809		}
810		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
811			element[ method ]( options );
812		} else if ( effectName !== method && element[ effectName ] ) {

813			element[ effectName ]( options.duration, options.easing, callback );
814		} else {
815			element.queue(function( next ) {
816				$( this )[ method ]();
817				if ( callback ) {
818					callback.call( element[ 0 ] );
819				}
820				next();
821			});
822		}
823	};
824});
825
826})( jQuery );
827(function( $, undefined ) {
828
829var mouseHandled = false;
830$( document ).mouseup( function() {
831	mouseHandled = false;
832});
833
834$.widget("ui.mouse", {
835	version: "1.10.3",
836	options: {
837		cancel: "input,textarea,button,select,option",
838		distance: 1,
839		delay: 0
840	},
841	_mouseInit: function() {
842		var that = this;
843
844		this.element
845			.bind("mousedown."+this.widgetName, function(event) {
846				return that._mouseDown(event);
847			})
848			.bind("click."+this.widgetName, function(event) {
849				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
850					$.removeData(event.target, that.widgetName + ".preventClickEvent");
851					event.stopImmediatePropagation();
852					return false;
853				}
854			});
855
856		this.started = false;
857	},
858
859	// TODO: make sure destroying one instance of mouse doesn't mess with
860	// other instances of mouse
861	_mouseDestroy: function() {
862		this.element.unbind("."+this.widgetName);
863		if ( this._mouseMoveDelegate ) {
864			$(document)
865				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
866				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
867		}
868	},
869
870	_mouseDown: function(event) {
871		// don't let more than one widget handle mouseStart
872		if( mouseHandled ) { return; }
873
874		// we may have missed mouseup (out of window)
875		(this._mouseStarted && this._mouseUp(event));
876
877		this._mouseDownEvent = event;
878
879		var that = this,
880			btnIsLeft = (event.which === 1),
881			// event.target.nodeName works around a bug in IE 8 with
882			// disabled inputs (#7620)
883			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
884		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
885			return true;
886		}
887
888		this.mouseDelayMet = !this.options.delay;
889		if (!this.mouseDelayMet) {
890			this._mouseDelayTimer = setTimeout(function() {
891				that.mouseDelayMet = true;
892			}, this.options.delay);
893		}
894
895		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
896			this._mouseStarted = (this._mouseStart(event) !== false);
897			if (!this._mouseStarted) {
898				event.preventDefault();
899				return true;
900			}
901		}
902
903		// Click event may never have fired (Gecko & Opera)
904		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
905			$.removeData(event.target, this.widgetName + ".preventClickEvent");
906		}
907
908		// these delegates are required to keep context
909		this._mouseMoveDelegate = function(event) {
910			return that._mouseMove(event);
911		};
912		this._mouseUpDelegate = function(event) {
913			return that._mouseUp(event);
914		};
915		$(document)
916			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
917			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
918
919		event.preventDefault();
920
921		mouseHandled = true;
922		return true;
923	},
924
925	_mouseMove: function(event) {
926		// IE mouseup check - mouseup happened when mouse was out of window
927		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
928			return this._mouseUp(event);
929		}
930
931		if (this._mouseStarted) {
932			this._mouseDrag(event);
933			return event.preventDefault();
934		}
935
936		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
937			this._mouseStarted =
938				(this._mouseStart(this._mouseDownEvent, event) !== false);
939			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
940		}
941
942		return !this._mouseStarted;
943	},
944
945	_mouseUp: function(event) {
946		$(document)
947			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
948			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
949
950		if (this._mouseStarted) {
951			this._mouseStarted = false;
952
953			if (event.target === this._mouseDownEvent.target) {
954				$.data(event.target, this.widgetName + ".preventClickEvent", true);
955			}
956
957			this._mouseStop(event);
958		}
959
960		return false;
961	},
962
963	_mouseDistanceMet: function(event) {
964		return (Math.max(
965				Math.abs(this._mouseDownEvent.pageX - event.pageX),
966				Math.abs(this._mouseDownEvent.pageY - event.pageY)
967			) >= this.options.distance
968		);
969	},
970
971	_mouseDelayMet: function(/* event */) {
972		return this.mouseDelayMet;
973	},
974
975	// These are placeholder methods, to be overriden by extending plugin
976	_mouseStart: function(/* event */) {},
977	_mouseDrag: function(/* event */) {},
978	_mouseStop: function(/* event */) {},
979	_mouseCapture: function(/* event */) { return true; }
980});
981
982})(jQuery);
983(function( $, undefined ) {
984
985$.ui = $.ui || {};
986
987var cachedScrollbarWidth,
988	max = Math.max,
989	abs = Math.abs,
990	round = Math.round,
991	rhorizontal = /left|center|right/,
992	rvertical = /top|center|bottom/,
993	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
994	rposition = /^\w+/,
995	rpercent = /%$/,
996	_position = $.fn.position;
997
998function getOffsets( offsets, width, height ) {
999	return [
1000		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1001		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1002	];
1003}
1004
1005function parseCss( element, property ) {
1006	return parseInt( $.css( element, property ), 10 ) || 0;
1007}
1008
1009function getDimensions( elem ) {
1010	var raw = elem[0];
1011	if ( raw.nodeType === 9 ) {
1012		return {
1013			width: elem.width(),
1014			height: elem.height(),
1015			offset: { top: 0, left: 0 }
1016		};
1017	}
1018	if ( $.isWindow( raw ) ) {
1019		return {
1020			width: elem.width(),
1021			height: elem.height(),
1022			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1023		};
1024	}
1025	if ( raw.preventDefault ) {
1026		return {
1027			width: 0,
1028			height: 0,
1029			offset: { top: raw.pageY, left: raw.pageX }
1030		};
1031	}
1032	return {
1033		width: elem.outerWidth(),
1034		height: elem.outerHeight(),
1035		offset: elem.offset()
1036	};
1037}
1038
1039$.position = {
1040	scrollbarWidth: function() {
1041		if ( cachedScrollbarWidth !== undefined ) {
1042			return cachedScrollbarWidth;
1043		}
1044		var w1, w2,
1045			div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1046			innerDiv = div.children()[0];
1047
1048		$( "body" ).append( div );
1049		w1 = innerDiv.offsetWidth;
1050		div.css( "overflow", "scroll" );
1051
1052		w2 = innerDiv.offsetWidth;
1053
1054		if ( w1 === w2 ) {
1055			w2 = div[0].clientWidth;
1056		}
1057
1058		div.remove();
1059
1060		return (cachedScrollbarWidth = w1 - w2);
1061	},
1062	getScrollInfo: function( within ) {
1063		var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
1064			overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
1065			hasOverflowX = overflowX === "scroll" ||
1066				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1067			hasOverflowY = overflowY === "scroll" ||
1068				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1069		return {
1070			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1071			height: hasOverflowX ? $.position.scrollbarWidth() : 0
1072		};
1073	},
1074	getWithinInfo: function( element ) {
1075		var withinElement = $( element || window ),
1076			isWindow = $.isWindow( withinElement[0] );
1077		return {
1078			element: withinElement,
1079			isWindow: isWindow,
1080			offset: withinElement.offset() || { left: 0, top: 0 },
1081			scrollLeft: withinElement.scrollLeft(),
1082			scrollTop: withinElement.scrollTop(),
1083			width: isWindow ? withinElement.width() : withinElement.outerWidth(),
1084			height: isWindow ? withinElement.height() : withinElement.outerHeight()
1085		};
1086	}
1087};
1088
1089$.fn.position = function( options ) {
1090	if ( !options || !options.of ) {
1091		return _position.apply( this, arguments );
1092	}
1093
1094	// make a copy, we don't want to modify arguments
1095	options = $.extend( {}, options );
1096
1097	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1098		target = $( options.of ),
1099		within = $.position.getWithinInfo( options.within ),
1100		scrollInfo = $.position.getScrollInfo( within ),
1101		collision = ( options.collision || "flip" ).split( " " ),
1102		offsets = {};
1103
1104	dimensions = getDimensions( target );
1105	if ( target[0].preventDefault ) {
1106		// force left top to allow flipping
1107		options.at = "left top";
1108	}
1109	targetWidth = dimensions.width;
1110	targetHeight = dimensions.height;
1111	targetOffset = dimensions.offset;
1112	// clone to reuse original targetOffset later
1113	basePosition = $.extend( {}, targetOffset );
1114
1115	// force my and at to have valid horizontal and vertical positions
1116	// if a value is missing or invalid, it will be converted to center
1117	$.each( [ "my", "at" ], function() {
1118		var pos = ( options[ this ] || "" ).split( " " ),
1119			horizontalOffset,
1120			verticalOffset;
1121
1122		if ( pos.length === 1) {
1123			pos = rhorizontal.test( pos[ 0 ] ) ?
1124				pos.concat( [ "center" ] ) :
1125				rvertical.test( pos[ 0 ] ) ?
1126					[ "center" ].concat( pos ) :
1127					[ "center", "center" ];
1128		}
1129		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1130		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1131
1132		// calculate offsets
1133		horizontalOffset = roffset.exec( pos[ 0 ] );
1134		verticalOffset = roffset.exec( pos[ 1 ] );
1135		offsets[ this ] = [
1136			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1137			verticalOffset ? verticalOffset[ 0 ] : 0
1138		];
1139
1140		// reduce to just the positions without the offsets
1141		options[ this ] = [
1142			rposition.exec( pos[ 0 ] )[ 0 ],
1143			rposition.exec( pos[ 1 ] )[ 0 ]
1144		];
1145	});
1146
1147	// normalize collision option
1148	if ( collision.length === 1 ) {
1149		collision[ 1 ] = collision[ 0 ];
1150	}
1151
1152	if ( options.at[ 0 ] === "right" ) {
1153		basePosition.left += targetWidth;
1154	} else if ( options.at[ 0 ] === "center" ) {
1155		basePosition.left += targetWidth / 2;
1156	}
1157
1158	if ( options.at[ 1 ] === "bottom" ) {
1159		basePosition.top += targetHeight;
1160	} else if ( options.at[ 1 ] === "center" ) {
1161		basePosition.top += targetHeight / 2;
1162	}
1163
1164	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1165	basePosition.left += atOffset[ 0 ];
1166	basePosition.top += atOffset[ 1 ];
1167
1168	return this.each(function() {
1169		var collisionPosition, using,
1170			elem = $( this ),
1171			elemWidth = elem.outerWidth(),
1172			elemHeight = elem.outerHeight(),
1173			marginLeft = parseCss( this, "marginLeft" ),
1174			marginTop = parseCss( this, "marginTop" ),
1175			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1176			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1177			position = $.extend( {}, basePosition ),
1178			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1179
1180		if ( options.my[ 0 ] === "right" ) {
1181			position.left -= elemWidth;
1182		} else if ( options.my[ 0 ] === "center" ) {
1183			position.left -= elemWidth / 2;
1184		}
1185
1186		if ( options.my[ 1 ] === "bottom" ) {
1187			position.top -= elemHeight;
1188		} else if ( options.my[ 1 ] === "center" ) {
1189			position.top -= elemHeight / 2;
1190		}
1191
1192		position.left += myOffset[ 0 ];
1193		position.top += myOffset[ 1 ];
1194
1195		// if the browser doesn't support fractions, then round for consistent results
1196		if ( !$.support.offsetFractions ) {
1197			position.left = round( position.left );
1198			position.top = round( position.top );
1199		}
1200
1201		collisionPosition = {
1202			marginLeft: marginLeft,
1203			marginTop: marginTop
1204		};
1205
1206		$.each( [ "left", "top" ], function( i, dir ) {
1207			if ( $.ui.position[ collision[ i ] ] ) {
1208				$.ui.position[ collision[ i ] ][ dir ]( position, {
1209					targetWidth: targetWidth,
1210					targetHeight: targetHeight,
1211					elemWidth: elemWidth,
1212					elemHeight: elemHeight,
1213					collisionPosition: collisionPosition,
1214					collisionWidth: collisionWidth,
1215					collisionHeight: collisionHeight,
1216					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1217					my: options.my,
1218					at: options.at,
1219					within: within,
1220					elem : elem
1221				});
1222			}
1223		});
1224
1225		if ( options.using ) {
1226			// adds feedback as second argument to using callback, if present
1227			using = function( props ) {
1228				var left = targetOffset.left - position.left,
1229					right = left + targetWidth - elemWidth,
1230					top = targetOffset.top - position.top,
1231					bottom = top + targetHeight - elemHeight,
1232					feedback = {
1233						target: {
1234							element: target,
1235							left: targetOffset.left,
1236							top: targetOffset.top,
1237							width: targetWidth,
1238							height: targetHeight
1239						},
1240						element: {
1241							element: elem,
1242							left: position.left,
1243							top: position.top,
1244							width: elemWidth,
1245							height: elemHeight
1246						},
1247						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1248						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1249					};
1250				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1251					feedback.horizontal = "center";
1252				}
1253				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1254					feedback.vertical = "middle";
1255				}
1256				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1257					feedback.important = "horizontal";
1258				} else {
1259					feedback.important = "vertical";
1260				}
1261				options.using.call( this, props, feedback );
1262			};
1263		}
1264
1265		elem.offset( $.extend( position, { using: using } ) );
1266	});
1267};
1268
1269$.ui.position = {
1270	fit: {
1271		left: function( position, data ) {
1272			var within = data.within,
1273				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1274				outerWidth = within.width,
1275				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1276				overLeft = withinOffset - collisionPosLeft,
1277				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1278				newOverRight;
1279
1280			// element is wider than within
1281			if ( data.collisionWidth > outerWidth ) {
1282				// element is initially over the left side of within
1283				if ( overLeft > 0 && overRight <= 0 ) {
1284					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1285					position.left += overLeft - newOverRight;
1286				// element is initially over right side of within
1287				} else if ( overRight > 0 && overLeft <= 0 ) {
1288					position.left = withinOffset;
1289				// element is initially over both left and right sides of within
1290				} else {
1291					if ( overLeft > overRight ) {
1292						position.left = withinOffset + outerWidth - data.collisionWidth;
1293					} else {
1294						position.left = withinOffset;
1295					}
1296				}
1297			// too far left -> align with left edge
1298			} else if ( overLeft > 0 ) {
1299				position.left += overLeft;
1300			// too far right -> align with right edge
1301			} else if ( overRight > 0 ) {
1302				position.left -= overRight;
1303			// adjust based on position and margin
1304			} else {
1305				position.left = max( position.left - collisionPosLeft, position.left );
1306			}
1307		},
1308		top: function( position, data ) {
1309			var within = data.within,
1310				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1311				outerHeight = data.within.height,
1312				collisionPosTop = position.top - data.collisionPosition.marginTop,
1313				overTop = withinOffset - collisionPosTop,
1314				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1315				newOverBottom;
1316
1317			// element is taller than within
1318			if ( data.collisionHeight > outerHeight ) {
1319				// element is initially over the top of within
1320				if ( overTop > 0 && overBottom <= 0 ) {
1321					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1322					position.top += overTop - newOverBottom;
1323				// element is initially over bottom of within
1324				} else if ( overBottom > 0 && overTop <= 0 ) {
1325					position.top = withinOffset;
1326				// element is initially over both top and bottom of within
1327				} else {
1328					if ( overTop > overBottom ) {
1329						position.top = withinOffset + outerHeight - data.collisionHeight;
1330					} else {
1331						position.top = withinOffset;
1332					}
1333				}
1334			// too far up -> align with top
1335			} else if ( overTop > 0 ) {
1336				position.top += overTop;
1337			// too far down -> align with bottom edge
1338			} else if ( overBottom > 0 ) {
1339				position.top -= overBottom;
1340			// adjust based on position and margin
1341			} else {
1342				position.top = max( position.top - collisionPosTop, position.top );
1343			}
1344		}
1345	},
1346	flip: {
1347		left: function( position, data ) {
1348			var within = data.within,
1349				withinOffset = within.offset.left + within.scrollLeft,
1350				outerWidth = within.width,
1351				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1352				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1353				overLeft = collisionPosLeft - offsetLeft,
1354				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1355				myOffset = data.my[ 0 ] === "left" ?
1356					-data.elemWidth :
1357					data.my[ 0 ] === "right" ?
1358						data.elemWidth :
1359						0,
1360				atOffset = data.at[ 0 ] === "left" ?
1361					data.targetWidth :
1362					data.at[ 0 ] === "right" ?
1363						-data.targetWidth :
1364						0,
1365				offset = -2 * data.offset[ 0 ],
1366				newOverRight,
1367				newOverLeft;
1368
1369			if ( overLeft < 0 ) {
1370				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1371				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1372					position.left += myOffset + atOffset + offset;
1373				}
1374			}
1375			else if ( overRight > 0 ) {
1376				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1377				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1378					position.left += myOffset + atOffset + offset;
1379				}
1380			}
1381		},
1382		top: function( position, data ) {
1383			var within = data.within,
1384				withinOffset = within.offset.top + within.scrollTop,
1385				outerHeight = within.height,
1386				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1387				collisionPosTop = position.top - data.collisionPosition.marginTop,
1388				overTop = collisionPosTop - offsetTop,
1389				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1390				top = data.my[ 1 ] === "top",
1391				myOffset = top ?
1392					-data.elemHeight :
1393					data.my[ 1 ] === "bottom" ?
1394						data.elemHeight :
1395						0,
1396				atOffset = data.at[ 1 ] === "top" ?
1397					data.targetHeight :
1398					data.at[ 1 ] === "bottom" ?
1399						-data.targetHeight :
1400						0,
1401				offset = -2 * data.offset[ 1 ],
1402				newOverTop,
1403				newOverBottom;
1404			if ( overTop < 0 ) {
1405				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1406				if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1407					position.top += myOffset + atOffset + offset;
1408				}
1409			}
1410			else if ( overBottom > 0 ) {
1411				newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1412				if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1413					position.top += myOffset + atOffset + offset;
1414				}
1415			}
1416		}
1417	},
1418	flipfit: {
1419		left: function() {
1420			$.ui.position.flip.left.apply( this, arguments );
1421			$.ui.position.fit.left.apply( this, arguments );
1422		},
1423		top: function() {
1424			$.ui.position.flip.top.apply( this, arguments );
1425			$.ui.position.fit.top.apply( this, arguments );
1426		}
1427	}
1428};
1429
1430// fraction support test
1431(function () {
1432	var testElement, testElementParent, testElementStyle, offsetLeft, i,
1433		body = document.getElementsByTagName( "body" )[ 0 ],
1434		div = document.createElement( "div" );
1435
1436	//Create a "fake body" for testing based on method used in jQuery.support
1437	testElement = document.createElement( body ? "div" : "body" );
1438	testElementStyle = {
1439		visibility: "hidden",
1440		width: 0,
1441		height: 0,
1442		border: 0,
1443		margin: 0,
1444		background: "none"
1445	};
1446	if ( body ) {
1447		$.extend( testElementStyle, {
1448			position: "absolute",
1449			left: "-1000px",
1450			top: "-1000px"
1451		});
1452	}
1453	for ( i in testElementStyle ) {
1454		testElement.style[ i ] = testElementStyle[ i ];
1455	}
1456	testElement.appendChild( div );
1457	testElementParent = body || document.documentElement;
1458	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1459
1460	div.style.cssText = "position: absolute; left: 10.7432222px;";
1461
1462	offsetLeft = $( div ).offset().left;
1463	$.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
1464
1465	testElement.innerHTML = "";
1466	testElementParent.removeChild( testElement );
1467})();
1468
1469}( jQuery ) );
1470(function($, undefined) {
1471
1472var dataSpace = "ui-effects-";
1473
1474$.effects = {
1475	effect: {}
1476};
1477
1478/*!
1479 * jQuery Color Animations v2.1.2
1480 * https://github.com/jquery/jquery-color
1481 *
1482 * Copyright 2013 jQuery Foundation and other contributors
1483 * Released under the MIT license.
1484 * http://jquery.org/license
1485 *
1486 * Date: Wed Jan 16 08:47:09 2013 -0600
1487 */
1488(function( jQuery, undefined ) {
1489
1490	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
1491
1492	// plusequals test for += 100 -= 100
1493	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
1494	// a set of RE's that can match strings and generate color tuples.
1495	stringParsers = [{
1496			re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1497			parse: function( execResult ) {
1498				return [
1499					execResult[ 1 ],
1500					execResult[ 2 ],
1501					execResult[ 3 ],
1502					execResult[ 4 ]
1503				];
1504			}
1505		}, {
1506			re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1507			parse: function( execResult ) {
1508				return [
1509					execResult[ 1 ] * 2.55,
1510					execResult[ 2 ] * 2.55,
1511					execResult[ 3 ] * 2.55,
1512					execResult[ 4 ]
1513				];
1514			}
1515		}, {
1516			// this regex ignores A-F because it's compared against an already lowercased string
1517			re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
1518			parse: function( execResult ) {
1519				return [
1520					parseInt( execResult[ 1 ], 16 ),
1521					parseInt( execResult[ 2 ], 16 ),
1522					parseInt( execResult[ 3 ], 16 )
1523				];
1524			}
1525		}, {
1526			// this regex ignores A-F because it's compared against an already lowercased string
1527			re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
1528			parse: function( execResult ) {
1529				return [
1530					parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
1531					parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
1532					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
1533				];
1534			}
1535		}, {
1536			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1537			space: "hsla",
1538			parse: function( execResult ) {
1539				return [
1540					execResult[ 1 ],
1541					execResult[ 2 ] / 100,
1542					execResult[ 3 ] / 100,
1543					execResult[ 4 ]
1544				];
1545			}
1546		}],
1547
1548	// jQuery.Color( )
1549	color = jQuery.Color = function( color, green, blue, alpha ) {
1550		return new jQuery.Color.fn.parse( color, green, blue, alpha );
1551	},
1552	spaces = {
1553		rgba: {
1554			props: {
1555				red: {
1556					idx: 0,
1557					type: "byte"
1558				},
1559				green: {
1560					idx: 1,
1561					type: "byte"
1562				},
1563				blue: {
1564					idx: 2,
1565					type: "byte"
1566				}
1567			}
1568		},
1569
1570		hsla: {
1571			props: {
1572				hue: {
1573					idx: 0,
1574					type: "degrees"
1575				},
1576				saturation: {
1577					idx: 1,
1578					type: "percent"
1579				},
1580				lightness: {
1581					idx: 2,
1582					type: "percent"
1583				}
1584			}
1585		}
1586	},
1587	propTypes = {
1588		"byte": {
1589			floor: true,
1590			max: 255
1591		},
1592		"percent": {
1593			max: 1
1594		},
1595		"degrees": {
1596			mod: 360,
1597			floor: true
1598		}
1599	},
1600	support = color.support = {},
1601
1602	// element for support tests
1603	supportElem = jQuery( "<p>" )[ 0 ],
1604
1605	// colors = jQuery.Color.names
1606	colors,
1607
1608	// local aliases of functions called often
1609	each = jQuery.each;
1610
1611// determine rgba support immediately
1612supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
1613support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
1614
1615// define cache name and alpha properties
1616// for rgba and hsla spaces
1617each( spaces, function( spaceName, space ) {
1618	space.cache = "_" + spaceName;
1619	space.props.alpha = {
1620		idx: 3,
1621		type: "percent",
1622		def: 1
1623	};
1624});
1625
1626function clamp( value, prop, allowEmpty ) {
1627	var type = propTypes[ prop.type ] || {};
1628
1629	if ( value == null ) {
1630		return (allowEmpty || !prop.def) ? null : prop.def;
1631	}
1632
1633	// ~~ is an short way of doing floor for positive numbers
1634	value = type.floor ? ~~value : parseFloat( value );
1635
1636	// IE will pass in empty strings as value for alpha,
1637	// which will hit this case
1638	if ( isNaN( value ) ) {
1639		return prop.def;
1640	}
1641
1642	if ( type.mod ) {
1643		// we add mod before modding to make sure that negatives values
1644		// get converted properly: -10 -> 350
1645		return (value + type.mod) % type.mod;
1646	}
1647
1648	// for now all property types without mod have min and max
1649	return 0 > value ? 0 : type.max < value ? type.max : value;
1650}
1651
1652function stringParse( string ) {
1653	var inst = color(),
1654		rgba = inst._rgba = [];
1655
1656	string = string.toLowerCase();
1657
1658	each( stringParsers, function( i, parser ) {
1659		var parsed,
1660			match = parser.re.exec( string ),
1661			values = match && parser.parse( match ),
1662			spaceName = parser.space || "rgba";
1663
1664		if ( values ) {
1665			parsed = inst[ spaceName ]( values );
1666
1667			// if this was an rgba parse the assignment might happen twice
1668			// oh well....
1669			inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
1670			rgba = inst._rgba = parsed._rgba;
1671
1672			// exit each( stringParsers ) here because we matched
1673			return false;
1674		}
1675	});
1676
1677	// Found a stringParser that handled it
1678	if ( rgba.length ) {
1679
1680		// if this came from a parsed string, force "transparent" when alpha is 0
1681		// chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
1682		if ( rgba.join() === "0,0,0,0" ) {
1683			jQuery.extend( rgba, colors.transparent );
1684		}
1685		return inst;
1686	}
1687
1688	// named colors
1689	return colors[ string ];
1690}
1691
1692color.fn = jQuery.extend( color.prototype, {
1693	parse: function( red, green, blue, alpha ) {
1694		if ( red === undefined ) {
1695			this._rgba = [ null, null, null, null ];
1696			return this;
1697		}
1698		if ( red.jquery || red.nodeType ) {
1699			red = jQuery( red ).css( green );
1700			green = undefined;
1701		}
1702
1703		var inst = this,
1704			type = jQuery.type( red ),
1705			rgba = this._rgba = [];
1706
1707		// more than 1 argument specified - assume ( red, green, blue, alpha )
1708		if ( green !== undefined ) {
1709			red = [ red, green, blue, alpha ];
1710			type = "array";
1711		}
1712
1713		if ( type === "string" ) {
1714			return this.parse( stringParse( red ) || colors._default );
1715		}
1716
1717		if ( type === "array" ) {
1718			each( spaces.rgba.props, function( key, prop ) {
1719				rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
1720			});
1721			return this;
1722		}
1723
1724		if ( type === "object" ) {
1725			if ( red instanceof color ) {
1726				each( spaces, function( spaceName, space ) {
1727					if ( red[ space.cache ] ) {
1728						inst[ space.cache ] = red[ space.cache ].slice();
1729					}
1730				});
1731			} else {
1732				each( spaces, function( spaceName, space ) {
1733					var cache = space.cache;
1734					each( space.props, function( key, prop ) {
1735
1736						// if the cache doesn't exist, and we know how to convert
1737						if ( !inst[ cache ] && space.to ) {
1738
1739							// if the value was null, we don't need to copy it
1740							// if the key was alpha, we don't need to copy it either
1741							if ( key === "alpha" || red[ key ] == null ) {
1742								return;
1743							}
1744							inst[ cache ] = space.to( inst._rgba );
1745						}
1746
1747						// this is the only case where we allow nulls for ALL properties.
1748						// call clamp with alwaysAllowEmpty
1749						inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
1750					});
1751
1752					// everything defined but alpha?
1753					if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
1754						// use the default of 1
1755						inst[ cache ][ 3 ] = 1;
1756						if ( space.from ) {
1757							inst._rgba = space.from( inst[ cache ] );
1758						}
1759					}
1760				});
1761			}
1762			return this;
1763		}
1764	},
1765	is: function( compare ) {
1766		var is = color( compare ),
1767			same = true,
1768			inst = this;
1769
1770		each( spaces, function( _, space ) {
1771			var localCache,
1772				isCache = is[ space.cache ];
1773			if (isCache) {
1774				localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
1775				each( space.props, function( _, prop ) {
1776					if ( isCache[ prop.idx ] != null ) {
1777						same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
1778						return same;
1779					}
1780				});
1781			}
1782			return same;
1783		});
1784		return same;
1785	},
1786	_space: function() {
1787		var used = [],
1788			inst = this;
1789		each( spaces, function( spaceName, space ) {
1790			if ( inst[ space.cache ] ) {
1791				used.push( spaceName );
1792			}
1793		});
1794		return used.pop();
1795	},
1796	transition: function( other, distance ) {
1797		var end = color( other ),
1798			spaceName = end._space(),
1799			space = spaces[ spaceName ],
1800			startColor = this.alpha() === 0 ? color( "transparent" ) : this,
1801			start = startColor[ space.cache ] || space.to( startColor._rgba ),
1802			result = start.slice();
1803
1804		end = end[ space.cache ];
1805		each( space.props, function( key, prop ) {
1806			var index = prop.idx,
1807				startValue = start[ index ],
1808				endValue = end[ index ],
1809				type = propTypes[ prop.type ] || {};
1810
1811			// if null, don't override start value
1812			if ( endValue === null ) {
1813				return;
1814			}
1815			// if null - use end
1816			if ( startValue === null ) {
1817				result[ index ] = endValue;
1818			} else {
1819				if ( type.mod ) {
1820					if ( endValue - startValue > type.mod / 2 ) {
1821						startValue += type.mod;
1822					} else if ( startValue - endValue > type.mod / 2 ) {
1823						startValue -= type.mod;
1824					}
1825				}
1826				result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
1827			}
1828		});
1829		return this[ spaceName ]( result );
1830	},
1831	blend: function( opaque ) {
1832		// if we are already opaque - return ourself
1833		if ( this._rgba[ 3 ] === 1 ) {
1834			return this;
1835		}
1836
1837		var rgb = this._rgba.slice(),
1838			a = rgb.pop(),
1839			blend = color( opaque )._rgba;
1840
1841		return color( jQuery.map( rgb, function( v, i ) {
1842			return ( 1 - a ) * blend[ i ] + a * v;
1843		}));
1844	},
1845	toRgbaString: function() {
1846		var prefix = "rgba(",
1847			rgba = jQuery.map( this._rgba, function( v, i ) {
1848				return v == null ? ( i > 2 ? 1 : 0 ) : v;
1849			});
1850
1851		if ( rgba[ 3 ] === 1 ) {
1852			rgba.pop();
1853			prefix = "rgb(";
1854		}
1855
1856		return prefix + rgba.join() + ")";
1857	},
1858	toHslaString: function() {
1859		var prefix = "hsla(",
1860			hsla = jQuery.map( this.hsla(), function( v, i ) {
1861				if ( v == null ) {
1862					v = i > 2 ? 1 : 0;
1863				}
1864
1865				// catch 1 and 2
1866				if ( i && i < 3 ) {
1867					v = Math.round( v * 100 ) + "%";
1868				}
1869				return v;
1870			});
1871
1872		if ( hsla[ 3 ] === 1 ) {
1873			hsla.pop();
1874			prefix = "hsl(";
1875		}
1876		return prefix + hsla.join() + ")";
1877	},
1878	toHexString: function( includeAlpha ) {
1879		var rgba = this._rgba.slice(),
1880			alpha = rgba.pop();
1881
1882		if ( includeAlpha ) {
1883			rgba.push( ~~( alpha * 255 ) );
1884		}
1885
1886		return "#" + jQuery.map( rgba, function( v ) {
1887
1888			// default to 0 when nulls exist
1889			v = ( v || 0 ).toString( 16 );
1890			return v.length === 1 ? "0" + v : v;
1891		}).join("");
1892	},
1893	toString: function() {
1894		return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
1895	}
1896});
1897color.fn.parse.prototype = color.fn;
1898
1899// hsla conversions adapted from:
1900// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
1901
1902function hue2rgb( p, q, h ) {
1903	h = ( h + 1 ) % 1;
1904	if ( h * 6 < 1 ) {
1905		return p + (q - p) * h * 6;
1906	}
1907	if ( h * 2 < 1) {
1908		return q;
1909	}
1910	if ( h * 3 < 2 ) {
1911		return p + (q - p) * ((2/3) - h) * 6;
1912	}
1913	return p;
1914}
1915
1916spaces.hsla.to = function ( rgba ) {
1917	if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
1918		return [ null, null, null, rgba[ 3 ] ];
1919	}
1920	var r = rgba[ 0 ] / 255,
1921		g = rgba[ 1 ] / 255,
1922		b = rgba[ 2 ] / 255,
1923		a = rgba[ 3 ],
1924		max = Math.max( r, g, b ),
1925		min = Math.min( r, g, b ),
1926		diff = max - min,
1927		add = max + min,
1928		l = add * 0.5,
1929		h, s;
1930
1931	if ( min === max ) {
1932		h = 0;
1933	} else if ( r === max ) {
1934		h = ( 60 * ( g - b ) / diff ) + 360;
1935	} else if ( g === max ) {
1936		h = ( 60 * ( b - r ) / diff ) + 120;
1937	} else {
1938		h = ( 60 * ( r - g ) / diff ) + 240;
1939	}
1940
1941	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
1942	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
1943	if ( diff === 0 ) {
1944		s = 0;
1945	} else if ( l <= 0.5 ) {
1946		s = diff / add;
1947	} else {
1948		s = diff / ( 2 - add );
1949	}
1950	return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
1951};
1952
1953spaces.hsla.from = function ( hsla ) {
1954	if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
1955		return [ null, null, null, hsla[ 3 ] ];
1956	}
1957	var h = hsla[ 0 ] / 360,
1958		s = hsla[ 1 ],
1959		l = hsla[ 2 ],
1960		a = hsla[ 3 ],
1961		q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
1962		p = 2 * l - q;
1963
1964	return [
1965		Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
1966		Math.round( hue2rgb( p, q, h ) * 255 ),
1967		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
1968		a
1969	];
1970};
1971
1972
1973each( spaces, function( spaceName, space ) {
1974	var props = space.props,
1975		cache = space.cache,
1976		to = space.to,
1977		from = space.from;
1978
1979	// makes rgba() and hsla()
1980	color.fn[ spaceName ] = function( value ) {
1981
1982		// generate a cache for this space if it doesn't exist
1983		if ( to && !this[ cache ] ) {
1984			this[ cache ] = to( this._rgba );
1985		}
1986		if ( value === undefined ) {
1987			return this[ cache ].slice();
1988		}
1989
1990		var ret,
1991			type = jQuery.type( value ),
1992			arr = ( type === "array" || type === "object" ) ? value : arguments,
1993			local = this[ cache ].slice();
1994
1995		each( props, function( key, prop ) {
1996			var val = arr[ type === "object" ? key : prop.idx ];
1997			if ( val == null ) {
1998				val = local[ prop.idx ];
1999			}
2000			local[ prop.idx ] = clamp( val, prop );
2001		});
2002
2003		if ( from ) {
2004			ret = color( from( local ) );
2005			ret[ cache ] = local;
2006			return ret;
2007		} else {
2008			return color( local );
2009		}
2010	};
2011
2012	// makes red() green() blue() alpha() hue() saturation() lightness()
2013	each( props, function( key, prop ) {
2014		// alpha is included in more than one space
2015		if ( color.fn[ key ] ) {
2016			return;
2017		}
2018		color.fn[ key ] = function( value ) {
2019			var vtype = jQuery.type( value ),
2020				fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
2021				local = this[ fn ](),
2022				cur = local[ prop.idx ],
2023				match;
2024
2025			if ( vtype === "undefined" ) {
2026				return cur;
2027			}
2028
2029			if ( vtype === "function" ) {
2030				value = value.call( this, cur );
2031				vtype = jQuery.type( value );
2032			}
2033			if ( value == null && prop.empty ) {
2034				return this;
2035			}
2036			if ( vtype === "string" ) {
2037				match = rplusequals.exec( value );
2038				if ( match ) {
2039					value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
2040				}
2041			}
2042			local[ prop.idx ] = value;
2043			return this[ fn ]( local );
2044		};
2045	});
2046});
2047
2048// add cssHook and .fx.step function for each named hook.
2049// accept a space separated string of properties
2050color.hook = function( hook ) {
2051	var hooks = hook.split( " " );
2052	each( hooks, function( i, hook ) {
2053		jQuery.cssHooks[ hook ] = {
2054			set: function( elem, value ) {
2055				var parsed, curElem,
2056					backgroundColor = "";
2057
2058				if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
2059					value = color( parsed || value );
2060					if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
2061						curElem = hook === "backgroundColor" ? elem.parentNode : elem;
2062						while (
2063							(backgroundColor === "" || backgroundColor === "transparent") &&
2064							curElem && curElem.style
2065						) {
2066							try {
2067								backgroundColor = jQuery.css( curElem, "backgroundColor" );
2068								curElem = curElem.parentNode;
2069							} catch ( e ) {
2070							}
2071						}
2072
2073						value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
2074							backgroundColor :
2075							"_default" );
2076					}
2077
2078					value = value.toRgbaString();
2079				}
2080				try {
2081					elem.style[ hook ] = value;
2082				} catch( e ) {
2083					// wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
2084				}
2085			}
2086		};
2087		jQuery.fx.step[ hook ] = function( fx ) {
2088			if ( !fx.colorInit ) {
2089				fx.start = color( fx.elem, hook );
2090				fx.end = color( fx.end );
2091				fx.colorInit = true;
2092			}
2093			jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
2094		};
2095	});
2096
2097};
2098
2099color.hook( stepHooks );
2100
2101jQuery.cssHooks.borderColor = {
2102	expand: function( value ) {
2103		var expanded = {};
2104
2105		each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
2106			expanded[ "border" + part + "Color" ] = value;
2107		});
2108		return expanded;
2109	}
2110};
2111
2112// Basic color names only.
2113// Usage of any of the other color names requires adding yourself or including
2114// jquery.color.svg-names.js.
2115colors = jQuery.Color.names = {
2116	// 4.1. Basic color keywords
2117	aqua: "#00ffff",
2118	black: "#000000",
2119	blue: "#0000ff",
2120	fuchsia: "#ff00ff",
2121	gray: "#808080",
2122	green: "#008000",
2123	lime: "#00ff00",
2124	maroon: "#800000",
2125	navy: "#000080",
2126	olive: "#808000",
2127	purple: "#800080",
2128	red: "#ff0000",
2129	silver: "#c0c0c0",
2130	teal: "#008080",
2131	white: "#ffffff",
2132	yellow: "#ffff00",
2133
2134	// 4.2.3. "transparent" color keyword
2135	transparent: [ null, null, null, 0 ],
2136
2137	_default: "#ffffff"
2138};
2139
2140})( jQuery );
2141
2142
2143/******************************************************************************/
2144/****************************** CLASS ANIMATIONS ******************************/
2145/******************************************************************************/
2146(function() {
2147
2148var classAnimationActions = [ "add", "remove", "toggle" ],
2149	shorthandStyles = {
2150		border: 1,
2151		borderBottom: 1,
2152		borderColor: 1,
2153		borderLeft: 1,
2154		borderRight: 1,
2155		borderTop: 1,
2156		borderWidth: 1,
2157		margin: 1,
2158		padding: 1
2159	};
2160
2161$.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
2162	$.fx.step[ prop ] = function( fx ) {
2163		if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
2164			jQuery.style( fx.elem, prop, fx.end );
2165			fx.setAttr = true;
2166		}
2167	};
2168});
2169
2170function getElementStyles( elem ) {
2171	var key, len,
2172		style = elem.ownerDocument.defaultView ?
2173			elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
2174			elem.currentStyle,
2175		styles = {};
2176
2177	if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
2178		len = style.length;
2179		while ( len-- ) {
2180			key = style[ len ];
2181			if ( typeof style[ key ] === "string" ) {
2182				styles[ $.camelCase( key ) ] = style[ key ];
2183			}
2184		}
2185	// support: Opera, IE <9
2186	} else {
2187		for ( key in style ) {
2188			if ( typeof style[ key ] === "string" ) {
2189				styles[ key ] = style[ key ];
2190			}
2191		}
2192	}
2193
2194	return styles;
2195}
2196
2197
2198function styleDifference( oldStyle, newStyle ) {
2199	var diff = {},
2200		name, value;
2201
2202	for ( name in newStyle ) {
2203		value = newStyle[ name ];
2204		if ( oldStyle[ name ] !== value ) {
2205			if ( !shorthandStyles[ name ] ) {
2206				if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
2207					diff[ name ] = value;
2208				}
2209			}
2210		}
2211	}
2212
2213	return diff;
2214}
2215
2216// support: jQuery <1.8
2217if ( !$.fn.addBack ) {
2218	$.fn.addBack = function( selector ) {
2219		return this.add( selector == null ?
2220			this.prevObject : this.prevObject.filter( selector )
2221		);
2222	};
2223}
2224
2225$.effects.animateClass = function( value, duration, easing, callback ) {
2226	var o = $.speed( duration, easing, callback );
2227
2228	return this.queue( function() {
2229		var animated = $( this ),
2230			baseClass = animated.attr( "class" ) || "",
2231			applyClassChange,
2232			allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
2233
2234		// map the animated objects to store the original styles.
2235		allAnimations = allAnimations.map(function() {
2236			var el = $( this );
2237			return {
2238				el: el,
2239				start: getElementStyles( this )
2240			};
2241		});
2242
2243		// apply class change
2244		applyClassChange = function() {
2245			$.each( classAnimationActions, function(i, action) {
2246				if ( value[ action ] ) {
2247					animated[ action + "Class" ]( value[ action ] );
2248				}
2249			});
2250		};
2251		applyClassChange();
2252
2253		// map all animated objects again - calculate new styles and diff
2254		allAnimations = allAnimations.map(function() {
2255			this.end = getElementStyles( this.el[ 0 ] );
2256			this.diff = styleDifference( this.start, this.end );
2257			return this;
2258		});
2259
2260		// apply original class
2261		animated.attr( "class", baseClass );
2262
2263		// map all animated objects again - this time collecting a promise
2264		allAnimations = allAnimations.map(function() {
2265			var styleInfo = this,
2266				dfd = $.Deferred(),
2267				opts = $.extend({}, o, {
2268					queue: false,
2269					complete: function() {
2270						dfd.resolve( styleInfo );
2271					}
2272				});
2273
2274			this.el.animate( this.diff, opts );
2275			return dfd.promise();
2276		});
2277
2278		// once all animations have completed:
2279		$.when.apply( $, allAnimations.get() ).done(function() {
2280
2281			// set the final class
2282			applyClassChange();
2283
2284			// for each animated element,
2285			// clear all css properties that were animated
2286			$.each( arguments, function() {
2287				var el = this.el;
2288				$.each( this.diff, function(key) {
2289					el.css( key, "" );
2290				});
2291			});
2292
2293			// this is guarnteed to be there if you use jQuery.speed()
2294			// it also handles dequeuing the next anim...
2295			o.complete.call( animated[ 0 ] );
2296		});
2297	});
2298};
2299
2300$.fn.extend({
2301	addClass: (function( orig ) {
2302		return function( classNames, speed, easing, callback ) {
2303			return speed ?
2304				$.effects.animateClass.call( this,
2305					{ add: classNames }, speed, easing, callback ) :
2306				orig.apply( this, arguments );
2307		};
2308	})( $.fn.addClass ),
2309
2310	removeClass: (function( orig ) {
2311		return function( classNames, speed, easing, callback ) {
2312			return arguments.length > 1 ?
2313				$.effects.animateClass.call( this,
2314					{ remove: classNames }, speed, easing, callback ) :
2315				orig.apply( this, arguments );
2316		};
2317	})( $.fn.removeClass ),
2318
2319	toggleClass: (function( orig ) {
2320		return function( classNames, force, speed, easing, callback ) {
2321			if ( typeof force === "boolean" || force === undefined ) {
2322				if ( !speed ) {
2323					// without speed parameter
2324					return orig.apply( this, arguments );
2325				} else {
2326					return $.effects.animateClass.call( this,
2327						(force ? { add: classNames } : { remove: classNames }),
2328						speed, easing, callback );
2329				}
2330			} else {
2331				// without force parameter
2332				return $.effects.animateClass.call( this,
2333					{ toggle: classNames }, force, speed, easing );
2334			}
2335		};
2336	})( $.fn.toggleClass ),
2337
2338	switchClass: function( remove, add, speed, easing, callback) {
2339		return $.effects.animateClass.call( this, {
2340			add: add,
2341			remove: remove
2342		}, speed, easing, callback );
2343	}
2344});
2345
2346})();
2347
2348/******************************************************************************/
2349/*********************************** EFFECTS **********************************/
2350/******************************************************************************/
2351
2352(function() {
2353
2354$.extend( $.effects, {
2355	version: "1.10.3",
2356
2357	// Saves a set of properties in a data storage
2358	save: function( element, set ) {
2359		for( var i=0; i < set.length; i++ ) {
2360			if ( set[ i ] !== null ) {
2361				element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
2362			}
2363		}
2364	},
2365
2366	// Restores a set of previously saved properties from a data storage
2367	restore: function( element, set ) {
2368		var val, i;
2369		for( i=0; i < set.length; i++ ) {
2370			if ( set[ i ] !== null ) {
2371				val = element.data( dataSpace + set[ i ] );
2372				// support: jQuery 1.6.2
2373				// http://bugs.jquery.com/ticket/9917
2374				// jQuery 1.6.2 incorrectly returns undefined for any falsy value.
2375				// We can't differentiate between "" and 0 here, so we just assume
2376				// empty string since it's likely to be a more common value...
2377				if ( val === undefined ) {
2378					val = "";
2379				}
2380				element.css( set[ i ], val );
2381			}
2382		}
2383	},
2384
2385	setMode: function( el, mode ) {
2386		if (mode === "toggle") {
2387			mode = el.is( ":hidden" ) ? "show" : "hide";
2388		}
2389		return mode;
2390	},
2391
2392	// Translates a [top,left] array into a baseline value
2393	// this should be a little more flexible in the future to handle a string & hash
2394	getBaseline: function( origin, original ) {
2395		var y, x;
2396		switch ( origin[ 0 ] ) {
2397			case "top": y = 0; break;
2398			case "middle": y = 0.5; break;
2399			case "bottom": y = 1; break;
2400			default: y = origin[ 0 ] / original.height;
2401		}
2402		switch ( origin[ 1 ] ) {
2403			case "left": x = 0; break;
2404			case "center": x = 0.5; break;
2405			case "right": x = 1; break;
2406			default: x = origin[ 1 ] / original.width;
2407		}
2408		return {
2409			x: x,
2410			y: y
2411		};
2412	},
2413
2414	// Wraps the element around a wrapper that copies position properties
2415	createWrapper: function( element ) {
2416
2417		// if the element is already wrapped, return it
2418		if ( element.parent().is( ".ui-effects-wrapper" )) {
2419			return element.parent();
2420		}
2421
2422		// wrap the element
2423		var props = {
2424				width: element.outerWidth(true),
2425				height: element.outerHeight(true),
2426				"float": element.css( "float" )
2427			},
2428			wrapper = $( "<div></div>" )
2429				.addClass( "ui-effects-wrapper" )
2430				.css({
2431					fontSize: "100%",
2432					background: "transparent",
2433					border: "none",
2434					margin: 0,
2435					padding: 0
2436				}),
2437			// Store the size in case width/height are defined in % - Fixes #5245
2438			size = {
2439				width: element.width(),
2440				height: element.height()
2441			},
2442			active = document.activeElement;
2443
2444		// support: Firefox
2445		// Firefox incorrectly exposes anonymous content
2446		// https://bugzilla.mozilla.org/show_bug.cgi?id=561664
2447		try {
2448			active.id;
2449		} catch( e ) {
2450			active = document.body;
2451		}
2452
2453		element.wrap( wrapper );
2454
2455		// Fixes #7595 - Elements lose focus when wrapped.
2456		if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
2457			$( active ).focus();
2458		}
2459
2460		wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
2461
2462		// transfer positioning properties to the wrapper
2463		if ( element.css( "position" ) === "static" ) {
2464			wrapper.css({ position: "relative" });
2465			element.css({ position: "relative" });
2466		} else {
2467			$.extend( props, {
2468				position: element.css( "position" ),
2469				zIndex: element.css( "z-index" )
2470			});
2471			$.each([ "top", "left", "bottom", "right" ], function(i, pos) {
2472				props[ pos ] = element.css( pos );
2473				if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
2474					props[ pos ] = "auto";
2475				}
2476			});
2477			element.css({
2478				position: "relative",
2479				top: 0,
2480				left: 0,
2481				right: "auto",
2482				bottom: "auto"
2483			});
2484		}
2485		element.css(size);
2486
2487		return wrapper.css( props ).show();
2488	},
2489
2490	removeWrapper: function( element ) {
2491		var active = document.activeElement;
2492
2493		if ( element.parent().is( ".ui-effects-wrapper" ) ) {
2494			element.parent().replaceWith( element );
2495
2496			// Fixes #7595 - Elements lose focus when wrapped.
2497			if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
2498				$( active ).focus();
2499			}
2500		}
2501
2502
2503		return element;
2504	},
2505
2506	setTransition: function( element, list, factor, value ) {
2507		value = value || {};
2508		$.each( list, function( i, x ) {
2509			var unit = element.cssUnit( x );
2510			if ( unit[ 0 ] > 0 ) {
2511				value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
2512			}
2513		});
2514		return value;
2515	}
2516});
2517
2518// return an effect options object for the given parameters:
2519function _normalizeArguments( effect, options, speed, callback ) {
2520
2521	// allow passing all options as the first parameter
2522	if ( $.isPlainObject( effect ) ) {
2523		options = effect;
2524		effect = effect.effect;
2525	}
2526
2527	// convert to an object
2528	effect = { effect: effect };
2529
2530	// catch (effect, null, ...)
2531	if ( options == null ) {
2532		options = {};
2533	}
2534
2535	// catch (effect, callback)
2536	if ( $.isFunction( options ) ) {
2537		callback = options;
2538		speed = null;
2539		options = {};
2540	}
2541
2542	// catch (effect, speed, ?)
2543	if ( typeof options === "number" || $.fx.speeds[ options ] ) {
2544		callback = speed;
2545		speed = options;
2546		options = {};
2547	}
2548
2549	// catch (effect, options, callback)
2550	if ( $.isFunction( speed ) ) {
2551		callback = speed;
2552		speed = null;
2553	}
2554
2555	// add options to effect
2556	if ( options ) {
2557		$.extend( effect, options );
2558	}
2559
2560	speed = speed || options.duration;
2561	effect.duration = $.fx.off ? 0 :
2562		typeof speed === "number" ? speed :
2563		speed in $.fx.speeds ? $.fx.speeds[ speed ] :
2564		$.fx.speeds._default;
2565
2566	effect.complete = callback || options.complete;
2567
2568	return effect;
2569}
2570
2571function standardAnimationOption( option ) {
2572	// Valid standard speeds (nothing, number, named speed)
2573	if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
2574		return true;
2575	}
2576
2577	// Invalid strings - treat as "normal" speed
2578	if ( typeof option === "string" && !$.effects.effect[ option ] ) {
2579		return true;
2580	}
2581
2582	// Complete callback
2583	if ( $.isFunction( option ) ) {
2584		return true;
2585	}
2586
2587	// Options hash (but not naming an effect)
2588	if ( typeof option === "object" && !option.effect ) {
2589		return true;
2590	}
2591
2592	// Didn't match any standard API
2593	return false;
2594}
2595
2596$.fn.extend({
2597	effect: function( /* effect, options, speed, callback */ ) {
2598		var args = _normalizeArguments.apply( this, arguments ),
2599			mode = args.mode,
2600			queue = args.queue,
2601			effectMethod = $.effects.effect[ args.effect ];
2602
2603		if ( $.fx.off || !effectMethod ) {
2604			// delegate to the original method (e.g., .show()) if possible
2605			if ( mode ) {
2606				return this[ mode ]( args.duration, args.complete );
2607			} else {
2608				return this.each( function() {
2609					if ( args.complete ) {
2610						args.complete.call( this );
2611					}
2612				});
2613			}
2614		}
2615
2616		function run( next ) {
2617			var elem = $( this ),
2618				complete = args.complete,
2619				mode = args.mode;
2620
2621			function done() {
2622				if ( $.isFunction( complete ) ) {
2623					complete.call( elem[0] );
2624				}
2625				if ( $.isFunction( next ) ) {
2626					next();
2627				}
2628			}
2629
2630			// If the element already has the correct final state, delegate to
2631			// the core methods so the internal tracking of "olddisplay" works.
2632			if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
2633				elem[ mode ]();
2634				done();
2635			} else {
2636				effectMethod.call( elem[0], args, done );
2637			}
2638		}
2639
2640		return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
2641	},
2642
2643	show: (function( orig ) {
2644		return function( option ) {
2645			if ( standardAnimationOption( option ) ) {
2646				return orig.apply( this, arguments );
2647			} else {
2648				var args = _normalizeArguments.apply( this, arguments );
2649				args.mode = "show";
2650				return this.effect.call( this, args );
2651			}
2652		};
2653	})( $.fn.show ),
2654
2655	hide: (function( orig ) {
2656		return function( option ) {
2657			if ( standardAnimationOption( option ) ) {
2658				return orig.apply( this, arguments );
2659			} else {
2660				var args = _normalizeArguments.apply( this, arguments );
2661				args.mode = "hide";
2662				return this.effect.call( this, args );
2663			}
2664		};
2665	})( $.fn.hide ),
2666
2667	toggle: (function( orig ) {
2668		return function( option ) {
2669			if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
2670				return orig.apply( this, arguments );
2671			} else {
2672				var args = _normalizeArguments.apply( this, arguments );
2673				args.mode = "toggle";
2674				return this.effect.call( this, args );
2675			}
2676		};
2677	})( $.fn.toggle ),
2678
2679	// helper functions
2680	cssUnit: function(key) {
2681		var style = this.css( key ),
2682			val = [];
2683
2684		$.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
2685			if ( style.indexOf( unit ) > 0 ) {
2686				val = [ parseFloat( style ), unit ];
2687			}
2688		});
2689		return val;
2690	}
2691});
2692
2693})();
2694
2695/******************************************************************************/
2696/*********************************** EASING ***********************************/
2697/******************************************************************************/
2698
2699(function() {
2700
2701// based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
2702
2703var baseEasings = {};
2704
2705$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
2706	baseEasings[ name ] = function( p ) {
2707		return Math.pow( p, i + 2 );
2708	};
2709});
2710
2711$.extend( baseEasings, {
2712	Sine: function ( p ) {
2713		return 1 - Math.cos( p * Math.PI / 2 );
2714	},
2715	Circ: function ( p ) {
2716		return 1 - Math.sqrt( 1 - p * p );
2717	},
2718	Elastic: function( p ) {
2719		return p === 0 || p === 1 ? p :
2720			-Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
2721	},
2722	Back: function( p ) {
2723		return p * p * ( 3 * p - 2 );
2724	},
2725	Bounce: function ( p ) {
2726		var pow2,
2727			bounce = 4;
2728
2729		while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
2730		return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
2731	}
2732});
2733
2734$.each( baseEasings, function( name, easeIn ) {
2735	$.easing[ "easeIn" + name ] = easeIn;
2736	$.easing[ "easeOut" + name ] = function( p ) {
2737		return 1 - easeIn( 1 - p );
2738	};
2739	$.easing[ "easeInOut" + name ] = function( p ) {
2740		return p < 0.5 ?
2741			easeIn( p * 2 ) / 2 :
2742			1 - easeIn( p * -2 + 2 ) / 2;
2743	};
2744});
2745
2746})();
2747
2748})(jQuery);
2749(function( $, undefined ) {
2750
2751var rvertical = /up|down|vertical/,
2752	rpositivemotion = /up|left|vertical|horizontal/;
2753
2754$.effects.effect.blind = function( o, done ) {
2755	// Create element
2756	var el = $( this ),
2757		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
2758		mode = $.effects.setMode( el, o.mode || "hide" ),
2759		direction = o.direction || "up",
2760		vertical = rvertical.test( direction ),
2761		ref = vertical ? "height" : "width",
2762		ref2 = vertical ? "top" : "left",
2763		motion = rpositivemotion.test( direction ),
2764		animation = {},
2765		show = mode === "show",
2766		wrapper, distance, margin;
2767
2768	// if already wrapped, the wrapper's properties are my property. #6245
2769	if ( el.parent().is( ".ui-effects-wrapper" ) ) {
2770		$.effects.save( el.parent(), props );
2771	} else {
2772		$.effects.save( el, props );
2773	}
2774	el.show();
2775	wrapper = $.effects.createWrapper( el ).css({
2776		overflow: "hidden"
2777	});
2778
2779	distance = wrapper[ ref ]();
2780	margin = parseFloat( wrapper.css( ref2 ) ) || 0;
2781
2782	animation[ ref ] = show ? distance : 0;
2783	if ( !motion ) {
2784		el
2785			.css( vertical ? "bottom" : "right", 0 )
2786			.css( vertical ? "top" : "left", "auto" )
2787			.css({ position: "absolute" });
2788
2789		animation[ ref2 ] = show ? margin : distance + margin;
2790	}
2791
2792	// start at 0 if we are showing
2793	if ( show ) {
2794		wrapper.css( ref, 0 );
2795		if ( ! motion ) {
2796			wrapper.css( ref2, margin + distance );
2797		}
2798	}
2799
2800	// Animate
2801	wrapper.animate( animation, {
2802		duration: o.duration,
2803		easing: o.easing,
2804		queue: false,
2805		complete: function() {
2806			if ( mode === "hide" ) {
2807				el.hide();
2808			}
2809			$.effects.restore( el, props );
2810			$.effects.removeWrapper( el );
2811			done();
2812		}
2813	});
2814
2815};
2816
2817})(jQuery);
2818(function( $, undefined ) {
2819
2820$.effects.effect.bounce = function( o, done ) {
2821	var el = $( this ),
2822		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
2823
2824		// defaults:
2825		mode = $.effects.setMode( el, o.mode || "effect" ),
2826		hide = mode === "hide",
2827		show = mode === "show",
2828		direction = o.direction || "up",
2829		distance = o.distance,
2830		times = o.times || 5,
2831
2832		// number of internal animations
2833		anims = times * 2 + ( show || hide ? 1 : 0 ),
2834		speed = o.duration / anims,
2835		easing = o.easing,
2836
2837		// utility:
2838		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
2839		motion = ( direction === "up" || direction === "left" ),
2840		i,
2841		upAnim,
2842		downAnim,
2843
2844		// we will need to re-assemble the queue to stack our animations in place
2845		queue = el.queue(),
2846		queuelen = queue.length;
2847
2848	// Avoid touching opacity to prevent clearType and PNG issues in IE
2849	if ( show || hide ) {
2850		props.push( "opacity" );
2851	}
2852
2853	$.effects.save( el, props );
2854	el.show();
2855	$.effects.createWrapper( el ); // Create Wrapper
2856
2857	// default distance for the BIGGEST bounce is the outer Distance / 3
2858	if ( !distance ) {
2859		distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
2860	}
2861
2862	if ( show ) {
2863		downAnim = { opacity: 1 };
2864		downAnim[ ref ] = 0;
2865
2866		// if we are showing, force opacity 0 and set the initial position
2867		// then do the "first" animation
2868		el.css( "opacity", 0 )
2869			.css( ref, motion ? -distance * 2 : distance * 2 )
2870			.animate( downAnim, speed, easing );
2871	}
2872
2873	// start at the smallest distance if we are hiding
2874	if ( hide ) {
2875		distance = distance / Math.pow( 2, times - 1 );
2876	}
2877
2878	downAnim = {};
2879	downAnim[ ref ] = 0;
2880	// Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
2881	for ( i = 0; i < times; i++ ) {
2882		upAnim = {};
2883		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
2884
2885		el.animate( upAnim, speed, easing )
2886			.animate( downAnim, speed, easing );
2887
2888		distance = hide ? distance * 2 : distance / 2;
2889	}
2890
2891	// Last Bounce when Hiding
2892	if ( hide ) {
2893		upAnim = { opacity: 0 };
2894		upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
2895
2896		el.animate( upAnim, speed, easing );
2897	}
2898
2899	el.queue(function() {
2900		if ( hide ) {
2901			el.hide();
2902		}
2903		$.effects.restore( el, props );
2904		$.effects.removeWrapper( el );
2905		done();
2906	});
2907
2908	// inject all the animations we just queued to be first in line (after "inprogress")
2909	if ( queuelen > 1) {
2910		queue.splice.apply( queue,
2911			[ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
2912	}
2913	el.dequeue();
2914
2915};
2916
2917})(jQuery);
2918(function( $, undefined ) {
2919
2920$.effects.effect.clip = function( o, done ) {
2921	// Create element
2922	var el = $( this ),
2923		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
2924		mode = $.effects.setMode( el, o.mode || "hide" ),
2925		show = mode === "show",
2926		direction = o.direction || "vertical",
2927		vert = direction === "vertical",
2928		size = vert ? "height" : "width",
2929		position = vert ? "top" : "left",
2930		animation = {},
2931		wrapper, animate, distance;
2932
2933	// Save & Show
2934	$.effects.save( el, props );
2935	el.show();
2936
2937	// Create Wrapper
2938	wrapper = $.effects.createWrapper( el ).css({
2939		overflow: "hidden"
2940	});
2941	animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
2942	distance = animate[ size ]();
2943
2944	// Shift
2945	if ( show ) {
2946		animate.css( size, 0 );
2947		animate.css( position, distance / 2 );
2948	}
2949
2950	// Create Animation Object:
2951	animation[ size ] = show ? distance : 0;
2952	animation[ position ] = show ? 0 : distance / 2;
2953
2954	// Animate
2955	animate.animate( animation, {
2956		queue: false,
2957		duration: o.duration,
2958		easing: o.easing,
2959		complete: function() {
2960			if ( !show ) {
2961				el.hide();
2962			}
2963			$.effects.restore( el, props );
2964			$.effects.removeWrapper( el );
2965			done();
2966		}
2967	});
2968
2969};
2970
2971})(jQuery);
2972(function( $, undefined ) {
2973
2974$.effects.effect.drop = function( o, done ) {
2975
2976	var el = $( this ),
2977		props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
2978		mode = $.effects.setMode( el, o.mode || "hide" ),
2979		show = mode === "show",
2980		direction = o.direction || "left",
2981		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
2982		motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
2983		animation = {
2984			opacity: show ? 1 : 0
2985		},
2986		distance;
2987
2988	// Adjust
2989	$.effects.save( el, props );
2990	el.show();
2991	$.effects.createWrapper( el );
2992
2993	distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]( true ) / 2;
2994
2995	if ( show ) {
2996		el
2997			.css( "opacity", 0 )
2998			.css( ref, motion === "pos" ? -distance : distance );
2999	}
3000
3001	// Animation
3002	animation[ ref ] = ( show ?
3003		( motion === "pos" ? "+=" : "-=" ) :
3004		( motion === "pos" ? "-=" : "+=" ) ) +
3005		distance;
3006
3007	// Animate
3008	el.animate( animation, {
3009		queue: false,
3010		duration: o.duration,
3011		easing: o.easing,
3012		complete: function() {
3013			if ( mode === "hide" ) {
3014				el.hide();
3015			}
3016			$.effects.restore( el, props );
3017			$.effects.removeWrapper( el );
3018			done();
3019		}
3020	});
3021};
3022
3023})(jQuery);
3024(function( $, undefined ) {
3025
3026$.effects.effect.explode = function( o, done ) {
3027
3028	var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
3029		cells = rows,
3030		el = $( this ),
3031		mode = $.effects.setMode( el, o.mode || "hide" ),
3032		show = mode === "show",
3033
3034		// show and then visibility:hidden the element before calculating offset
3035		offset = el.show().css( "visibility", "hidden" ).offset(),
3036
3037		// width and height of a piece
3038		width = Math.ceil( el.outerWidth() / cells ),
3039		height = Math.ceil( el.outerHeight() / rows ),
3040		pieces = [],
3041
3042		// loop
3043		i, j, left, top, mx, my;
3044
3045	// children animate complete:
3046	function childComplete() {
3047		pieces.push( this );
3048		if ( pieces.length === rows * cells ) {
3049			animComplete();
3050		}
3051	}
3052
3053	// clone the element for each row and cell.
3054	for( i = 0; i < rows ; i++ ) { // ===>
3055		top = offset.top + i * height;
3056		my = i - ( rows - 1 ) / 2 ;
3057
3058		for( j = 0; j < cells ; j++ ) { // |||
3059			left = offset.left + j * width;
3060			mx = j - ( cells - 1 ) / 2 ;
3061
3062			// Create a clone of the now hidden main element that will be absolute positioned
3063			// within a wrapper div off the -left and -top equal to size of our pieces
3064			el
3065				.clone()
3066				.appendTo( "body" )
3067				.wrap( "<div></div>" )
3068				.css({
3069					position: "absolute",
3070					visibility: "visible",
3071					left: -j * width,
3072					top: -i * height
3073				})
3074
3075			// select the wrapper - make it overflow: hidden and absolute positioned based on
3076			// where the original was located +left and +top equal to the size of pieces
3077				.parent()
3078				.addClass( "ui-effects-explode" )
3079				.css({
3080					position: "absolute",
3081					overflow: "hidden",
3082					width: width,
3083					height: height,
3084					left: left + ( show ? mx * width : 0 ),
3085					top: top + ( show ? my * height : 0 ),
3086					opacity: show ? 0 : 1
3087				}).animate({
3088					left: left + ( show ? 0 : mx * width ),
3089					top: top + ( show ? 0 : my * height ),
3090					opacity: show ? 1 : 0
3091				}, o.duration || 500, o.easing, childComplete );
3092		}
3093	}
3094
3095	function animComplete() {
3096		el.css({
3097			visibility: "visible"
3098		});
3099		$( pieces ).remove();
3100		if ( !show ) {
3101			el.hide();
3102		}
3103		done();
3104	}
3105};
3106
3107})(jQuery);
3108(function( $, undefined ) {
3109
3110$.effects.effect.fade = function( o, done ) {
3111	var el = $( this ),
3112		mode = $.effects.setMode( el, o.mode || "toggle" );
3113
3114	el.animate({
3115		opacity: mode
3116	}, {
3117		queue: false,
3118		duration: o.duration,
3119		easing: o.easing,
3120		complete: done
3121	});
3122};
3123
3124})( jQuery );
3125(function( $, undefined ) {
3126
3127$.effects.effect.fold = function( o, done ) {
3128
3129	// Create element
3130	var el = $( this ),
3131		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
3132		mode = $.effects.setMode( el, o.mode || "hide" ),
3133		show = mode === "show",
3134		hide = mode === "hide",
3135		size = o.size || 15,
3136		percent = /([0-9]+)%/.exec( size ),
3137		horizFirst = !!o.horizFirst,
3138		widthFirst = show !== horizFirst,
3139		ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
3140		duration = o.duration / 2,
3141		wrapper, distance,
3142		animation1 = {},
3143		animation2 = {};
3144
3145	$.effects.save( el, props );
3146	el.show();
3147
3148	// Create Wrapper
3149	wrapper = $.effects.createWrapper( el ).css({
3150		overflow: "hidden"
3151	});
3152	distance = widthFirst ?
3153		[ wrapper.width(), wrapper.height() ] :
3154		[ wrapper.height(), wrapper.width() ];
3155
3156	if ( percent ) {
3157		size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
3158	}
3159	if ( show ) {
3160		wrapper.css( horizFirst ? {
3161			height: 0,
3162			width: size
3163		} : {
3164			height: size,
3165			width: 0
3166		});
3167	}
3168
3169	// Animation
3170	animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
3171	animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
3172
3173	// Animate
3174	wrapper
3175		.animate( animation1, duration, o.easing )
3176		.animate( animation2, duration, o.easing, function() {
3177			if ( hide ) {
3178				el.hide();
3179			}
3180			$.effects.restore( el, props );
3181			$.effects.removeWrapper( el );
3182			done();
3183		});
3184
3185};
3186
3187})(jQuery);
3188(function( $, undefined ) {
3189
3190$.effects.effect.highlight = function( o, done ) {
3191	var elem = $( this ),
3192		props = [ "backgroundImage", "backgroundColor", "opacity" ],
3193		mode = $.effects.setMode( elem, o.mode || "show" ),
3194		animation = {
3195			backgroundColor: elem.css( "backgroundColor" )
3196		};
3197
3198	if (mode === "hide") {
3199		animation.opacity = 0;
3200	}
3201
3202	$.effects.save( elem, props );
3203
3204	elem
3205		.show()
3206		.css({
3207			backgroundImage: "none",
3208			backgroundColor: o.color || "#ffff99"
3209		})
3210		.animate( animation, {
3211			queue: false,
3212			duration: o.duration,
3213			easing: o.easing,
3214			complete: function() {
3215				if ( mode === "hide" ) {
3216					elem.hide();
3217				}
3218				$.effects.restore( elem, props );
3219				done();
3220			}
3221		});
3222};
3223
3224})(jQuery);
3225(function( $, undefined ) {
3226
3227$.effects.effect.pulsate = function( o, done ) {
3228	var elem = $( this ),
3229		mode = $.effects.setMode( elem, o.mode || "show" ),
3230		show = mode === "show",
3231		hide = mode === "hide",
3232		showhide = ( show || mode === "hide" ),
3233
3234		// showing or hiding leaves of the "last" animation
3235		anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
3236		duration = o.duration / anims,
3237		animateTo = 0,
3238		queue = elem.queue(),
3239		queuelen = queue.length,
3240		i;
3241
3242	if ( show || !elem.is(":visible")) {
3243		elem.css( "opacity", 0 ).show();
3244		animateTo = 1;
3245	}
3246
3247	// anims - 1 opacity "toggles"
3248	for ( i = 1; i < anims; i++ ) {
3249		elem.animate({
3250			opacity: animateTo
3251		}, duration, o.easing );
3252		animateTo = 1 - animateTo;
3253	}
3254
3255	elem.animate({
3256		opacity: animateTo
3257	}, duration, o.easing);
3258
3259	elem.queue(function() {
3260		if ( hide ) {
3261			elem.hide();
3262		}
3263		done();
3264	});
3265
3266	// We just queued up "anims" animations, we need to put them next in the queue
3267	if ( queuelen > 1 ) {
3268		queue.splice.apply( queue,
3269			[ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
3270	}
3271	elem.dequeue();
3272};
3273
3274})(jQuery);
3275(function( $, undefined ) {
3276
3277$.effects.effect.puff = function( o, done ) {
3278	var elem = $( this ),
3279		mode = $.effects.setMode( elem, o.mode || "hide" ),
3280		hide = mode === "hide",
3281		percent = parseInt( o.percent, 10 ) || 150,
3282		factor = percent / 100,
3283		original = {
3284			height: elem.height(),
3285			width: elem.width(),
3286			outerHeight: elem.outerHeight(),
3287			outerWidth: elem.outerWidth()
3288		};
3289
3290	$.extend( o, {
3291		effect: "scale",
3292		queue: false,
3293		fade: true,
3294		mode: mode,
3295		complete: done,
3296		percent: hide ? percent : 100,
3297		from: hide ?
3298			original :
3299			{
3300				height: original.height * factor,
3301				width: original.width * factor,
3302				outerHeight: original.outerHeight * factor,
3303				outerWidth: original.outerWidth * factor
3304			}
3305	});
3306
3307	elem.effect( o );
3308};
3309
3310$.effects.effect.scale = function( o, done ) {
3311
3312	// Create element
3313	var el = $( this ),
3314		options = $.extend( true, {}, o ),
3315		mode = $.effects.setMode( el, o.mode || "effect" ),
3316		percent = parseInt( o.percent, 10 ) ||
3317			( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
3318		direction = o.direction || "both",
3319		origin = o.origin,
3320		original = {
3321			height: el.height(),
3322			width: el.width(),
3323			outerHeight: el.outerHeight(),
3324			outerWidth: el.outerWidth()
3325		},
3326		factor = {
3327			y: direction !== "horizontal" ? (percent / 100) : 1,
3328			x: direction !== "vertical" ? (percent / 100) : 1
3329		};
3330
3331	// We are going to pass this effect to the size effect:
3332	options.effect = "size";
3333	options.queue = false;
3334	options.complete = done;
3335
3336	// Set default origin and restore for show/hide
3337	if ( mode !== "effect" ) {
3338		options.origin = origin || ["middle","center"];
3339		options.restore = true;
3340	}
3341
3342	options.from = o.from || ( mode === "show" ? {
3343		height: 0,
3344		width: 0,
3345		outerHeight: 0,
3346		outerWidth: 0
3347	} : original );
3348	options.to = {
3349		height: original.height * factor.y,
3350		width: original.width * factor.x,
3351		outerHeight: original.outerHeight * factor.y,
3352		outerWidth: original.outerWidth * factor.x
3353	};
3354
3355	// Fade option to support puff
3356	if ( options.fade ) {
3357		if ( mode === "show" ) {
3358			options.from.opacity = 0;
3359			options.to.opacity = 1;
3360		}
3361		if ( mode === "hide" ) {
3362			options.from.opacity = 1;
3363			options.to.opacity = 0;
3364		}
3365	}
3366
3367	// Animate
3368	el.effect( options );
3369
3370};
3371
3372$.effects.effect.size = function( o, done ) {
3373
3374	// Create element
3375	var original, baseline, factor,
3376		el = $( this ),
3377		props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
3378
3379		// Always restore
3380		props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
3381
3382		// Copy for children
3383		props2 = [ "width", "height", "overflow" ],
3384		cProps = [ "fontSize" ],
3385		vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
3386		hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
3387
3388		// Set options
3389		mode = $.effects.setMode( el, o.mode || "effect" ),
3390		restore = o.restore || mode !== "effect",
3391		scale = o.scale || "both",
3392		origin = o.origin || [ "middle", "center" ],
3393		position = el.css( "position" ),
3394		props = restore ? props0 : props1,
3395		zero = {
3396			height: 0,
3397			width: 0,
3398			outerHeight: 0,
3399			outerWidth: 0
3400		};
3401
3402	if ( mode === "show" ) {
3403		el.show();
3404	}
3405	original = {
3406		height: el.height(),
3407		width: el.width(),
3408		outerHeight: el.outerHeight(),
3409		outerWidth: el.outerWidth()
3410	};
3411
3412	if ( o.mode === "toggle" && mode === "show" ) {
3413		el.from = o.to || zero;
3414		el.to = o.from || original;
3415	} else {
3416		el.from = o.from || ( mode === "show" ? zero : original );
3417		el.to = o.to || ( mode === "hide" ? zero : original );
3418	}
3419
3420	// Set scaling factor
3421	factor = {
3422		from: {
3423			y: el.from.height / original.height,
3424			x: el.from.width / original.width
3425		},
3426		to: {
3427			y: el.to.height / original.height,
3428			x: el.to.width / original.width
3429		}
3430	};
3431
3432	// Scale the css box
3433	if ( scale === "box" || scale === "both" ) {
3434
3435		// Vertical props scaling
3436		if ( factor.from.y !== factor.to.y ) {
3437			props = props.concat( vProps );
3438			el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
3439			el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
3440		}
3441
3442		// Horizontal props scaling
3443		if ( factor.from.x !== factor.to.x ) {
3444			props = props.concat( hProps );
3445			el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
3446			el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
3447		}
3448	}
3449
3450	// Scale the content
3451	if ( scale === "content" || scale === "both" ) {
3452
3453		// Vertical props scaling
3454		if ( factor.from.y !== factor.to.y ) {
3455			props = props.concat( cProps ).concat( props2 );
3456			el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
3457			el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
3458		}
3459	}
3460
3461	$.effects.save( el, props );
3462	el.show();
3463	$.effects.createWrapper( el );
3464	el.css( "overflow", "hidden" ).css( el.from );
3465
3466	// Adjust
3467	if (origin) { // Calculate baseline shifts
3468		baseline = $.effects.getBaseline( origin, original );
3469		el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
3470		el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
3471		el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
3472		el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
3473	}
3474	el.css( el.from ); // set top & left
3475
3476	// Animate
3477	if ( scale === "content" || scale === "both" ) { // Scale the children
3478
3479		// Add margins/font-size
3480		vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
3481		hProps = hProps.concat([ "marginLeft", "marginRight" ]);
3482		props2 = props0.concat(vProps).concat(hProps);
3483
3484		el.find( "*[width]" ).each( function(){
3485			var child = $( this ),
3486				c_original = {
3487					height: child.height(),
3488					width: child.width(),
3489					outerHeight: child.outerHeight(),
3490					outerWidth: child.outerWidth()
3491				};
3492			if (restore) {
3493				$.effects.save(child, props2);
3494			}
3495
3496			child.from = {
3497				height: c_original.height * factor.from.y,
3498				width: c_original.width * factor.from.x,
3499				outerHeight: c_original.outerHeight * factor.from.y,
3500				outerWidth: c_original.outerWidth * factor.from.x
3501			};
3502			child.to = {
3503				height: c_original.height * factor.to.y,
3504				width: c_original.width * factor.to.x,
3505				outerHeight: c_original.height * factor.to.y,
3506				outerWidth: c_original.width * factor.to.x
3507			};
3508
3509			// Vertical props scaling
3510			if ( factor.from.y !== factor.to.y ) {
3511				child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
3512				child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
3513			}
3514
3515			// Horizontal props scaling
3516			if ( factor.from.x !== factor.to.x ) {
3517				child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
3518				child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
3519			}
3520
3521			// Animate children
3522			child.css( child.from );
3523			child.animate( child.to, o.duration, o.easing, function() {
3524
3525				// Restore children
3526				if ( restore ) {
3527					$.effects.restore( child, props2 );
3528				}
3529			});
3530		});
3531	}
3532
3533	// Animate
3534	el.animate( el.to, {
3535		queue: false,
3536		duration: o.duration,
3537		easing: o.easing,
3538		complete: function() {
3539			if ( el.to.opacity === 0 ) {
3540				el.css( "opacity", el.from.opacity );
3541			}
3542			if( mode === "hide" ) {
3543				el.hide();
3544			}
3545			$.effects.restore( el, props );
3546			if ( !restore ) {
3547
3548				// we need to calculate our new positioning based on the scaling
3549				if ( position === "static" ) {
3550					el.css({
3551						position: "relative",
3552						top: el.to.top,
3553						left: el.to.left
3554					});
3555				} else {
3556					$.each([ "top", "left" ], function( idx, pos ) {
3557						el.css( pos, function( _, str ) {
3558							var val = parseInt( str, 10 ),
3559								toRef = idx ? el.to.left : el.to.top;
3560
3561							// if original was "auto", recalculate the new value from wrapper
3562							if ( str === "auto" ) {
3563								return toRef + "px";
3564							}
3565
3566							return val + toRef + "px";
3567						});
3568					});
3569				}
3570			}
3571
3572			$.effects.removeWrapper( el );
3573			done();
3574		}
3575	});
3576
3577};
3578
3579})(jQuery);
3580(function( $, undefined ) {
3581
3582$.effects.effect.shake = function( o, done ) {
3583
3584	var el = $( this ),
3585		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
3586		mode = $.effects.setMode( el, o.mode || "effect" ),
3587		direction = o.direction || "left",
3588		distance = o.distance || 20,
3589		times = o.times || 3,
3590		anims = times * 2 + 1,
3591		speed = Math.round(o.duration/anims),
3592		ref = (direction === "up" || direction === "down") ? "top" : "left",
3593		positiveMotion = (direction === "up" || direction === "left"),
3594		animation = {},
3595		animation1 = {},
3596		animation2 = {},
3597		i,
3598
3599		// we will need to re-assemble the queue to stack our animations in place
3600		queue = el.queue(),
3601		queuelen = queue.length;
3602
3603	$.effects.save( el, props );
3604	el.show();
3605	$.effects.createWrapper( el );
3606
3607	// Animation
3608	animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
3609	animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
3610	animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
3611
3612	// Animate
3613	el.animate( animation, speed, o.easing );
3614
3615	// Shakes
3616	for ( i = 1; i < times; i++ ) {
3617		el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
3618	}
3619	el
3620		.animate( animation1, speed, o.easing )
3621		.animate( animation, speed / 2, o.easing )
3622		.queue(function() {
3623			if ( mode === "hide" ) {
3624				el.hide();
3625			}
3626			$.effects.restore( el, props );
3627			$.effects.removeWrapper( el );
3628			done();
3629		});
3630
3631	// inject all the animations we just queued to be first in line (after "inprogress")
3632	if ( queuelen > 1) {
3633		queue.splice.apply( queue,
3634			[ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
3635	}
3636	el.dequeue();
3637
3638};
3639
3640})(jQuery);
3641(function( $, undefined ) {
3642
3643$.effects.effect.slide = function( o, done ) {
3644
3645	// Create element
3646	var el = $( this ),
3647		props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
3648		mode = $.effects.setMode( el, o.mode || "show" ),
3649		show = mode === "show",
3650		direction = o.direction || "left",
3651		ref = (direction === "up" || direction === "down") ? "top" : "left",
3652		positiveMotion = (direction === "up" || direction === "left"),
3653		distance,
3654		animation = {};
3655
3656	// Adjust
3657	$.effects.save( el, props );
3658	el.show();
3659	distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
3660
3661	$.effects.createWrapper( el ).css({
3662		overflow: "hidden"
3663	});
3664
3665	if ( show ) {
3666		el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
3667	}
3668
3669	// Animation
3670	animation[ ref ] = ( show ?
3671		( positiveMotion ? "+=" : "-=") :
3672		( positiveMotion ? "-=" : "+=")) +
3673		distance;
3674
3675	// Animate
3676	el.animate( animation, {
3677		queue: false,
3678		duration: o.duration,
3679		easing: o.easing,
3680		complete: function() {
3681			if ( mode === "hide" ) {
3682				el.hide();
3683			}
3684			$.effects.restore( el, props );
3685			$.effects.removeWrapper( el );
3686			done();
3687		}
3688	});
3689};
3690
3691})(jQuery);
3692(function( $, undefined ) {
3693
3694$.effects.effect.transfer = function( o, done ) {
3695	var elem = $( this ),
3696		target = $( o.to ),
3697		targetFixed = target.css( "position" ) === "fixed",
3698		body = $("body"),
3699		fixTop = targetFixed ? body.scrollTop() : 0,
3700		fixLeft = targetFixed ? body.scrollLeft() : 0,
3701		endPosition = target.offset(),
3702		animation = {
3703			top: endPosition.top - fixTop ,
3704			left: endPosition.left - fixLeft ,
3705			height: target.innerHeight(),
3706			width: target.innerWidth()
3707		},
3708		startPosition = elem.offset(),
3709		transfer = $( "<div class='ui-effects-transfer'></div>" )
3710			.appendTo( document.body )
3711			.addClass( o.className )
3712			.css({
3713				top: startPosition.top - fixTop ,
3714				left: startPosition.left - fixLeft ,
3715				height: elem.innerHeight(),
3716				width: elem.innerWidth(),
3717				position: targetFixed ? "fixed" : "absolute"
3718			})
3719			.animate( animation, o.duration, o.easing, function() {
3720				transfer.remove();
3721				done();
3722			});
3723};
3724
3725})(jQuery);