https://du.ac.bd/fontView/assets/js/jquery-ui.js

120
121// selectors
122    function focusable( element, isTabIndexNotNaN ) {
123        var map, mapName, img,
124            nodeName = element.nodeName.toLowerCase();
125        if ( "area" === nodeName ) {
126            map = element.parentNode;
127            mapName = map.name;
128            if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
129                return false;
130            }
131            img = $( "img[usemap=#" + mapName + "]" )[0];
132            return !!img && visible( img );
133        }
134        return ( /input|select|textarea|button|object/.test( nodeName ) ?
135            !element.disabled :
136            "a" === nodeName ?
137                element.href || isTabIndexNotNaN :
138                isTabIndexNotNaN) &&
139            // the element and all of its ancestors must be visible
140            visible( element );
141    }
142
143    function visible( element ) {
144        return $.expr.filters.visible( element ) &&
145            !$( element ).parents().addBack().filter(function() {
146                return $.css( this, "visibility" ) === "hidden";
147            }).length;
148    }
149
150    $.extend( $.expr[ ":" ], {
151        data: $.expr.createPseudo ?
152            $.expr.createPseudo(function( dataName ) {
153                return function( elem ) {
154                    return !!$.data( elem, dataName );
155                };
156            }) :
157            // support: jQuery <1.8
158            function( elem, i, match ) {
159                return !!$.data( elem, match[ 3 ] );
160            },
161
162        focusable: function( element ) {
163            return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
164        },
165
166        tabbable: function( element ) {
167            var tabIndex = $.attr( element, "tabindex" ),
168                isTabIndexNaN = isNaN( tabIndex );
169            return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
170        }
171    });
172
173// support: jQuery <1.8
174    if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
175        $.each( [ "Width", "Height" ], function( i, name ) {
176            var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
177                type = name.toLowerCase(),
178                orig = {
179                    innerWidth: $.fn.innerWidth,
180                    innerHeight: $.fn.innerHeight,
181                    outerWidth: $.fn.outerWidth,
182                    outerHeight: $.fn.outerHeight
183                };
184
185            function reduce( elem, size, border, margin ) {
186                $.each( side, function() {
187                    size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
188                    if ( border ) {
189                        size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
190                    }
191                    if ( margin ) {
192                        size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
193                    }
194                });
195                return size;
196            }
197
198            $.fn[ "inner" + name ] = function( size ) {
199                if ( size === undefined ) {
200                    return orig[ "inner" + name ].call( this );
201                }
202
203                return this.each(function() {
204                    $( this ).css( type, reduce( this, size ) + "px" );
205                });
206            };
207
208            $.fn[ "outer" + name] = function( size, margin ) {
209                if ( typeof size !== "number" ) {
210                    return orig[ "outer" + name ].call( this, size );
211                }
212
213                return this.each(function() {
214                    $( this).css( type, reduce( this, size, true, margin ) + "px" );
215                });
216            };
217        });
218    }
219
220// support: jQuery <1.8
221    if ( !$.fn.addBack ) {
222        $.fn.addBack = function( selector ) {
223            return this.add( selector == null ?
224                this.prevObject : this.prevObject.filter( selector )
225            );
226        };
227    }
228
229// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
230    if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
231        $.fn.removeData = (function( removeData ) {
232            return function( key ) {
233                if ( arguments.length ) {
234                    return removeData.call( this, $.camelCase( key ) );
235                } else {
236                    return removeData.call( this );
237                }
238            };
239        })( $.fn.removeData );
240    }
241
242
243
244
245
246// deprecated
247    $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
248
249    $.support.selectstart = "onselectstart" in document.createElement( "div" );
250    $.fn.extend({
251        disableSelection: function() {
252            return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
253                ".ui-disableSelection", function( event ) {
254                event.preventDefault();
255            });
256        },
257
258        enableSelection: function() {
259            return this.unbind( ".ui-disableSelection" );
260        }
261    });
262
263    $.extend( $.ui, {
264        // $.ui.plugin is deprecated.  Use the proxy pattern instead.
265        plugin: {
266            add: function( module, option, set ) {
267                var i,
268                    proto = $.ui[ module ].prototype;
269                for ( i in set ) {
270                    proto.plugins[ i ] = proto.plugins[ i ] || [];
271                    proto.plugins[ i ].push( [ option, set[ i ] ] );
272                }
273            },
274            call: function( instance, name, args ) {
275                var i,
276                    set = instance.plugins[ name ];
277                if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
278                    return;
279                }
280
281                for ( i = 0; i < set.length; i++ ) {
282                    if ( instance.options[ set[ i ][ 0 ] ] ) {
283                        set[ i ][ 1 ].apply( instance.element, args );
284                    }
285                }
286            }
287        },
288
289        // only used by resizable
290        hasScroll: function( el, a ) {
291
292            //If overflow is hidden, the element might have extra content, but the user wants to hide it
293            if ( $( el ).css( "overflow" ) === "hidden") {
294                return false;
295            }
296
297            var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
298                has = false;
299
300            if ( el[ scroll ] > 0 ) {
301                return true;
302            }
303
304            // TODO: determine which cases actually cause this to happen
305            // if the element doesn't have the scroll set, see if it's possible to
306            // set the scroll
307            el[ scroll ] = 1;
308            has = ( el[ scroll ] > 0 );
309            el[ scroll ] = 0;
310            return has;
311        }
312    });
313
314})( jQuery );
315
316(function( $, undefined ) {
317
318    var 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
828(function( $, undefined ) {
829
830    var mouseHandled = false;
831    $( document ).mouseup( function() {
832        mouseHandled = false;
833    });
834
835    $.widget("ui.mouse", {
836        version: "1.10.2",
837        options: {
838            cancel: "input,textarea,button,select,option",
839            distance: 1,
840            delay: 0
841        },
842        _mouseInit: function() {
843            var that = this;
844
845            this.element
846                .bind("mousedown."+this.widgetName, function(event) {
847                    return that._mouseDown(event);
848                })
849                .bind("click."+this.widgetName, function(event) {
850                    if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
851                        $.removeData(event.target, that.widgetName + ".preventClickEvent");
852                        event.stopImmediatePropagation();
853                        return false;
854                    }
855                });
856
857            this.started = false;
858        },
859
860        // TODO: make sure destroying one instance of mouse doesn't mess with
861        // other instances of mouse
862        _mouseDestroy: function() {
863            this.element.unbind("."+this.widgetName);
864            if ( this._mouseMoveDelegate ) {
865                $(document)
866                    .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
867                    .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
868            }
869        },
870
871        _mouseDown: function(event) {
872            // don't let more than one widget handle mouseStart
873            if( mouseHandled ) { return; }
874
875            // we may have missed mouseup (out of window)
876            (this._mouseStarted && this._mouseUp(event));
877
878            this._mouseDownEvent = event;
879
880            var that = this,
881                btnIsLeft = (event.which === 1),
882                // event.target.nodeName works around a bug in IE 8 with
883                // disabled inputs (#7620)
884                elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
885            if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
886                return true;
887            }
888
889            this.mouseDelayMet = !this.options.delay;
890            if (!this.mouseDelayMet) {
891                this._mouseDelayTimer = setTimeout(function() {
892                    that.mouseDelayMet = true;
893                }, this.options.delay);
894            }
895
896            if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
897                this._mouseStarted = (this._mouseStart(event) !== false);
898                if (!this._mouseStarted) {
899                    event.preventDefault();
900                    return true;
901                }
902            }
903
904            // Click event may never have fired (Gecko & Opera)
905            if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
906                $.removeData(event.target, this.widgetName + ".preventClickEvent");
907            }
908
909            // these delegates are required to keep context
910            this._mouseMoveDelegate = function(event) {
911                return that._mouseMove(event);
912            };
913            this._mouseUpDelegate = function(event) {
914                return that._mouseUp(event);
915            };
916            $(document)
917                .bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
918                .bind("mouseup."+this.widgetName, this._mouseUpDelegate);
919
920            event.preventDefault();
921
922            mouseHandled = true;
923            return true;
924        },
925
926        _mouseMove: function(event) {
927            // IE mouseup check - mouseup happened when mouse was out of window
928            if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
929                return this._mouseUp(event);
930            }
931
932            if (this._mouseStarted) {
933                this._mouseDrag(event);
934                return event.preventDefault();
935            }
936
937            if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
938                this._mouseStarted =
939                    (this._mouseStart(this._mouseDownEvent, event) !== false);
940                (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
941            }
942
943            return !this._mouseStarted;
944        },
945
946        _mouseUp: function(event) {
947            $(document)
948                .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
949                .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
950
951            if (this._mouseStarted) {
952                this._mouseStarted = false;
953
954                if (event.target === this._mouseDownEvent.target) {
955                    $.data(event.target, this.widgetName + ".preventClickEvent", true);
956                }
957
958                this._mouseStop(event);
959            }
960
961            return false;
962        },
963
964        _mouseDistanceMet: function(event) {
965            return (Math.max(
966                    Math.abs(this._mouseDownEvent.pageX - event.pageX),
967                    Math.abs(this._mouseDownEvent.pageY - event.pageY)
968                ) >= this.options.distance
969            );
970        },
971
972        _mouseDelayMet: function(/* event */) {
973            return this.mouseDelayMet;
974        },
975
976        // These are placeholder methods, to be overriden by extending plugin
977        _mouseStart: function(/* event */) {},
978        _mouseDrag: function(/* event */) {},
979        _mouseStop: function(/* event */) {},
980        _mouseCapture: function(/* event */) { return true; }
981    });
982
983})(jQuery);
984
985(function( $, undefined ) {
986
987    $.widget("ui.draggable", $.ui.mouse, {
988        version: "1.10.2",
989        widgetEventPrefix: "drag",
990        options: {
991            addClasses: true,
992            appendTo: "parent",
993            axis: false,
994            connectToSortable: false,
995            containment: false,
996            cursor: "auto",
997            cursorAt: false,
998            grid: false,
999            handle: false,
1000            helper: "original",
1001            iframeFix: false,
1002            opacity: false,
1003            refreshPositions: false,
1004            revert: false,
1005            revertDuration: 500,
1006            scope: "default",
1007            scroll: true,
1008            scrollSensitivity: 20,
1009            scrollSpeed: 20,
1010            snap: false,
1011            snapMode: "both",
1012            snapTolerance: 20,
1013            stack: false,
1014            zIndex: false,
1015
1016            // callbacks
1017            drag: null,
1018            start: null,
1019            stop: null
1020        },
1021        _create: function() {
1022
1023            if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
1024                this.element[0].style.position = "relative";
1025            }
1026            if (this.options.addClasses){
1027                this.element.addClass("ui-draggable");
1028            }
1029            if (this.options.disabled){
1030                this.element.addClass("ui-draggable-disabled");
1031            }
1032
1033            this._mouseInit();
1034
1035        },
1036
1037        _destroy: function() {
1038            this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1039            this._mouseDestroy();
1040        },
1041
1042        _mouseCapture: function(event) {
1043
1044            var o = this.options;
1045
1046            // among others, prevent a drag on a resizable-handle
1047            if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
1048                return false;
1049            }
1050
1051            //Quit if we're not on a valid handle
1052            this.handle = this._getHandle(event);
1053            if (!this.handle) {
1054                return false;
1055            }
1056
1057            $(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1058                $("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
1059                    .css({
1060                        width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1061                        position: "absolute", opacity: "0.001", zIndex: 1000
1062                    })
1063                    .css($(this).offset())
1064                    .appendTo("body");
1065            });
1066
1067            return true;
1068
1069        },
1070
1071        _mouseStart: function(event) {
1072
1073            var o = this.options;
1074
1075            //Create and append the visible helper
1076            this.helper = this._createHelper(event);
1077
1078            this.helper.addClass("ui-draggable-dragging");
1079
1080            //Cache the helper size
1081            this._cacheHelperProportions();
1082
1083            //If ddmanager is used for droppables, set the global draggable
1084            if($.ui.ddmanager) {
1085                $.ui.ddmanager.current = this;
1086            }
1087
1088            /*
1089		 * - Position generation -
1090		 * This block generates everything position related - it's the core of draggables.
1091		 */
1092
1093            //Cache the margins of the original element
1094            this._cacheMargins();
1095
1096            //Store the helper's css position
1097            this.cssPosition = this.helper.css("position");
1098            this.scrollParent = this.helper.scrollParent();
1099
1100            //The element's absolute position on the page minus margins
1101            this.offset = this.positionAbs = this.element.offset();
1102            this.offset = {
1103                top: this.offset.top - this.margins.top,
1104                left: this.offset.left - this.margins.left
1105            };
1106
1107            $.extend(this.offset, {
1108                click: { //Where the click happened, relative to the element
1109                    left: event.pageX - this.offset.left,
1110                    top: event.pageY - this.offset.top
1111                },
1112                parent: this._getParentOffset(),
1113                relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1114            });
1115
1116            //Generate the original position
1117            this.originalPosition = this.position = this._generatePosition(event);
1118            this.originalPageX = event.pageX;
1119            this.originalPageY = event.pageY;
1120
1121            //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1122            (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1123
1124            //Set a containment if given in the options
1125            if(o.containment) {
1126                this._setContainment();
1127            }
1128
1129            //Trigger event + callbacks
1130            if(this._trigger("start", event) === false) {
1131                this._clear();
1132                return false;
1133            }
1134
1135            //Recache the helper size
1136            this._cacheHelperProportions();
1137
1138            //Prepare the droppable offsets
1139            if ($.ui.ddmanager && !o.dropBehaviour) {
1140                $.ui.ddmanager.prepareOffsets(this, event);
1141            }
1142
1143
1144            this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1145
1146            //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1147            if ( $.ui.ddmanager ) {
1148                $.ui.ddmanager.dragStart(this, event);
1149            }
1150
1151            return true;
1152        },
1153
1154        _mouseDrag: function(event, noPropagation) {
1155
1156            //Compute the helpers position
1157            this.position = this._generatePosition(event);
1158            this.positionAbs = this._convertPositionTo("absolute");
1159
1160            //Call plugins and callbacks and use the resulting position if something is returned
1161            if (!noPropagation) {
1162                var ui = this._uiHash();
1163                if(this._trigger("drag", event, ui) === false) {
1164                    this._mouseUp({});
1165                    return false;
1166                }
1167                this.position = ui.position;
1168            }
1169
1170            if(!this.options.axis || this.options.axis !== "y") {
1171                this.helper[0].style.left = this.position.left+"px";
1172            }
1173            if(!this.options.axis || this.options.axis !== "x") {
1174                this.helper[0].style.top = this.position.top+"px";
1175            }
1176            if($.ui.ddmanager) {
1177                $.ui.ddmanager.drag(this, event);
1178            }
1179
1180            return false;
1181        },
1182
1183        _mouseStop: function(event) {
1184
1185            //If we are using droppables, inform the manager about the drop
1186            var element,
1187                that = this,
1188                elementInDom = false,
1189                dropped = false;
1190            if ($.ui.ddmanager && !this.options.dropBehaviour) {
1191                dropped = $.ui.ddmanager.drop(this, event);
1192            }
1193
1194            //if a drop comes from outside (a sortable)
1195            if(this.dropped) {
1196                dropped = this.dropped;
1197                this.dropped = false;
1198            }
1199
1200            //if the original element is no longer in the DOM don't bother to continue (see #8269)
1201            element = this.element[0];
1202            while ( element && (element = element.parentNode) ) {
1203                if (element === document ) {
1204                    elementInDom = true;
1205                }
1206            }
1207            if ( !elementInDom && this.options.helper === "original" ) {
1208                return false;
1209            }
1210
1211            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))) {
1212                $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1213                    if(that._trigger("stop", event) !== false) {
1214                        that._clear();
1215                    }
1216                });
1217            } else {
1218                if(this._trigger("stop", event) !== false) {
1219                    this._clear();
1220                }
1221            }
1222
1223            return false;
1224        },
1225
1226        _mouseUp: function(event) {
1227            //Remove frame helpers
1228            $("div.ui-draggable-iframeFix").each(function() {
1229                this.parentNode.removeChild(this);
1230            });
1231
1232            //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1233            if( $.ui.ddmanager ) {
1234                $.ui.ddmanager.dragStop(this, event);
1235            }
1236
1237            return $.ui.mouse.prototype._mouseUp.call(this, event);
1238        },
1239
1240        cancel: function() {
1241
1242            if(this.helper.is(".ui-draggable-dragging")) {
1243                this._mouseUp({});
1244            } else {
1245                this._clear();
1246            }
1247
1248            return this;
1249
1250        },
1251
1252        _getHandle: function(event) {
1253            return this.options.handle ?
1254                !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
1255                true;
1256        },
1257
1258        _createHelper: function(event) {
1259
1260            var o = this.options,
1261                helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1262
1263            if(!helper.parents("body").length) {
1264                helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1265            }
1266
1267            if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1268                helper.css("position", "absolute");
1269            }
1270
1271            return helper;
1272
1273        },
1274
1275        _adjustOffsetFromHelper: function(obj) {
1276            if (typeof obj === "string") {
1277                obj = obj.split(" ");
1278            }
1279            if ($.isArray(obj)) {
1280                obj = {left: +obj[0], top: +obj[1] || 0};
1281            }
1282            if ("left" in obj) {
1283                this.offset.click.left = obj.left + this.margins.left;
1284            }
1285            if ("right" in obj) {
1286                this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1287            }
1288            if ("top" in obj) {
1289                this.offset.click.top = obj.top + this.margins.top;
1290            }
1291            if ("bottom" in obj) {
1292                this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1293            }
1294        },
1295
1296        _getParentOffset: function() {
1297
1298            //Get the offsetParent and cache its position
1299            this.offsetParent = this.helper.offsetParent();
1300            var po = this.offsetParent.offset();
1301
1302            // This is a special case where we need to modify a offset calculated on start, since the following happened:
1303            // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1304            // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1305            //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1306            if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1307                po.left += this.scrollParent.scrollLeft();
1308                po.top += this.scrollParent.scrollTop();
1309            }
1310
1311            //This needs to be actually done for all browsers, since pageX/pageY includes this information
1312            //Ugly IE fix
1313            if((this.offsetParent[0] === document.body) ||
1314                (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1315                po = { top: 0, left: 0 };
1316            }
1317
1318            return {
1319                top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),

131910) || 0),
1320                left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1321            };
1322
1323        },
1324
1325        _getRelativeOffset: function() {
1326
1327            if(this.cssPosition === "relative") {
1328                var p = this.element.position();
1329                return {
1330                    top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1331                    left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1332                };
1333            } else {
1334                return { top: 0, left: 0 };
1335            }
1336
1337        },
1338
1339        _cacheMargins: function() {
1340            this.margins = {
1341                left: (parseInt(this.element.css("marginLeft"),10) || 0),
1342                top: (parseInt(this.element.css("marginTop"),10) || 0),
1343                right: (parseInt(this.element.css("marginRight"),10) || 0),
1344                bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1345            };
1346        },
1347
1348        _cacheHelperProportions: function() {
1349            this.helperProportions = {
1350                width: this.helper.outerWidth(),
1351                height: this.helper.outerHeight()
1352            };
1353        },
1354
1355        _setContainment: function() {
1356
1357            var over, c, ce,
1358                o = this.options;
1359
1360            if(o.containment === "parent") {
1361                o.containment = this.helper[0].parentNode;
1362            }
1363            if(o.containment === "document" || o.containment === "window") {
1364                this.containment = [
1365                    o.containment === "document" ? 0 : $(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1366                    o.containment === "document" ? 0 : $(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,
1367                    (o.containment === "document" ? 0 : $(window).scrollLeft()) + $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
1368                    (o.containment === "document" ? 0 : $(window).scrollTop()) + ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
1369                ];
1370            }
1371
1372            if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor !== Array) {
1373                c = $(o.containment);
1374                ce = c[0];
1375
1376                if(!ce) {
1377                    return;
1378                }
1379
1380                over = ($(ce).css("overflow") !== "hidden");
1381
1382                this.containment = [
1383                    (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0),
1384                    (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0),
1385                    (over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderRightWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left - this.margins.right,
1386                    (over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderBottomWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top  - this.margins.bottom
1387                ];
1388                this.relative_container = c;
1389
1390            } else if(o.containment.constructor === Array) {
1391                this.containment = o.containment;
1392            }
1393
1394        },
1395
1396        _convertPositionTo: function(d, pos) {
1397
1398            if(!pos) {
1399                pos = this.position;
1400            }
1401
1402            var mod = d === "absolute" ? 1 : -1,
1403                scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
1404
1405            return {
1406                top: (
1407                    pos.top	+																// The absolute mouse position
1408                    this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1409                    this.offset.parent.top * mod -										// The offsetParent's offset without borders (offset + border)
1410                    ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
1411                ),
1412                left: (
1413                    pos.left +																// The absolute mouse position
1414                    this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1415                    this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
1416                    ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
1417                )
1418            };
1419
1420        },
1421
1422        _generatePosition: function(event) {
1423
1424            var containment, co, top, left,
1425                o = this.options,
1426                scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
1427                scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName),
1428                pageX = event.pageX,
1429                pageY = event.pageY;
1430
1431            /*
1432		 * - Position constraining -
1433		 * Constrain the position to a mix of grid, containment.
1434		 */
1435
1436            if(this.originalPosition) { //If we are not dragging yet, we won't check for options
1437                if(this.containment) {
1438                    if (this.relative_container){
1439                        co = this.relative_container.offset();
1440                        containment = [ this.containment[0] + co.left,
1441                            this.containment[1] + co.top,
1442                            this.containment[2] + co.left,
1443                            this.containment[3] + co.top ];
1444                    }
1445                    else {
1446                        containment = this.containment;
1447                    }
1448
1449                    if(event.pageX - this.offset.click.left < containment[0]) {
1450                        pageX = containment[0] + this.offset.click.left;
1451                    }
1452                    if(event.pageY - this.offset.click.top < containment[1]) {
1453                        pageY = containment[1] + this.offset.click.top;
1454                    }
1455                    if(event.pageX - this.offset.click.left > containment[2]) {
1456                        pageX = containment[2] + this.offset.click.left;
1457                    }
1458                    if(event.pageY - this.offset.click.top > containment[3]) {
1459                        pageY = containment[3] + this.offset.click.top;
1460                    }
1461                }
1462
1463                if(o.grid) {
1464                    //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1465                    top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1466                    pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
1467
1468                    left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1469                    pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
1470                }
1471
1472            }
1473
1474            return {
1475                top: (
1476                    pageY -																	// The absolute mouse position
1477                    this.offset.click.top	-												// Click offset (relative to the element)
1478                    this.offset.relative.top -												// Only for relative positioned nodes: Relative offset from element to offset parent
1479                    this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
1480                    ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
1481                ),
1482                left: (
1483                    pageX -																	// The absolute mouse position
1484                    this.offset.click.left -												// Click offset (relative to the element)
1485                    this.offset.relative.left -												// Only for relative positioned nodes: Relative offset from element to offset parent
1486                    this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
1487                    ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
1488                )
1489            };
1490
1491        },
1492
1493        _clear: function() {
1494            this.helper.removeClass("ui-draggable-dragging");
1495            if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
1496                this.helper.remove();
1497            }
1498            this.helper = null;
1499            this.cancelHelperRemoval = false;
1500        },
1501
1502        // From now on bulk stuff - mainly helpers
1503
1504        _trigger: function(type, event, ui) {
1505            ui = ui || this._uiHash();
1506            $.ui.plugin.call(this, type, [event, ui]);
1507            //The absolute position has to be recalculated after plugins
1508            if(type === "drag") {
1509                this.positionAbs = this._convertPositionTo("absolute");
1510            }
1511            return $.Widget.prototype._trigger.call(this, type, event, ui);
1512        },
1513
1514        plugins: {},
1515
1516        _uiHash: function() {
1517            return {
1518                helper: this.helper,
1519                position: this.position,
1520                originalPosition: this.originalPosition,
1521                offset: this.positionAbs
1522            };
1523        }
1524
1525    });

