/drupal7/sites/all/modules/jquery_update/replace/ui/ui/jquery-ui.js - Diff - Club Drupal - Forge Centrale Marseille

Révision 503b3f7b

Ajouté par Assos Assos il y a environ 10 ans

ID 503b3f7ba498ca4c938fba91061c0c284e26727d
Parent 00430a4b
Enfant 580203ed

Weekly update of contrib modules

     /*!
      * jQuery UI 1.8.11
+     *
      * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
      * Dual licensed under the MIT or GPL Version 2 licenses.
      * http://jquery.org/license
+     *
      * http://docs.jquery.com/UI
      */
     /*! jQuery UI - v1.10.2 - 2013-03-14
     * http://jqueryui.com
     * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.effect.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.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, jquery.ui.menu.js, jquery.ui.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
     * Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
     (function( $, undefined ) {
     // prevent duplicate loading
     // this is only a problem because we proxy existing functions
     // and we don't want to double proxy them
     var uuid = 0,
     	runiqueId = /^ui-id-\d+$/;
     // $.ui might exist from components with no dependencies, e.g., $.ui.position
     $.ui = $.ui || {};
     if ( $.ui.version ) {
     	return;
+    }
     $.extend( $.ui, {
     	version: "1.8.11",
     	version: "1.10.2",
     	keyCode: {
     		ALT: 18,
     		BACKSPACE: 8,
     		CAPS_LOCK: 20,
     		COMMA: 188,
     		COMMAND: 91,
     		COMMAND_LEFT: 91, // COMMAND
     		COMMAND_RIGHT: 93,
     		CONTROL: 17,
     		DELETE: 46,
     		DOWN: 40,
     		END: 35,
     		ENTER: 13,
     		ESCAPE: 27,
     		HOME: 36,
     		INSERT: 45,
     		LEFT: 37,
     		MENU: 93, // COMMAND_RIGHT
     		NUMPAD_ADD: 107,
     		NUMPAD_DECIMAL: 110,
     		NUMPAD_DIVIDE: 111,
-...
     		PAGE_UP: 33,
     		PERIOD: 190,
     		RIGHT: 39,
     		SHIFT: 16,
     		SPACE: 32,
     		TAB: 9,
     		UP: 38,
     		WINDOWS: 91 // COMMAND
     		UP: 38
+    	}
     });
     // plugins
     $.fn.extend({
     	_focus: $.fn.focus,
     	focus: function( delay, fn ) {
     		return typeof delay === "number" ?
     			this.each(function() {
     				var elem = this;
     				setTimeout(function() {
     					$( elem ).focus();
     					if ( fn ) {
     						fn.call( elem );
+    					}
     				}, delay );
     			}) :
     			this._focus.apply( this, arguments );
     	},
     	focus: (function( orig ) {
     		return function( delay, fn ) {
     			return typeof delay === "number" ?
     				this.each(function() {
     					var elem = this;
     					setTimeout(function() {
     						$( elem ).focus();
     						if ( fn ) {
     							fn.call( elem );
+    						}
     					}, delay );
     				}) :
     				orig.apply( this, arguments );
     		};
     	})( $.fn.focus ),
     	scrollParent: function() {
     		var scrollParent;
     		if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
     		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
     			scrollParent = this.parents().filter(function() {
     				return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
     				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
     			}).eq(0);
     		} else {
     			scrollParent = this.parents().filter(function() {
     				return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
     				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
     			}).eq(0);
+    		}
     		return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
     		return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
     	},
     	zIndex: function( zIndex ) {
-...
     		return 0;
     	},
     	disableSelection: function() {
     		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
     			".ui-disableSelection", function( event ) {
     				event.preventDefault();
     			});
     	},
     	enableSelection: function() {
     		return this.unbind( ".ui-disableSelection" );
+    	}
     });
     $.each( [ "Width", "Height" ], function( i, name ) {
     	var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
     		type = name.toLowerCase(),
     		orig = {
     			innerWidth: $.fn.innerWidth,
     			innerHeight: $.fn.innerHeight,
     			outerWidth: $.fn.outerWidth,
     			outerHeight: $.fn.outerHeight
     		};
     	function reduce( elem, size, border, margin ) {
     		$.each( side, function() {
     			size -= parseFloat( $.curCSS( elem, "padding" + this, true) ) || 0;
     			if ( border ) {
     				size -= parseFloat( $.curCSS( elem, "border" + this + "Width", true) ) || 0;
+    			}
     			if ( margin ) {
     				size -= parseFloat( $.curCSS( elem, "margin" + this, true) ) || 0;
+    			}
     		});
     		return size;
+    	}
     	$.fn[ "inner" + name ] = function( size ) {
     		if ( size === undefined ) {
     			return orig[ "inner" + name ].call( this );
+    		}
     	uniqueId: function() {
     		return this.each(function() {
     			$( this ).css( type, reduce( this, size ) + "px" );
     			if ( !this.id ) {
     				this.id = "ui-id-" + (++uuid);
+    			}
     		});
     	};
     	$.fn[ "outer" + name] = function( size, margin ) {
     		if ( typeof size !== "number" ) {
     			return orig[ "outer" + name ].call( this, size );
+    		}
     	},
     	removeUniqueId: function() {
     		return this.each(function() {
     			$( this).css( type, reduce( this, size, true, margin ) + "px" );
     			if ( runiqueId.test( this.id ) ) {
     				$( this ).removeAttr( "id" );
+    			}
     		});
     	};
+    	}
     });
     // selectors
     function focusable( element, isTabIndexNotNaN ) {
     	var map, mapName, img,
     		nodeName = element.nodeName.toLowerCase();
     	if ( "area" === nodeName ) {
     		map = element.parentNode;
     		mapName = map.name;
     		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
     			return false;
+    		}
     		img = $( "img[usemap=#" + mapName + "]" )[0];
     		return !!img && visible( img );
+    	}
     	return ( /input|select|textarea|button|object/.test( nodeName ) ?
     		!element.disabled :
     		"a" === nodeName ?
     			element.href || isTabIndexNotNaN :
     			isTabIndexNotNaN) &&
     		// the element and all of its ancestors must be visible
     		visible( element );
+    }
     function visible( element ) {
     	return !$( element ).parents().andSelf().filter(function() {
     		return $.curCSS( this, "visibility" ) === "hidden" ||
     			$.expr.filters.hidden( this );
     	}).length;
     	return $.expr.filters.visible( element ) &&
     		!$( element ).parents().addBack().filter(function() {
     			return $.css( this, "visibility" ) === "hidden";
     		}).length;
+    }
     $.extend( $.expr[ ":" ], {
     	data: function( elem, i, match ) {
     		return !!$.data( elem, match[ 3 ] );
     	},
     	data: $.expr.createPseudo ?
     		$.expr.createPseudo(function( dataName ) {
     			return function( elem ) {
     				return !!$.data( elem, dataName );
     			};
     		}) :
     		// support: jQuery <1.8
     		function( elem, i, match ) {
     			return !!$.data( elem, match[ 3 ] );
     		},
     	focusable: function( element ) {
     		var nodeName = element.nodeName.toLowerCase(),
     			tabIndex = $.attr( element, "tabindex" );
     		if ( "area" === nodeName ) {
     			var map = element.parentNode,
     				mapName = map.name,
     				img;
     			if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
     				return false;
+    			}
     			img = $( "img[usemap=#" + mapName + "]" )[0];
     			return !!img && visible( img );
+    		}
     		return ( /input|select|textarea|button|object/.test( nodeName )
     			? !element.disabled
     			: "a" == nodeName
     				? element.href || !isNaN( tabIndex )
     				: !isNaN( tabIndex ))
     			// the element and all of its ancestors must be visible
     			&& visible( element );
     		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
     	},
     	tabbable: function( element ) {
     		var tabIndex = $.attr( element, "tabindex" );
     		return ( isNaN( tabIndex ) || tabIndex >= 0 ) && $( element ).is( ":focusable" );
     		var tabIndex = $.attr( element, "tabindex" ),
     			isTabIndexNaN = isNaN( tabIndex );
     		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
+    	}
     });
     // support
     $(function() {
     	var body = document.body,
     		div = body.appendChild( div = document.createElement( "div" ) );
     // support: jQuery <1.8
     if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
     	$.each( [ "Width", "Height" ], function( i, name ) {
     		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
     			type = name.toLowerCase(),
     			orig = {
     				innerWidth: $.fn.innerWidth,
     				innerHeight: $.fn.innerHeight,
     				outerWidth: $.fn.outerWidth,
     				outerHeight: $.fn.outerHeight
     			};
     	$.extend( div.style, {
     		minHeight: "100px",
     		height: "auto",
     		padding: 0,
     		borderWidth: 0
     		function reduce( elem, size, border, margin ) {
     			$.each( side, function() {
     				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
     				if ( border ) {
     					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
+    				}
     				if ( margin ) {
     					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
+    				}
     			});
     			return size;
+    		}
     		$.fn[ "inner" + name ] = function( size ) {
     			if ( size === undefined ) {
     				return orig[ "inner" + name ].call( this );
+    			}
     			return this.each(function() {
     				$( this ).css( type, reduce( this, size ) + "px" );
     			});
     		};
     		$.fn[ "outer" + name] = function( size, margin ) {
     			if ( typeof size !== "number" ) {
     				return orig[ "outer" + name ].call( this, size );
+    			}
     			return this.each(function() {
     				$( this).css( type, reduce( this, size, true, margin ) + "px" );
     			});
     		};
     	});
+    }
     	$.support.minHeight = div.offsetHeight === 100;
     	$.support.selectstart = "onselectstart" in div;
     // support: jQuery <1.8
     if ( !$.fn.addBack ) {
     	$.fn.addBack = function( selector ) {
     		return this.add( selector == null ?
     			this.prevObject : this.prevObject.filter( selector )
     		);
     	};
+    }
     	// set display to none to avoid a layout bug in IE
     	// http://dev.jquery.com/ticket/4014
     	body.removeChild( div ).style.display = "none";
     });
     // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
     if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
     	$.fn.removeData = (function( removeData ) {
     		return function( key ) {
     			if ( arguments.length ) {
     				return removeData.call( this, $.camelCase( key ) );
     			} else {
     				return removeData.call( this );
+    			}
     		};
     	})( $.fn.removeData );
+    }
     // deprecated
     $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
     $.support.selectstart = "onselectstart" in document.createElement( "div" );
     $.fn.extend({
     	disableSelection: function() {
     		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
     			".ui-disableSelection", function( event ) {
     				event.preventDefault();
     			});
     	},
     	enableSelection: function() {
     		return this.unbind( ".ui-disableSelection" );
+    	}
     });
     $.extend( $.ui, {
     	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
     	plugin: {
     		add: function( module, option, set ) {
     			var proto = $.ui[ module ].prototype;
     			for ( var i in set ) {
     			var i,
     				proto = $.ui[ module ].prototype;
     			for ( i in set ) {
     				proto.plugins[ i ] = proto.plugins[ i ] || [];
     				proto.plugins[ i ].push( [ option, set[ i ] ] );
+    			}
     		},
     		call: function( instance, name, args ) {
     			var set = instance.plugins[ name ];
     			if ( !set || !instance.element[ 0 ].parentNode ) {
     			var i,
     				set = instance.plugins[ name ];
     			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
     				return;
+    			}
     			for ( var i = 0; i < set.length; i++ ) {
     			for ( i = 0; i < set.length; i++ ) {
     				if ( instance.options[ set[ i ][ 0 ] ] ) {
     					set[ i ][ 1 ].apply( instance.element, args );
+    				}
+    			}
+    		}
     	},
     	// will be deprecated when we switch to jQuery 1.4 - use jQuery.contains()
     	contains: function( a, b ) {
     		return document.compareDocumentPosition ?
     			a.compareDocumentPosition( b ) & 16 :
     			a !== b && a.contains( b );
     	},
     	// only used by resizable
     	hasScroll: function( el, a ) {
     		//If overflow is hidden, the element might have extra content, but the user wants to hide it
     		if ( $( el ).css( "overflow" ) === "hidden") {
     			return false;
+    		}
     		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
     			has = false;
     		if ( el[ scroll ] > 0 ) {
     			return true;
+    		}
     		// TODO: determine which cases actually cause this to happen
     		// if the element doesn't have the scroll set, see if it's possible to
     		// set the scroll
-...
     		has = ( el[ scroll ] > 0 );
     		el[ scroll ] = 0;
     		return has;
     	},
     	// these are odd functions, fix the API or move into individual plugins
     	isOverAxis: function( x, reference, size ) {
     		//Determines when x coordinate is over "b" element axis
     		return ( x > reference ) && ( x < ( reference + size ) );
     	},
     	isOver: function( y, x, top, left, height, width ) {
     		//Determines when x, y coordinates is over "b" element
     		return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
+    	}
     });
     })( jQuery );
     /*!
      * jQuery UI Widget 1.8.11
+     *
      * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
      * Dual licensed under the MIT or GPL Version 2 licenses.
      * http://jquery.org/license
+     *
      * http://docs.jquery.com/UI/Widget
      */
     (function( $, undefined ) {
     // jQuery 1.4+
     if ( $.cleanData ) {
     	var _cleanData = $.cleanData;
     	$.cleanData = function( elems ) {
     		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
     var uuid = 0,
     	slice = Array.prototype.slice,
     	_cleanData = $.cleanData;
     $.cleanData = function( elems ) {
     	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
     		try {
     			$( elem ).triggerHandler( "remove" );
+    		}
     		_cleanData( elems );
     	};
     } else {
     	var _remove = $.fn.remove;
     	$.fn.remove = function( selector, keepData ) {
     		return this.each(function() {
     			if ( !keepData ) {
     				if ( !selector || $.filter( selector, [ this ] ).length ) {
     					$( "*", this ).add( [ this ] ).each(function() {
     						$( this ).triggerHandler( "remove" );
     					});
+    				}
+    			}
     			return _remove.call( $(this), selector, keepData );
     		});
     	};
+    }
     		// http://bugs.jquery.com/ticket/8235
     		} catch( e ) {}
+    	}
     	_cleanData( elems );
     };
     $.widget = function( name, base, prototype ) {
     	var namespace = name.split( "." )[ 0 ],
     		fullName;
     	var fullName, existingConstructor, constructor, basePrototype,
     		// proxiedPrototype allows the provided prototype to remain unmodified
     		// so that it can be used as a mixin for multiple widgets (#8876)
     		proxiedPrototype = {},
     		namespace = name.split( "." )[ 0 ];
     	name = name.split( "." )[ 1 ];
     	fullName = namespace + "-" + name;
-...
+    	}
     	// create selector for plugin
     	$.expr[ ":" ][ fullName ] = function( elem ) {
     		return !!$.data( elem, name );
     	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
     		return !!$.data( elem, fullName );
     	};
     	$[ namespace ] = $[ namespace ] || {};
     	$[ namespace ][ name ] = function( options, element ) {
     	existingConstructor = $[ namespace ][ name ];
     	constructor = $[ namespace ][ name ] = function( options, element ) {
     		// allow instantiation without "new" keyword
     		if ( !this._createWidget ) {
     			return new constructor( options, element );
+    		}
     		// allow instantiation without initializing for simple inheritance
     		// must use "new" keyword (the code above always passes args)
     		if ( arguments.length ) {
     			this._createWidget( options, element );
+    		}
     	};
     	// extend with the existing constructor to carry over any static properties
     	$.extend( constructor, existingConstructor, {
     		version: prototype.version,
     		// copy the object used to create the prototype in case we need to
     		// redefine the widget later
     		_proto: $.extend( {}, prototype ),
     		// track widgets that inherit from this widget in case this widget is
     		// redefined after a widget inherits from it
     		_childConstructors: []
     	});
     	var basePrototype = new base();
     	basePrototype = new base();
     	// we need to make the options hash a property directly on the new instance
     	// otherwise we'll modify the options hash on the prototype that we're
     	// inheriting from
     //	$.each( basePrototype, function( key, val ) {
     //		if ( $.isPlainObject(val) ) {
     //			basePrototype[ key ] = $.extend( {}, val );
     //		}
     //	});
     	basePrototype.options = $.extend( true, {}, basePrototype.options );
     	$[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
     	basePrototype.options = $.widget.extend( {}, basePrototype.options );
     	$.each( prototype, function( prop, value ) {
     		if ( !$.isFunction( value ) ) {
     			proxiedPrototype[ prop ] = value;
     			return;
+    		}
     		proxiedPrototype[ prop ] = (function() {
     			var _super = function() {
     					return base.prototype[ prop ].apply( this, arguments );
     				},
     				_superApply = function( args ) {
     					return base.prototype[ prop ].apply( this, args );
     				};
     			return function() {
     				var __super = this._super,
     					__superApply = this._superApply,
     					returnValue;
     				this._super = _super;
     				this._superApply = _superApply;
     				returnValue = value.apply( this, arguments );
     				this._super = __super;
     				this._superApply = __superApply;
     				return returnValue;
     			};
     		})();
     	});
     	constructor.prototype = $.widget.extend( basePrototype, {
     		// TODO: remove support for widgetEventPrefix
     		// always use the name + a colon as the prefix, e.g., draggable:start
     		// don't prefix for widgets that aren't DOM-based
     		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
     	}, proxiedPrototype, {
     		constructor: constructor,
     		namespace: namespace,
     		widgetName: name,
     		widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
     		widgetBaseClass: fullName
     	}, prototype );
     		widgetFullName: fullName
     	});
     	$.widget.bridge( name, $[ namespace ][ name ] );
     	// If this widget is being redefined then we need to find all widgets that
     	// are inheriting from it and redefine all of them so that they inherit from
     	// the new version of this widget. We're essentially trying to replace one
     	// level in the prototype chain.
     	if ( existingConstructor ) {
     		$.each( existingConstructor._childConstructors, function( i, child ) {
     			var childPrototype = child.prototype;
     			// redefine the child widget using the same prototype that was
     			// originally used, but inherit from the new version of the base
     			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
     		});
     		// remove the list of existing child constructors from the old constructor
     		// so the old child constructors can be garbage collected
     		delete existingConstructor._childConstructors;
     	} else {
     		base._childConstructors.push( constructor );
+    	}
     	$.widget.bridge( name, constructor );
     };
     $.widget.extend = function( target ) {
     	var input = slice.call( arguments, 1 ),
     		inputIndex = 0,
     		inputLength = input.length,
     		key,
     		value;
     	for ( ; inputIndex < inputLength; inputIndex++ ) {
     		for ( key in input[ inputIndex ] ) {
     			value = input[ inputIndex ][ key ];
     			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
     				// Clone objects
     				if ( $.isPlainObject( value ) ) {
     					target[ key ] = $.isPlainObject( target[ key ] ) ?
     						$.widget.extend( {}, target[ key ], value ) :
     						// Don't extend strings, arrays, etc. with objects
     						$.widget.extend( {}, value );
     				// Copy everything else by reference
     				} else {
     					target[ key ] = value;
+    				}
+    			}
+    		}
+    	}
     	return target;
     };
     $.widget.bridge = function( name, object ) {
     	var fullName = object.prototype.widgetFullName || name;
     	$.fn[ name ] = function( options ) {
     		var isMethodCall = typeof options === "string",
     			args = Array.prototype.slice.call( arguments, 1 ),
     			args = slice.call( arguments, 1 ),
     			returnValue = this;
     		// allow multiple hashes to be passed on init
     		options = !isMethodCall && args.length ?
     			$.extend.apply( null, [ true, options ].concat(args) ) :
     			$.widget.extend.apply( null, [ options ].concat(args) ) :
     			options;
     		// prevent calls to internal methods
     		if ( isMethodCall && options.charAt( 0 ) === "_" ) {
     			return returnValue;
+    		}
     		if ( isMethodCall ) {
     			this.each(function() {
     				var instance = $.data( this, name ),
     					methodValue = instance && $.isFunction( instance[options] ) ?
     						instance[ options ].apply( instance, args ) :
     						instance;
     				// TODO: add this back in 1.9 and use $.error() (see #5972)
     //				if ( !instance ) {
     //					throw "cannot call methods on " + name + " prior to initialization; " +
     //						"attempted to call method '" + options + "'";
     //				}
     //				if ( !$.isFunction( instance[options] ) ) {
     //					throw "no such method '" + options + "' for " + name + " widget instance";
     //				}
     //				var methodValue = instance[ options ].apply( instance, args );
     				var methodValue,
     					instance = $.data( this, fullName );
     				if ( !instance ) {
     					return $.error( "cannot call methods on " + name + " prior to initialization; " +
     						"attempted to call method '" + options + "'" );
+    				}
     				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
     					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
+    				}
     				methodValue = instance[ options ].apply( instance, args );
     				if ( methodValue !== instance && methodValue !== undefined ) {
     					returnValue = methodValue;
     					returnValue = methodValue && methodValue.jquery ?
     						returnValue.pushStack( methodValue.get() ) :
     						methodValue;
     					return false;
+    				}
     			});
     		} else {
     			this.each(function() {
     				var instance = $.data( this, name );
     				var instance = $.data( this, fullName );
     				if ( instance ) {
     					instance.option( options || {} )._init();
     				} else {
     					$.data( this, name, new object( options, this ) );
     					$.data( this, fullName, new object( options, this ) );
+    				}
     			});
+    		}
-...
     	};
     };
     $.Widget = function( options, element ) {
     	// allow instantiation without initializing for simple inheritance
     	if ( arguments.length ) {
     		this._createWidget( options, element );
+    	}
     };
     $.Widget = function( /* options, element */ ) {};
     $.Widget._childConstructors = [];
     $.Widget.prototype = {
     	widgetName: "widget",
     	widgetEventPrefix: "",
     	defaultElement: "<div>",
     	options: {
     		disabled: false
     		disabled: false,
     		// callbacks
     		create: null
     	},
     	_createWidget: function( options, element ) {
     		// $.widget.bridge stores the plugin instance, but we do it anyway
     		// so that it's stored even before the _create function runs
     		$.data( element, this.widgetName, this );
     		element = $( element || this.defaultElement || this )[ 0 ];
     		this.element = $( element );
     		this.options = $.extend( true, {},
     		this.uuid = uuid++;
     		this.eventNamespace = "." + this.widgetName + this.uuid;
     		this.options = $.widget.extend( {},
     			this.options,
     			this._getCreateOptions(),
     			options );
     		var self = this;
     		this.element.bind( "remove." + this.widgetName, function() {
     			self.destroy();
     		});
     		this.bindings = $();
     		this.hoverable = $();
     		this.focusable = $();
     		if ( element !== this ) {
     			$.data( element, this.widgetFullName, this );
     			this._on( true, this.element, {
     				remove: function( event ) {
     					if ( event.target === element ) {
     						this.destroy();
+    					}
+    				}
     			});
     			this.document = $( element.style ?
     				// element within the document
     				element.ownerDocument :
     				// element is window or document
     				element.document || element );
     			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
+    		}
     		this._create();
     		this._trigger( "create" );
     		this._trigger( "create", null, this._getCreateEventData() );
     		this._init();
     	},
     	_getCreateOptions: function() {
     		return $.metadata && $.metadata.get( this.element[0] )[ this.widgetName ];
     	},
     	_create: function() {},
     	_init: function() {},
     	_getCreateOptions: $.noop,
     	_getCreateEventData: $.noop,
     	_create: $.noop,
     	_init: $.noop,
     	destroy: function() {
     		this._destroy();
     		// we can probably remove the unbind calls in 2.0
     		// all event bindings should go through this._on()
     		this.element
     			.unbind( "." + this.widgetName )
     			.removeData( this.widgetName );
     			.unbind( this.eventNamespace )
     			// 1.9 BC for #7810
     			// TODO remove dual storage
     			.removeData( this.widgetName )
     			.removeData( this.widgetFullName )
     			// support: jquery <1.6.3
     			// http://bugs.jquery.com/ticket/9413
     			.removeData( $.camelCase( this.widgetFullName ) );
     		this.widget()
     			.unbind( "." + this.widgetName )
     			.unbind( this.eventNamespace )
     			.removeAttr( "aria-disabled" )
     			.removeClass(
     				this.widgetBaseClass + "-disabled " +
     				this.widgetFullName + "-disabled " +
     				"ui-state-disabled" );
     		// clean up events and states
     		this.bindings.unbind( this.eventNamespace );
     		this.hoverable.removeClass( "ui-state-hover" );
     		this.focusable.removeClass( "ui-state-focus" );
     	},
     	_destroy: $.noop,
     	widget: function() {
     		return this.element;
     	},
     	option: function( key, value ) {
     		var options = key;
     		var options = key,
     			parts,
     			curOption,
     			i;
     		if ( arguments.length === 0 ) {
     			// don't return a reference to the internal hash
     			return $.extend( {}, this.options );
     			return $.widget.extend( {}, this.options );
+    		}
     		if  (typeof key === "string" ) {
     			if ( value === undefined ) {
     				return this.options[ key ];
+    			}
     		if ( typeof key === "string" ) {
     			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
     			options = {};
     			options[ key ] = value;
     			parts = key.split( "." );
     			key = parts.shift();
     			if ( parts.length ) {
     				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
     				for ( i = 0; i < parts.length - 1; i++ ) {
     					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
     					curOption = curOption[ parts[ i ] ];
+    				}
     				key = parts.pop();
     				if ( value === undefined ) {
     					return curOption[ key ] === undefined ? null : curOption[ key ];
+    				}
     				curOption[ key ] = value;
     			} else {
     				if ( value === undefined ) {
     					return this.options[ key ] === undefined ? null : this.options[ key ];
+    				}
     				options[ key ] = value;
+    			}
+    		}
     		this._setOptions( options );
-...
     		return this;
     	},
     	_setOptions: function( options ) {
     		var self = this;
     		$.each( options, function( key, value ) {
     			self._setOption( key, value );
     		});
     		var key;
     		for ( key in options ) {
     			this._setOption( key, options[ key ] );
+    		}
     		return this;
     	},
-...
     		if ( key === "disabled" ) {
     			this.widget()
     				[ value ? "addClass" : "removeClass"](
     					this.widgetBaseClass + "-disabled" + " " +
     					"ui-state-disabled" )
     				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
     				.attr( "aria-disabled", value );
     			this.hoverable.removeClass( "ui-state-hover" );
     			this.focusable.removeClass( "ui-state-focus" );
+    		}
     		return this;
-...
     		return this._setOption( "disabled", true );
     	},
     	_on: function( suppressDisabledCheck, element, handlers ) {
     		var delegateElement,
     			instance = this;
     		// no suppressDisabledCheck flag, shuffle arguments
     		if ( typeof suppressDisabledCheck !== "boolean" ) {
     			handlers = element;
     			element = suppressDisabledCheck;
     			suppressDisabledCheck = false;
+    		}
     		// no element argument, shuffle and use this.element
     		if ( !handlers ) {
     			handlers = element;
     			element = this.element;
     			delegateElement = this.widget();
     		} else {
     			// accept selectors, DOM elements
     			element = delegateElement = $( element );
     			this.bindings = this.bindings.add( element );
+    		}
     		$.each( handlers, function( event, handler ) {
     			function handlerProxy() {
     				// allow widgets to customize the disabled handling
     				// - disabled as an array instead of boolean
     				// - disabled class as method for disabling individual parts
     				if ( !suppressDisabledCheck &&
     						( instance.options.disabled === true ||
     							$( this ).hasClass( "ui-state-disabled" ) ) ) {
     					return;
+    				}
     				return ( typeof handler === "string" ? instance[ handler ] : handler )
     					.apply( instance, arguments );
+    			}
     			// copy the guid so direct unbinding works
     			if ( typeof handler !== "string" ) {
     				handlerProxy.guid = handler.guid =
     					handler.guid || handlerProxy.guid || $.guid++;
+    			}
     			var match = event.match( /^(\w+)\s*(.*)$/ ),
     				eventName = match[1] + instance.eventNamespace,
     				selector = match[2];
     			if ( selector ) {
     				delegateElement.delegate( selector, eventName, handlerProxy );
     			} else {
     				element.bind( eventName, handlerProxy );
+    			}
     		});
     	},
     	_off: function( element, eventName ) {
     		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
     		element.unbind( eventName ).undelegate( eventName );
     	},
     	_delay: function( handler, delay ) {
     		function handlerProxy() {
     			return ( typeof handler === "string" ? instance[ handler ] : handler )
     				.apply( instance, arguments );
+    		}
     		var instance = this;
     		return setTimeout( handlerProxy, delay || 0 );
     	},
     	_hoverable: function( element ) {
     		this.hoverable = this.hoverable.add( element );
     		this._on( element, {
     			mouseenter: function( event ) {
     				$( event.currentTarget ).addClass( "ui-state-hover" );
     			},
     			mouseleave: function( event ) {
     				$( event.currentTarget ).removeClass( "ui-state-hover" );
+    			}
     		});
     	},
     	_focusable: function( element ) {
     		this.focusable = this.focusable.add( element );
     		this._on( element, {
     			focusin: function( event ) {
     				$( event.currentTarget ).addClass( "ui-state-focus" );
     			},
     			focusout: function( event ) {
     				$( event.currentTarget ).removeClass( "ui-state-focus" );
+    			}
     		});
     	},
     	_trigger: function( type, event, data ) {
     		var callback = this.options[ type ];
     		var prop, orig,
     			callback = this.options[ type ];
     		data = data || {};
     		event = $.Event( event );
     		event.type = ( type === this.widgetEventPrefix ?
     			type :
     			this.widgetEventPrefix + type ).toLowerCase();
     		data = data || {};
     		// the original event may come from any element
     		// so we need to reset the target on the new event
     		event.target = this.element[ 0 ];
     		// copy original event properties over to the new event
     		// this would happen if we could call $.event.fix instead of $.Event
     		// but we don't have a way to force an event to be fixed multiple times
     		if ( event.originalEvent ) {
     			for ( var i = $.event.props.length, prop; i; ) {
     				prop = $.event.props[ --i ];
     				event[ prop ] = event.originalEvent[ prop ];
     		orig = event.originalEvent;
     		if ( orig ) {
     			for ( prop in orig ) {
     				if ( !( prop in event ) ) {
     					event[ prop ] = orig[ prop ];
+    				}
+    			}
+    		}
     		this.element.trigger( event, data );
     		return !( $.isFunction(callback) &&
     			callback.call( this.element[0], event, data ) === false ||
     		return !( $.isFunction( callback ) &&
     			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
     			event.isDefaultPrevented() );
+    	}
     };
     $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
     	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
     		if ( typeof options === "string" ) {
     			options = { effect: options };
+    		}
     		var hasOptions,
     			effectName = !options ?
     				method :
     				options === true || typeof options === "number" ?
     					defaultEffect :
     					options.effect || defaultEffect;
     		options = options || {};
     		if ( typeof options === "number" ) {
     			options = { duration: options };
+    		}
     		hasOptions = !$.isEmptyObject( options );
     		options.complete = callback;
     		if ( options.delay ) {
     			element.delay( options.delay );
+    		}
     		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
     			element[ method ]( options );
     		} else if ( effectName !== method && element[ effectName ] ) {
     			element[ effectName ]( options.duration, options.easing, callback );
     		} else {
     			element.queue(function( next ) {
     				$( this )[ method ]();
     				if ( callback ) {
     					callback.call( element[ 0 ] );
+    				}
     				next();
     			});
+    		}
     	};
     });
     })( jQuery );
     /*!
      * jQuery UI Mouse 1.8.11
+     *
      * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
      * Dual licensed under the MIT or GPL Version 2 licenses.
      * http://jquery.org/license
+     *
      * http://docs.jquery.com/UI/Mouse
+     *
      * Depends:
      *	jquery.ui.widget.js
      */
     (function( $, undefined ) {
     var mouseHandled = false;
     $( document ).mouseup( function() {
     	mouseHandled = false;
     });
     $.widget("ui.mouse", {
     	version: "1.10.2",
     	options: {
     		cancel: ':input,option',
     		cancel: "input,textarea,button,select,option",
     		distance: 1,
     		delay: 0
     	},
     	_mouseInit: function() {
     		var self = this;
     		var that = this;
     		this.element
     			.bind('mousedown.'+this.widgetName, function(event) {
     				return self._mouseDown(event);
     			.bind("mousedown."+this.widgetName, function(event) {
     				return that._mouseDown(event);
     			})
     			.bind('click.'+this.widgetName, function(event) {
     				if (true === $.data(event.target, self.widgetName + '.preventClickEvent')) {
     				    $.removeData(event.target, self.widgetName + '.preventClickEvent');
     			.bind("click."+this.widgetName, function(event) {
     				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
     					$.removeData(event.target, that.widgetName + ".preventClickEvent");
     					event.stopImmediatePropagation();
     					return false;
+    				}
-...
     	// TODO: make sure destroying one instance of mouse doesn't mess with
     	// other instances of mouse
     	_mouseDestroy: function() {
     		this.element.unbind('.'+this.widgetName);
     		this.element.unbind("."+this.widgetName);
     		if ( this._mouseMoveDelegate ) {
     			$(document)
     				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
     				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+    		}
     	},
     	_mouseDown: function(event) {
     		// don't let more than one widget handle mouseStart
     		// TODO: figure out why we have to use originalEvent
     		event.originalEvent = event.originalEvent || {};
     		if (event.originalEvent.mouseHandled) { return; }
     		if( mouseHandled ) { return; }
     		// we may have missed mouseup (out of window)
     		(this._mouseStarted && this._mouseUp(event));
     		this._mouseDownEvent = event;
     		var self = this,
     			btnIsLeft = (event.which == 1),
     			elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
     		var that = this,
     			btnIsLeft = (event.which === 1),
     			// event.target.nodeName works around a bug in IE 8 with
     			// disabled inputs (#7620)
     			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
     		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
     			return true;
+    		}
-...
     		this.mouseDelayMet = !this.options.delay;
     		if (!this.mouseDelayMet) {
     			this._mouseDelayTimer = setTimeout(function() {
     				self.mouseDelayMet = true;
     				that.mouseDelayMet = true;
     			}, this.options.delay);
+    		}
-...
+    		}
     		// Click event may never have fired (Gecko & Opera)
     		if (true === $.data(event.target, this.widgetName + '.preventClickEvent')) {
     			$.removeData(event.target, this.widgetName + '.preventClickEvent');
     		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
     			$.removeData(event.target, this.widgetName + ".preventClickEvent");
+    		}
     		// these delegates are required to keep context
     		this._mouseMoveDelegate = function(event) {
     			return self._mouseMove(event);
     			return that._mouseMove(event);
     		};
     		this._mouseUpDelegate = function(event) {
     			return self._mouseUp(event);
     			return that._mouseUp(event);
     		};
     		$(document)
     			.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
     			.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
     			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
     			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
     		event.preventDefault();
     		event.originalEvent.mouseHandled = true;
     		mouseHandled = true;
     		return true;
     	},
     	_mouseMove: function(event) {
     		// IE mouseup check - mouseup happened when mouse was out of window
     		if ($.browser.msie && !(document.documentMode >= 9) && !event.button) {
     		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
     			return this._mouseUp(event);
+    		}
-...
     	_mouseUp: function(event) {
     		$(document)
     			.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
     			.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
     			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
     			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
     		if (this._mouseStarted) {
     			this._mouseStarted = false;
     			if (event.target == this._mouseDownEvent.target) {
     			    $.data(event.target, this.widgetName + '.preventClickEvent', true);
     			if (event.target === this._mouseDownEvent.target) {
     				$.data(event.target, this.widgetName + ".preventClickEvent", true);
+    			}
     			this._mouseStop(event);
-...
     		);
     	},
     	_mouseDelayMet: function(event) {
     	_mouseDelayMet: function(/* event */) {
     		return this.mouseDelayMet;
     	},
     	// These are placeholder methods, to be overriden by extending plugin
     	_mouseStart: function(event) {},
     	_mouseDrag: function(event) {},
     	_mouseStop: function(event) {},
     	_mouseCapture: function(event) { return true; }
     	_mouseStart: function(/* event */) {},
     	_mouseDrag: function(/* event */) {},
     	_mouseStop: function(/* event */) {},
     	_mouseCapture: function(/* event */) { return true; }
     });
     })(jQuery);
     /*
      * jQuery UI Draggable 1.8.11
+     *
      * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
      * Dual licensed under the MIT or GPL Version 2 licenses.
      * http://jquery.org/license
+     *
      * http://docs.jquery.com/UI/Draggables
+     *
      * Depends:
      *	jquery.ui.core.js
      *	jquery.ui.mouse.js
      *	jquery.ui.widget.js
      */
     (function( $, undefined ) {
     $.widget("ui.draggable", $.ui.mouse, {
     	version: "1.10.2",
     	widgetEventPrefix: "drag",
     	options: {
     		addClasses: true,
-...
     		snapMode: "both",
     		snapTolerance: 20,
     		stack: false,
     		zIndex: false
     		zIndex: false,
     		// callbacks
     		drag: null,
     		start: null,
     		stop: null
     	},
     	_create: function() {
     		if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
     			this.element[0].style.position = 'relative';
     		(this.options.addClasses && this.element.addClass("ui-draggable"));
     		(this.options.disabled && this.element.addClass("ui-draggable-disabled"));
     		if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
     			this.element[0].style.position = "relative";
+    		}
     		if (this.options.addClasses){
     			this.element.addClass("ui-draggable");
+    		}
     		if (this.options.disabled){
     			this.element.addClass("ui-draggable-disabled");
+    		}
     		this._mouseInit();
     	},
     	destroy: function() {
     		if(!this.element.data('draggable')) return;
     		this.element
     			.removeData("draggable")
     			.unbind(".draggable")
     			.removeClass("ui-draggable"
     				+ " ui-draggable-dragging"
     				+ " ui-draggable-disabled");
     	_destroy: function() {
     		this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
     		this._mouseDestroy();
     		return this;
     	},
     	_mouseCapture: function(event) {
-...
     		var o = this.options;
     		// among others, prevent a drag on a resizable-handle
     		if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
     		if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
     			return false;
+    		}
     		//Quit if we're not on a valid handle
     		this.handle = this._getHandle(event);
     		if (!this.handle)
     		if (!this.handle) {
     			return false;
+    		}
     		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
     			$("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
     			.css({
     				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
     				position: "absolute", opacity: "0.001", zIndex: 1000
     			})
     			.css($(this).offset())
     			.appendTo("body");
     		});
     		return true;
-...
     		//Create and append the visible helper
     		this.helper = this._createHelper(event);
     		//Cache the helper size
     		this.helper.addClass("ui-draggable-dragging");
     		//Cache the helper size
     		this._cacheHelperProportions();
     		//If ddmanager is used for droppables, set the global draggable
     		if($.ui.ddmanager)
     		if($.ui.ddmanager) {
     			$.ui.ddmanager.current = this;
+    		}
     		/*
     		 * - Position generation -
-...
     		this.originalPageX = event.pageX;
     		this.originalPageY = event.pageY;
     		//Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
     		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
     		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
     		//Set a containment if given in the options
     		if(o.containment)
     		if(o.containment) {
     			this._setContainment();
+    		}
     		//Trigger event + callbacks
     		if(this._trigger("start", event) === false) {
-...
     		this._cacheHelperProportions();
     		//Prepare the droppable offsets
     		if ($.ui.ddmanager && !o.dropBehaviour)
     		if ($.ui.ddmanager && !o.dropBehaviour) {
     			$.ui.ddmanager.prepareOffsets(this, event);
+    		}
     		this.helper.addClass("ui-draggable-dragging");
     		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
     		//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
     		if ( $.ui.ddmanager ) {
     			$.ui.ddmanager.dragStart(this, event);
+    		}
     		return true;
     	},
-...
     		//Call plugins and callbacks and use the resulting position if something is returned
     		if (!noPropagation) {
     			var ui = this._uiHash();
     			if(this._trigger('drag', event, ui) === false) {
     			if(this._trigger("drag", event, ui) === false) {
     				this._mouseUp({});
     				return false;
+    			}
     			this.position = ui.position;
+    		}
     		if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
     		if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
     		if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
     		if(!this.options.axis || this.options.axis !== "y") {
     			this.helper[0].style.left = this.position.left+"px";
+    		}
     		if(!this.options.axis || this.options.axis !== "x") {
     			this.helper[0].style.top = this.position.top+"px";
+    		}
     		if($.ui.ddmanager) {
     			$.ui.ddmanager.drag(this, event);
+    		}
     		return false;
     	},
-...
     	_mouseStop: function(event) {
     		//If we are using droppables, inform the manager about the drop
     		var dropped = false;
     		if ($.ui.ddmanager && !this.options.dropBehaviour)
     		var element,
     			that = this,
     			elementInDom = false,
     			dropped = false;
     		if ($.ui.ddmanager && !this.options.dropBehaviour) {
     			dropped = $.ui.ddmanager.drop(this, event);
+    		}
     		//if a drop comes from outside (a sortable)
     		if(this.dropped) {
     			dropped = this.dropped;
     			this.dropped = false;
+    		}
     		//if the original element is removed, don't bother to continue if helper is set to "original"
     		if((!this.element[0] || !this.element[0].parentNode) && this.options.helper == "original")
     		//if the original element is no longer in the DOM don't bother to continue (see #8269)
     		element = this.element[0];
     		while ( element && (element = element.parentNode) ) {
     			if (element === document ) {
     				elementInDom = true;
+    			}
+    		}
     		if ( !elementInDom && this.options.helper === "original" ) {
     			return false;
+    		}
     		if((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
     			var self = this;
     		if((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
     			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
     				if(self._trigger("stop", event) !== false) {
     					self._clear();
     				if(that._trigger("stop", event) !== false) {
     					that._clear();
+    				}
     			});
     		} else {
-...
     		return false;
     	},
     	_mouseUp: function(event) {
     		//Remove frame helpers
     		$("div.ui-draggable-iframeFix").each(function() {
     			this.parentNode.removeChild(this);
     		});
     		//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
     		if( $.ui.ddmanager ) {
     			$.ui.ddmanager.dragStop(this, event);
+    		}

... Ce différentiel a été tronqué car il excède la taille maximale pouvant être affichée.

Formats disponibles : Unified diff