1771
1772    $.ui.plugin.add("draggable", "snap", {
1773        start: function() {
1774
1775            var i = $(this).data("ui-draggable"),
1776                o = i.options;
1777
1778            i.snapElements = [];
1779
1780            $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
1781                var $t = $(this),
1782                    $o = $t.offset();
1783                if(this !== i.element[0]) {
1784                    i.snapElements.push({
1785                        item: this,
1786                        width: $t.outerWidth(), height: $t.outerHeight(),
1787                        top: $o.top, left: $o.left
1788                    });
1789                }
1790            });
1791
1792        },
1793        drag: function(event, ui) {
1794
1795            var ts, bs, ls, rs, l, r, t, b, i, first,
1796                inst = $(this).data("ui-draggable"),
1797                o = inst.options,
1798                d = o.snapTolerance,
1799                x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
1800                y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
1801
1802            for (i = inst.snapElements.length - 1; i >= 0; i--){
1803
1804                l = inst.snapElements[i].left;
1805                r = l + inst.snapElements[i].width;
1806                t = inst.snapElements[i].top;
1807                b = t + inst.snapElements[i].height;
1808
1809                //Yes, I know, this is insane ;)
1810                if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
1811                    if(inst.snapElements[i].snapping) {
1812                        (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1813                    }
1814                    inst.snapElements[i].snapping = false;
1815                    continue;
1816                }
1817
1818                if(o.snapMode !== "inner") {
1819                    ts = Math.abs(t - y2) <= d;
1820                    bs = Math.abs(b - y1) <= d;
1821                    ls = Math.abs(l - x2) <= d;
1822                    rs = Math.abs(r - x1) <= d;
1823                    if(ts) {
1824                        ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1825                    }
1826                    if(bs) {
1827                        ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1828                    }
1829                    if(ls) {
1830                        ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1831                    }
1832                    if(rs) {
1833                        ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1834                    }
1835                }
1836
1837                first = (ts || bs || ls || rs);
1838
1839                if(o.snapMode !== "outer") {
1840                    ts = Math.abs(t - y1) <= d;
1841                    bs = Math.abs(b - y2) <= d;
1842                    ls = Math.abs(l - x1) <= d;
1843                    rs = Math.abs(r - x2) <= d;
1844                    if(ts) {
1845                        ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1846                    }
1847                    if(bs) {
1848                        ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1849                    }
1850                    if(ls) {
1851                        ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1852                    }
1853                    if(rs) {
1854                        ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1855                    }
1856                }
1857
1858                if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1859                    (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1860                }
1861                inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1862
1863            }
1864
1865        }
1866    });
1867
1868    $.ui.plugin.add("draggable", "stack", {
1869        start: function() {
1870            var min,
1871                o = this.data("ui-draggable").options,
1872                group = $.makeArray($(o.stack)).sort(function(a,b) {
1873                    return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1874                });
1875
1876            if (!group.length) { return; }
1877
1878            min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1879            $(group).each(function(i) {
1880                $(this).css("zIndex", min + i);
1881            });
1882            this.css("zIndex", (min + group.length));
1883        }
1884    });
1885
1886    $.ui.plugin.add("draggable", "zIndex", {
1887        start: function(event, ui) {
1888            var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1889            if(t.css("zIndex")) {
1890                o._zIndex = t.css("zIndex");
1891            }
1892            t.css("zIndex", o.zIndex);
1893        },
1894        stop: function(event, ui) {
1895            var o = $(this).data("ui-draggable").options;
1896            if(o._zIndex) {
1897                $(ui.helper).css("zIndex", o._zIndex);
1898            }
1899        }
1900    });
1901
1902})(jQuery);
1903
1904(function( $, undefined ) {
1905
1906    function isOverAxis( x, reference, size ) {
1907        return ( x > reference ) && ( x < ( reference + size ) );
1908    }
1909
1910    $.widget("ui.droppable", {
1911        version: "1.10.2",
1912        widgetEventPrefix: "drop",
1913        options: {
1914            accept: "*",
1915            activeClass: false,
1916            addClasses: true,
1917            greedy: false,
1918            hoverClass: false,
1919            scope: "default",
1920            tolerance: "intersect",
1921
1922            // callbacks
1923            activate: null,
1924            deactivate: null,
1925            drop: null,
1926            out: null,
1927            over: null
1928        },
1929        _create: function() {
1930
1931            var o = this.options,
1932                accept = o.accept;
1933
1934            this.isover = false;
1935            this.isout = true;
1936
1937            this.accept = $.isFunction(accept) ? accept : function(d) {
1938                return d.is(accept);
1939            };
1940
1941            //Store the droppable's proportions
1942            this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1943
1944            // Add the reference and positions to the manager
1945            $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1946            $.ui.ddmanager.droppables[o.scope].push(this);
1947
1948            (o.addClasses && this.element.addClass("ui-droppable"));
1949
1950        },
1951
1952        _destroy: function() {
1953            var i = 0,
1954                drop = $.ui.ddmanager.droppables[this.options.scope];
1955
1956            for ( ; i < drop.length; i++ ) {
1957                if ( drop[i] === this ) {
1958                    drop.splice(i, 1);
1959                }
1960            }
1961
1962            this.element.removeClass("ui-droppable ui-droppable-disabled");
1963        },
1964
1965        _setOption: function(key, value) {
1966
1967            if(key === "accept") {
1968                this.accept = $.isFunction(value) ? value : function(d) {
1969                    return d.is(value);
1970                };
1971            }
1972            $.Widget.prototype._setOption.apply(this, arguments);
1973        },
1974
1975        _activate: function(event) {
1976            var draggable = $.ui.ddmanager.current;
1977            if(this.options.activeClass) {
1978                this.element.addClass(this.options.activeClass);
1979            }
1980            if(draggable){
1981                this._trigger("activate", event, this.ui(draggable));
1982            }
1983        },
1984
1985        _deactivate: function(event) {
1986            var draggable = $.ui.ddmanager.current;
1987            if(this.options.activeClass) {
1988                this.element.removeClass(this.options.activeClass);
1989            }
1990            if(draggable){
1991                this._trigger("deactivate", event, this.ui(draggable));
1992            }
1993        },
1994
1995        _over: function(event) {
1996
1997            var draggable = $.ui.ddmanager.current;
1998
1999            // Bail if draggable and droppable are same element
2000            if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2001                return;
2002            }
2003
2004            if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2005                if(this.options.hoverClass) {
2006                    this.element.addClass(this.options.hoverClass);
2007                }
2008                this._trigger("over", event, this.ui(draggable));
2009            }
2010
2011        },
2012
2013        _out: function(event) {
2014
2015            var draggable = $.ui.ddmanager.current;
2016
2017            // Bail if draggable and droppable are same element
2018            if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2019                return;
2020            }
2021
2022            if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2023                if(this.options.hoverClass) {
2024                    this.element.removeClass(this.options.hoverClass);
2025                }
2026                this._trigger("out", event, this.ui(draggable));
2027            }
2028
2029        },
2030
2031        _drop: function(event,custom) {
2032
2033            var draggable = custom || $.ui.ddmanager.current,
2034                childrenIntersection = false;
2035
2036            // Bail if draggable and droppable are same element
2037            if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2038                return false;
2039            }
2040
2041            this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
2042                var inst = $.data(this, "ui-droppable");
2043                if(
2044                    inst.options.greedy &&
2045                    !inst.options.disabled &&
2046                    inst.options.scope === draggable.options.scope &&
2047                    inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
2048                    $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2049                ) { childrenIntersection = true; return false; }
2050            });
2051            if(childrenIntersection) {
2052                return false;
2053            }
2054
2055            if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2056                if(this.options.activeClass) {
2057                    this.element.removeClass(this.options.activeClass);
2058                }
2059                if(this.options.hoverClass) {
2060                    this.element.removeClass(this.options.hoverClass);
2061                }
2062                this._trigger("drop", event, this.ui(draggable));
2063                return this.element;
2064            }
2065
2066            return false;
2067
2068        },
2069
2070        ui: function(c) {
2071            return {
2072                draggable: (c.currentItem || c.element),
2073                helper: c.helper,
2074                position: c.position,
2075                offset: c.positionAbs
2076            };
2077        }
2078
2079    });
2080
2081    $.ui.intersect = function(draggable, droppable, toleranceMode) {
2082
2083        if (!droppable.offset) {
2084            return false;
2085        }
2086
2087        var draggableLeft, draggableTop,
2088            x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2089            y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
2090            l = droppable.offset.left, r = l + droppable.proportions.width,
2091            t = droppable.offset.top, b = t + droppable.proportions.height;
2092
2093        switch (toleranceMode) {
2094            case "fit":
2095                return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
2096            case "intersect":
2097                return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
2098                    x2 - (draggable.helperProportions.width / 2) < r && // Left Half
2099                    t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
2100                    y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2101            case "pointer":
2102                draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2103                draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2104                return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
2105            case "touch":
2106                return (
2107                    (y1 >= t && y1 <= b) ||	// Top edge touching
2108                    (y2 >= t && y2 <= b) ||	// Bottom edge touching
2109                    (y1 < t && y2 > b)		// Surrounded vertically
2110                ) && (
2111                    (x1 >= l && x1 <= r) ||	// Left edge touching
2112                    (x2 >= l && x2 <= r) ||	// Right edge touching
2113                    (x1 < l && x2 > r)		// Surrounded horizontally
2114                );
2115            default:
2116                return false;
2117        }
2118
2119    };
2120
2121    /*
2122	This manager tracks offsets of draggables and droppables
2123*/
2124    $.ui.ddmanager = {
2125        current: null,
2126        droppables: { "default": [] },
2127        prepareOffsets: function(t, event) {
2128
2129            var i, j,
2130                m = $.ui.ddmanager.droppables[t.options.scope] || [],
2131                type = event ? event.type : null, // workaround for #2317
2132                list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
2133
2134            droppablesLoop: for (i = 0; i < m.length; i++) {
2135
2136                //No disabled and non-accepted
2137                if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2138                    continue;
2139                }
2140
2141                // Filter out elements in the current dragged item
2142                for (j=0; j < list.length; j++) {
2143                    if(list[j] === m[i].element[0]) {
2144                        m[i].proportions.height = 0;
2145                        continue droppablesLoop;
2146                    }
2147                }
2148
2149                m[i].visible = m[i].element.css("display") !== "none";
2150                if(!m[i].visible) {
2151                    continue;
2152                }
2153
2154                //Activate the droppable if used directly from draggables
2155                if(type === "mousedown") {
2156                    m[i]._activate.call(m[i], event);
2157                }
2158
2159                m[i].offset = m[i].element.offset();
2160                m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2161
2162            }
2163
2164        },
2165        drop: function(draggable, event) {
2166
2167            var dropped = false;
2168            // Create a copy of the droppables in case the list changes during the drop (#9116)
2169            $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
2170
2171                if(!this.options) {
2172                    return;
2173                }
2174                if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2175                    dropped = this._drop.call(this, event) || dropped;
2176                }
2177
2178                if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2179                    this.isout = true;
2180                    this.isover = false;
2181                    this._deactivate.call(this, event);
2182                }
2183
2184            });
2185            return dropped;
2186
2187        },
2188        dragStart: function( draggable, event ) {
2189            //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2190            draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2191                if( !draggable.options.refreshPositions ) {
2192                    $.ui.ddmanager.prepareOffsets( draggable, event );
2193                }
2194            });
2195        },
2196        drag: function(draggable, event) {
2197
2198            //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2199            if(draggable.options.refreshPositions) {
2200                $.ui.ddmanager.prepareOffsets(draggable, event);
2201            }
2202
2203            //Run through all droppables and check their positions based on specific tolerance options
2204            $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2205
2206                if(this.options.disabled || this.greedyChild || !this.visible) {
2207                    return;
2208                }
2209
2210                var parentInstance, scope, parent,
2211                    intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2212                    c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2213                if(!c) {
2214                    return;
2215                }
2216
2217                if (this.options.greedy) {
2218                    // find droppable parents with same scope
2219                    scope = this.options.scope;
2220                    parent = this.element.parents(":data(ui-droppable)").filter(function () {
2221                        return $.data(this, "ui-droppable").options.scope === scope;
2222                    });
2223
2224                    if (parent.length) {
2225                        parentInstance = $.data(parent[0], "ui-droppable");
2226                        parentInstance.greedyChild = (c === "isover");
2227                    }
2228                }
2229
2230                // we just moved into a greedy child
2231                if (parentInstance && c === "isover") {
2232                    parentInstance.isover = false;
2233                    parentInstance.isout = true;
2234                    parentInstance._out.call(parentInstance, event);
2235                }
2236
2237                this[c] = true;
2238                this[c === "isout" ? "isover" : "isout"] = false;
2239                this[c === "isover" ? "_over" : "_out"].call(this, event);
2240
2241                // we just moved out of a greedy child
2242                if (parentInstance && c === "isout") {
2243                    parentInstance.isout = false;
2244                    parentInstance.isover = true;
2245                    parentInstance._over.call(parentInstance, event);
2246                }
2247            });
2248
2249        },
2250        dragStop: function( draggable, event ) {
2251            draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2252            //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2253            if( !draggable.options.refreshPositions ) {
2254                $.ui.ddmanager.prepareOffsets( draggable, event );
2255            }
2256        }
2257    };
2258
2259})(jQuery);
2260
2261(function( $, undefined ) {
2262
2263    function num(v) {
2264        return parseInt(v, 10) || 0;
2265    }
2266
2267    function isNumber(value) {
2268        return !isNaN(parseInt(value, 10));
2269    }
2270
2271    $.widget("ui.resizable", $.ui.mouse, {
2272        version: "1.10.2",
2273        widgetEventPrefix: "resize",
2274        options: {
2275            alsoResize: false,
2276            animate: false,
2277            animateDuration: "slow",
2278            animateEasing: "swing",
2279            aspectRatio: false,
2280            autoHide: false,
2281            containment: false,
2282            ghost: false,
2283            grid: false,
2284            handles: "e,s,se",
2285            helper: false,
2286            maxHeight: null,
2287            maxWidth: null,
2288            minHeight: 10,
2289            minWidth: 10,
2290            // See #7960
2291            zIndex: 90,
2292
2293            // callbacks
2294            resize: null,
2295            start: null,
2296            stop: null
2297        },
2298        _create: function() {
2299
2300            var n, i, handle, axis, hname,
2301                that = this,
2302                o = this.options;
2303            this.element.addClass("ui-resizable");
2304
2305            $.extend(this, {
2306                _aspectRatio: !!(o.aspectRatio),
2307                aspectRatio: o.aspectRatio,
2308                originalElement: this.element,
2309                _proportionallyResizeElements: [],
2310                _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2311            });
2312
2313            //Wrap the element if it cannot hold child nodes
2314            if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2315
2316                //Create a wrapper element and set the wrapper to the new current internal element
2317                this.element.wrap(
2318                    $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2319                        position: this.element.css("position"),
2320                        width: this.element.outerWidth(),
2321                        height: this.element.outerHeight(),
2322                        top: this.element.css("top"),
2323                        left: this.element.css("left")
2324                    })
2325                );
2326
2327                //Overwrite the original this.element
2328                this.element = this.element.parent().data(
2329                    "ui-resizable", this.element.data("ui-resizable")
2330                );
2331
2332                this.elementIsWrapper = true;
2333
2334                //Move margins to the wrapper
2335                this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2336                this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2337
2338                //Prevent Safari textarea resize
2339                this.originalResizeStyle = this.originalElement.css("resize");
2340                this.originalElement.css("resize", "none");
2341
2342                //Push the actual element to our proportionallyResize internal array
2343                this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2344
2345                // avoid IE jump (hard set the margin)
2346                this.originalElement.css({ margin: this.originalElement.css("margin") });
2347
2348                // fix handlers offset
2349                this._proportionallyResize();
2350
2351            }
2352
2353            this.handles = o.handles || (!$(".ui-resizable-handle", this.element).length ? "e,s,se" : { n: ".ui-resizable-n", e: ".ui-resizable-e", s: ".ui-resizable-s", w: ".ui-resizable-w", se: ".ui-resizable-se", sw: ".ui-resizable-sw", ne: ".ui-resizable-ne", nw: ".ui-resizable-nw" });
2354            if(this.handles.constructor === String) {
2355
2356                if ( this.handles === "all") {
2357                    this.handles = "n,e,s,w,se,sw,ne,nw";
2358                }
2359
2360                n = this.handles.split(",");
2361                this.handles = {};
2362
2363                for(i = 0; i < n.length; i++) {
2364
2365                    handle = $.trim(n[i]);
2366                    hname = "ui-resizable-"+handle;
2367                    axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2368
2369                    // Apply zIndex to all handles - see #7960
2370                    axis.css({ zIndex: o.zIndex });
2371
2372                    //TODO : What's going on here?
2373                    if ("se" === handle) {
2374                        axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2375                    }
2376
2377                    //Insert into internal handles object and append to element
2378                    this.handles[handle] = ".ui-resizable-"+handle;
2379                    this.element.append(axis);
2380                }
2381
2382            }
2383
2384            this._renderAxis = function(target) {
2385
2386                var i, axis, padPos, padWrapper;
2387
2388                target = target || this.element;
2389
2390                for(i in this.handles) {
2391
2392                    if(this.handles[i].constructor === String) {
2393                        this.handles[i] = $(this.handles[i], this.element).show();
2394                    }
2395
2396                    //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2397                    if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2398
2399                        axis = $(this.handles[i], this.element);
2400
2401                        //Checking the correct pad and border
2402                        padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2403
2404                        //The padding type i have to apply...
2405                        padPos = [ "padding",
2406                            /ne|nw|n/.test(i) ? "Top" :
2407                                /se|sw|s/.test(i) ? "Bottom" :
2408                                    /^e$/.test(i) ? "Right" : "Left" ].join("");
2409
2410                        target.css(padPos, padWrapper);
2411
2412                        this._proportionallyResize();
2413
2414                    }
2415
2416                    //TODO: What's that good for? There's not anything to be executed left
2417                    if(!$(this.handles[i]).length) {
2418                        continue;
2419                    }
2420                }
2421            };
2422
2423            //TODO: make renderAxis a prototype function
2424            this._renderAxis(this.element);
2425
2426            this._handles = $(".ui-resizable-handle", this.element)
2427                .disableSelection();
2428
2429            //Matching axis name
2430            this._handles.mouseover(function() {
2431                if (!that.resizing) {
2432                    if (this.className) {
2433                        axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2434                    }
2435                    //Axis, default = se
2436                    that.axis = axis && axis[1] ? axis[1] : "se";
2437                }
2438            });
2439
2440            //If we want to auto hide the elements
2441            if (o.autoHide) {
2442                this._handles.hide();
2443                $(this.element)
2444                    .addClass("ui-resizable-autohide")
2445                    .mouseenter(function() {
2446                        if (o.disabled) {
2447                            return;
2448                        }
2449                        $(this).removeClass("ui-resizable-autohide");
2450                        that._handles.show();
2451                    })
2452                    .mouseleave(function(){
2453                        if (o.disabled) {
2454                            return;
2455                        }
2456                        if (!that.resizing) {
2457                            $(this).addClass("ui-resizable-autohide");
2458                            that._handles.hide();
2459                        }
2460                    });
2461            }
2462
2463            //Initialize the mouse interaction
2464            this._mouseInit();
2465
2466        },
2467
2468        _destroy: function() {
2469
2470            this._mouseDestroy();
2471
2472            var wrapper,
2473                _destroy = function(exp) {
2474                    $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2475                        .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2476                };
2477
2478            //TODO: Unwrap at same DOM position
2479            if (this.elementIsWrapper) {
2480                _destroy(this.element);
2481                wrapper = this.element;
2482                this.originalElement.css({
2483                    position: wrapper.css("position"),
2484                    width: wrapper.outerWidth(),
2485                    height: wrapper.outerHeight(),
2486                    top: wrapper.css("top"),
2487                    left: wrapper.css("left")
2488                }).insertAfter( wrapper );
2489                wrapper.remove();
2490            }
2491
2492            this.originalElement.css("resize", this.originalResizeStyle);
2493            _destroy(this.originalElement);
2494
2495            return this;
2496        },
2497
2498        _mouseCapture: function(event) {
2499            var i, handle,
2500                capture = false;
2501
2502            for (i in this.handles) {
2503                handle = $(this.handles[i])[0];
2504                if (handle === event.target || $.contains(handle, event.target)) {
2505                    capture = true;
2506                }
2507            }
2508
2509            return !this.options.disabled && capture;
2510        },
2511
2512        _mouseStart: function(event) {
2513
2514            var curleft, curtop, cursor,
2515                o = this.options,
2516                iniPos = this.element.position(),
2517                el = this.element;
2518
2519            this.resizing = true;
2520
2521            // bugfix for http://dev.jquery.com/ticket/1749
2522            if ( (/absolute/).test( el.css("position") ) ) {
2523                el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
2524            } else if (el.is(".ui-draggable")) {
2525                el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
2526            }
2527
2528            this._renderProxy();
2529
2530            curleft = num(this.helper.css("left"));
2531            curtop = num(this.helper.css("top"));
2532
2533            if (o.containment) {
2534                curleft += $(o.containment).scrollLeft() || 0;
2535                curtop += $(o.containment).scrollTop() || 0;
2536            }
2537
2538            //Store needed variables
2539            this.offset = this.helper.offset();
2540            this.position = { left: curleft, top: curtop };
2541            this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2542            this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2543            this.originalPosition = { left: curleft, top: curtop };
2544            this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2545            this.originalMousePosition = { left: event.pageX, top: event.pageY };
2546
2547            //Aspect Ratio
2548            this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2549
2550            cursor = $(".ui-resizable-" + this.axis).css("cursor");
2551            $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
2552
2553            el.addClass("ui-resizable-resizing");
2554            this._propagate("start", event);
2555            return true;
2556        },
2557
2558        _mouseDrag: function(event) {
2559
2560            //Increase performance, avoid regex
2561            var data,
2562                el = this.helper, props = {},
2563                smp = this.originalMousePosition,
2564                a = this.axis,
2565                prevTop = this.position.top,
2566                prevLeft = this.position.left,
2567                prevWidth = this.size.width,
2568                prevHeight = this.size.height,
2569                dx = (event.pageX-smp.left)||0,
2570                dy = (event.pageY-smp.top)||0,
2571                trigger = this._change[a];
2572
2573            if (!trigger) {
2574                return false;
2575            }
2576
2577            // Calculate the attrs that will be change
2578            data = trigger.apply(this, [event, dx, dy]);
2579
2580            // Put this in the mouseDrag handler since the user can start pressing shift while resizing
2581            this._updateVirtualBoundaries(event.shiftKey);
2582            if (this._aspectRatio || event.shiftKey) {
2583                data = this._updateRatio(data, event);
2584            }
2585
2586            data = this._respectSize(data, event);
2587
2588            this._updateCache(data);
2589
2590            // plugins callbacks need to be called first
2591            this._propagate("resize", event);
2592
2593            if (this.position.top !== prevTop) {
2594                props.top = this.position.top + "px";
2595            }
2596            if (this.position.left !== prevLeft) {
2597                props.left = this.position.left + "px";
2598            }
2599            if (this.size.width !== prevWidth) {
2600                props.width = this.size.width + "px";
2601            }
2602            if (this.size.height !== prevHeight) {
2603                props.height = this.size.height + "px";
2604            }
2605            el.css(props);
2606
2607            if (!this._helper && this._proportionallyResizeElements.length) {
2608                this._proportionallyResize();
2609            }
2610
2611            // Call the user callback if the element was resized
2612            if ( ! $.isEmptyObject(props) ) {
2613                this._trigger("resize", event, this.ui());
2614            }
2615
2616            return false;
2617        },
2618
2619        _mouseStop: function(event) {
2620
2621            this.resizing = false;
2622            var pr, ista, soffseth, soffsetw, s, left, top,
2623                o = this.options, that = this;
2624
2625            if(this._helper) {
2626
2627                pr = this._proportionallyResizeElements;
2628                ista = pr.length && (/textarea/i).test(pr[0].nodeName);
2629                soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2630                soffsetw = ista ? 0 : that.sizeDiff.width;
2631
2632                s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
2633                left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2634                top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2635
2636                if (!o.animate) {
2637                    this.element.css($.extend(s, { top: top, left: left }));
2638                }
2639
2640                that.helper.height(that.size.height);
2641                that.helper.width(that.size.width);
2642
2643                if (this._helper && !o.animate) {
2644                    this._proportionallyResize();
2645                }
2646            }
2647
2648            $("body").css("cursor", "auto");
2649
2650            this.element.removeClass("ui-resizable-resizing");
2651
2652            this._propagate("stop", event);
2653
2654            if (this._helper) {
2655                this.helper.remove();
2656            }
2657
2658            return false;
2659
2660        },
2661
2662        _updateVirtualBoundaries: function(forceAspectRatio) {
2663            var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
2664                o = this.options;
2665
2666            b = {
2667                minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
2668                maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
2669                minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
2670                maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
2671            };
2672
2673            if(this._aspectRatio || forceAspectRatio) {
2674                // We want to create an enclosing box whose aspect ration is the requested one
2675                // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2676                pMinWidth = b.minHeight * this.aspectRatio;
2677                pMinHeight = b.minWidth / this.aspectRatio;
2678                pMaxWidth = b.maxHeight * this.aspectRatio;
2679                pMaxHeight = b.maxWidth / this.aspectRatio;
2680
2681                if(pMinWidth > b.minWidth) {
2682                    b.minWidth = pMinWidth;
2683                }
2684                if(pMinHeight > b.minHeight) {
2685                    b.minHeight = pMinHeight;
2686                }
2687                if(pMaxWidth < b.maxWidth) {
2688                    b.maxWidth = pMaxWidth;
2689                }
2690                if(pMaxHeight < b.maxHeight) {
2691                    b.maxHeight = pMaxHeight;
2692                }
2693            }
2694            this._vBoundaries = b;
2695        },
2696
2697        _updateCache: function(data) {
2698            this.offset = this.helper.offset();
2699            if (isNumber(data.left)) {
2700                this.position.left = data.left;
2701            }
2702            if (isNumber(data.top)) {
2703                this.position.top = data.top;
2704            }
2705            if (isNumber(data.height)) {
2706                this.size.height = data.height;
2707            }
2708            if (isNumber(data.width)) {
2709                this.size.width = data.width;
2710            }
2711        },
2712
2713        _updateRatio: function( data ) {
2714
2715            var cpos = this.position,
2716                csize = this.size,
2717                a = this.axis;
2718
2719            if (isNumber(data.height)) {
2720                data.width = (data.height * this.aspectRatio);
2721            } else if (isNumber(data.width)) {
2722                data.height = (data.width / this.aspectRatio);
2723            }
2724
2725            if (a === "sw") {
2726                data.left = cpos.left + (csize.width - data.width);
2727                data.top = null;
2728            }
2729            if (a === "nw") {
2730                data.top = cpos.top + (csize.height - data.height);
2731                data.left = cpos.left + (csize.width - data.width);
2732            }
2733
2734            return data;
2735        },
2736
2737        _respectSize: function( data ) {
2738
2739            var o = this._vBoundaries,
2740                a = this.axis,
2741                ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2742                isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2743                dw = this.originalPosition.left + this.originalSize.width,
2744                dh = this.position.top + this.size.height,
2745                cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2746            if (isminw) {
2747                data.width = o.minWidth;
2748            }
2749            if (isminh) {
2750                data.height = o.minHeight;
2751            }
2752            if (ismaxw) {
2753                data.width = o.maxWidth;
2754            }
2755            if (ismaxh) {
2756                data.height = o.maxHeight;
2757            }
2758
2759            if (isminw && cw) {
2760                data.left = dw - o.minWidth;
2761            }
2762            if (ismaxw && cw) {
2763                data.left = dw - o.maxWidth;
2764            }
2765            if (isminh && ch) {
2766                data.top = dh - o.minHeight;
2767            }
2768            if (ismaxh && ch) {
2769                data.top = dh - o.maxHeight;
2770            }
2771
2772            // fixing jump error on top/left - bug #2330
2773            if (!data.width && !data.height && !data.left && data.top) {
2774                data.top = null;
2775            } else if (!data.width && !data.height && !data.top && data.left) {
2776                data.left = null;
2777            }
2778
2779            return data;
2780        },
2781
2782        _proportionallyResize: function() {
2783
2784            if (!this._proportionallyResizeElements.length) {
2785                return;
2786            }
2787
2788            var i, j, borders, paddings, prel,
2789                element = this.helper || this.element;
2790
2791            for ( i=0; i < this._proportionallyResizeElements.length; i++) {
2792
2793                prel = this._proportionallyResizeElements[i];
2794
2795                if (!this.borderDif) {
2796                    this.borderDif = [];
2797                    borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2798                    paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2799
2800                    for ( j = 0; j < borders.length; j++ ) {
2801                        this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2802                    }
2803                }
2804
2805                prel.css({
2806                    height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2807                    width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2808                });
2809
2810            }
2811
2812        },
2813
2814        _renderProxy: function() {
2815
2816            var el = this.element, o = this.options;
2817            this.elementOffset = el.offset();
2818
2819            if(this._helper) {
2820
2821                this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
2822
2823                this.helper.addClass(this._helper).css({
2824                    width: this.element.outerWidth() - 1,
2825                    height: this.element.outerHeight() - 1,
2826                    position: "absolute",
2827                    left: this.elementOffset.left +"px",
2828                    top: this.elementOffset.top +"px",
2829                    zIndex: ++o.zIndex //TODO: Don't modify option
2830                });
2831
2832                this.helper
2833                    .appendTo("body")
2834                    .disableSelection();
2835
2836            } else {
2837                this.helper = this.element;
2838            }
2839
2840        },
2841
2842        _change: {
2843            e: function(event, dx) {
2844                return { width: this.originalSize.width + dx };
2845            },
2846            w: function(event, dx) {
2847                var cs = this.originalSize, sp = this.originalPosition;
2848                return { left: sp.left + dx, width: cs.width - dx };
2849            },
2850            n: function(event, dx, dy) {
2851                var cs = this.originalSize, sp = this.originalPosition;
2852                return { top: sp.top + dy, height: cs.height - dy };
2853            },
2854            s: function(event, dx, dy) {
2855                return { height: this.originalSize.height + dy };
2856            },
2857            se: function(event, dx, dy) {
2858                return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2859            },
2860            sw: function(event, dx, dy) {
2861                return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2862            },
2863            ne: function(event, dx, dy) {
2864                return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2865            },
2866            nw: function(event, dx, dy) {
2867                return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2868            }
2869        },
2870
2871        _propagate: function(n, event) {
2872            $.ui.plugin.call(this, n, [event, this.ui()]);
2873            (n !== "resize" && this._trigger(n, event, this.ui()));
2874        },
2875
2876        plugins: {},
2877
2878        ui: function() {
2879            return {
2880                originalElement: this.originalElement,
2881                element: this.element,
2882                helper: this.helper,
2883                position: this.position,
2884                size: this.size,
2885                originalSize: this.originalSize,
2886                originalPosition: this.originalPosition
2887            };
2888        }
2889
2890    });
2891
2892    /*
2893 * Resizable Extensions
2894 */
2895
2896    $.ui.plugin.add("resizable", "animate", {
2897
2898        stop: function( event ) {
2899            var that = $(this).data("ui-resizable"),
2900                o = that.options,
2901                pr = that._proportionallyResizeElements,
2902                ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2903                soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2904                soffsetw = ista ? 0 : that.sizeDiff.width,
2905                style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
2906                left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2907                top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2908
2909            that.element.animate(
2910                $.extend(style, top && left ? { top: top, left: left } : {}), {
2911                    duration: o.animateDuration,
2912                    easing: o.animateEasing,
2913                    step: function() {
2914
2915                        var data = {
2916                            width: parseInt(that.element.css("width"), 10),
2917                            height: parseInt(that.element.css("height"), 10),
2918                            top: parseInt(that.element.css("top"), 10),
2919                            left: parseInt(that.element.css("left"), 10)
2920                        };
2921
2922                        if (pr && pr.length) {
2923                            $(pr[0]).css({ width: data.width, height: data.height });
2924                        }
2925
2926                        // propagating resize, and updating values for each animation step
2927                        that._updateCache(data);
2928                        that._propagate("resize", event);
2929
2930                    }
2931                }
2932            );
2933        }
2934
2935    });