/[projects]/misc/horsensspejder-web/jquery/jquery-ui-1.10.3/ui/jquery-ui.js
ViewVC logotype

Annotation of /misc/horsensspejder-web/jquery/jquery-ui-1.10.3/ui/jquery-ui.js

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2125 - (hide annotations) (download) (as text)
Wed Mar 12 19:30:05 2014 UTC (10 years, 4 months ago) by torben
File MIME type: application/javascript
File size: 435844 byte(s) 
initial import
1 torben 2125 /*! jQuery UI - v1.10.3 - 2013-05-03
2     * http://jqueryui.com
3     * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.effect.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
4     * Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
5     (function( $, undefined ) {
6    
7     var uuid = 0,
8     runiqueId = /^ui-id-\d+$/;
9    
10     // $.ui might exist from components with no dependencies, e.g., $.ui.position
11     $.ui = $.ui || {};
12    
13     $.extend( $.ui, {
14     version: "1.10.3",
15    
16     keyCode: {
17     BACKSPACE: 8,
18     COMMA: 188,
19     DELETE: 46,
20     DOWN: 40,
21     END: 35,
22     ENTER: 13,
23     ESCAPE: 27,
24     HOME: 36,
25     LEFT: 37,
26     NUMPAD_ADD: 107,
27     NUMPAD_DECIMAL: 110,
28     NUMPAD_DIVIDE: 111,
29     NUMPAD_ENTER: 108,
30     NUMPAD_MULTIPLY: 106,
31     NUMPAD_SUBTRACT: 109,
32     PAGE_DOWN: 34,
33     PAGE_UP: 33,
34     PERIOD: 190,
35     RIGHT: 39,
36     SPACE: 32,
37     TAB: 9,
38     UP: 38
39     }
40     });
41    
42     // plugins
43     $.fn.extend({
44     focus: (function( orig ) {
45     return function( delay, fn ) {
46     return typeof delay === "number" ?
47     this.each(function() {
48     var elem = this;
49     setTimeout(function() {
50     $( elem ).focus();
51     if ( fn ) {
52     fn.call( elem );
53     }
54     }, delay );
55     }) :
56     orig.apply( this, arguments );
57     };
58     })( $.fn.focus ),
59    
60     scrollParent: function() {
61     var scrollParent;
62     if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
63     scrollParent = this.parents().filter(function() {
64     return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
65     }).eq(0);
66     } else {
67     scrollParent = this.parents().filter(function() {
68     return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
69     }).eq(0);
70     }
71    
72     return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
73     },
74    
75     zIndex: function( zIndex ) {
76     if ( zIndex !== undefined ) {
77     return this.css( "zIndex", zIndex );
78     }
79    
80     if ( this.length ) {
81     var elem = $( this[ 0 ] ), position, value;
82     while ( elem.length && elem[ 0 ] !== document ) {
83     // Ignore z-index if position is set to a value where z-index is ignored by the browser
84     // This makes behavior of this function consistent across browsers
85     // WebKit always returns auto if the element is positioned
86     position = elem.css( "position" );
87     if ( position === "absolute" || position === "relative" || position === "fixed" ) {
88     // IE returns 0 when zIndex is not specified
89     // other browsers return a string
90     // we ignore the case of nested elements with an explicit value of 0
91     // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
92     value = parseInt( elem.css( "zIndex" ), 10 );
93     if ( !isNaN( value ) && value !== 0 ) {
94     return value;
95     }
96     }
97     elem = elem.parent();
98     }
99     }
100    
101     return 0;
102     },
103    
104     uniqueId: function() {
105     return this.each(function() {
106     if ( !this.id ) {
107     this.id = "ui-id-" + (++uuid);
108     }
109     });
110     },
111    
112     removeUniqueId: function() {
113     return this.each(function() {
114     if ( runiqueId.test( this.id ) ) {
115     $( this ).removeAttr( "id" );
116     }
117     });
118     }
119     });
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 $.widget() extensions 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.3",
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.3",
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     this.offsetParent = this.helper.offsetParent();
1100     this.offsetParentCssPosition = this.offsetParent.css( "position" );
1101    
1102     //The element's absolute position on the page minus margins
1103     this.offset = this.positionAbs = this.element.offset();
1104     this.offset = {
1105     top: this.offset.top - this.margins.top,
1106     left: this.offset.left - this.margins.left
1107     };
1108    
1109     //Reset scroll cache
1110     this.offset.scroll = false;
1111    
1112     $.extend(this.offset, {
1113     click: { //Where the click happened, relative to the element
1114     left: event.pageX - this.offset.left,
1115     top: event.pageY - this.offset.top
1116     },
1117     parent: this._getParentOffset(),
1118     relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1119     });
1120    
1121     //Generate the original position
1122     this.originalPosition = this.position = this._generatePosition(event);
1123     this.originalPageX = event.pageX;
1124     this.originalPageY = event.pageY;
1125    
1126     //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1127     (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1128    
1129     //Set a containment if given in the options
1130     this._setContainment();
1131    
1132     //Trigger event + callbacks
1133     if(this._trigger("start", event) === false) {
1134     this._clear();
1135     return false;
1136     }
1137    
1138     //Recache the helper size
1139     this._cacheHelperProportions();
1140    
1141     //Prepare the droppable offsets
1142     if ($.ui.ddmanager && !o.dropBehaviour) {
1143     $.ui.ddmanager.prepareOffsets(this, event);
1144     }
1145    
1146    
1147     this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1148    
1149     //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1150     if ( $.ui.ddmanager ) {
1151     $.ui.ddmanager.dragStart(this, event);
1152     }
1153    
1154     return true;
1155     },
1156    
1157     _mouseDrag: function(event, noPropagation) {
1158     // reset any necessary cached properties (see #5009)
1159     if ( this.offsetParentCssPosition === "fixed" ) {
1160     this.offset.parent = this._getParentOffset();
1161     }
1162    
1163     //Compute the helpers position
1164     this.position = this._generatePosition(event);
1165     this.positionAbs = this._convertPositionTo("absolute");
1166    
1167     //Call plugins and callbacks and use the resulting position if something is returned
1168     if (!noPropagation) {
1169     var ui = this._uiHash();
1170     if(this._trigger("drag", event, ui) === false) {
1171     this._mouseUp({});
1172     return false;
1173     }
1174     this.position = ui.position;
1175     }
1176    
1177     if(!this.options.axis || this.options.axis !== "y") {
1178     this.helper[0].style.left = this.position.left+"px";
1179     }
1180     if(!this.options.axis || this.options.axis !== "x") {
1181     this.helper[0].style.top = this.position.top+"px";
1182     }
1183     if($.ui.ddmanager) {
1184     $.ui.ddmanager.drag(this, event);
1185     }
1186    
1187     return false;
1188     },
1189    
1190     _mouseStop: function(event) {
1191    
1192     //If we are using droppables, inform the manager about the drop
1193     var that = this,
1194     dropped = false;
1195     if ($.ui.ddmanager && !this.options.dropBehaviour) {
1196     dropped = $.ui.ddmanager.drop(this, event);
1197     }
1198    
1199     //if a drop comes from outside (a sortable)
1200     if(this.dropped) {
1201     dropped = this.dropped;
1202     this.dropped = false;
1203     }
1204    
1205     //if the original element is no longer in the DOM don't bother to continue (see #8269)
1206     if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
1207     return false;
1208     }
1209    
1210     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))) {
1211     $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1212     if(that._trigger("stop", event) !== false) {
1213     that._clear();
1214     }
1215     });
1216     } else {
1217     if(this._trigger("stop", event) !== false) {
1218     this._clear();
1219     }
1220     }
1221    
1222     return false;
1223     },
1224    
1225     _mouseUp: function(event) {
1226     //Remove frame helpers
1227     $("div.ui-draggable-iframeFix").each(function() {
1228     this.parentNode.removeChild(this);
1229     });
1230    
1231     //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1232     if( $.ui.ddmanager ) {
1233     $.ui.ddmanager.dragStop(this, event);
1234     }
1235    
1236     return $.ui.mouse.prototype._mouseUp.call(this, event);
1237     },
1238    
1239     cancel: function() {
1240    
1241     if(this.helper.is(".ui-draggable-dragging")) {
1242     this._mouseUp({});
1243     } else {
1244     this._clear();
1245     }
1246    
1247     return this;
1248    
1249     },
1250    
1251     _getHandle: function(event) {
1252     return this.options.handle ?
1253     !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
1254     true;
1255     },
1256    
1257     _createHelper: function(event) {
1258    
1259     var o = this.options,
1260     helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1261    
1262     if(!helper.parents("body").length) {
1263     helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1264     }
1265    
1266     if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1267     helper.css("position", "absolute");
1268     }
1269    
1270     return helper;
1271    
1272     },
1273    
1274     _adjustOffsetFromHelper: function(obj) {
1275     if (typeof obj === "string") {
1276     obj = obj.split(" ");
1277     }
1278     if ($.isArray(obj)) {
1279     obj = {left: +obj[0], top: +obj[1] || 0};
1280     }
1281     if ("left" in obj) {
1282     this.offset.click.left = obj.left + this.margins.left;
1283     }
1284     if ("right" in obj) {
1285     this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1286     }
1287     if ("top" in obj) {
1288     this.offset.click.top = obj.top + this.margins.top;
1289     }
1290     if ("bottom" in obj) {
1291     this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1292     }
1293     },
1294    
1295     _getParentOffset: function() {
1296    
1297     //Get the offsetParent and cache its position
1298     var po = this.offsetParent.offset();
1299    
1300     // This is a special case where we need to modify a offset calculated on start, since the following happened:
1301     // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1302     // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1303     // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1304     if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1305     po.left += this.scrollParent.scrollLeft();
1306     po.top += this.scrollParent.scrollTop();
1307     }
1308    
1309     //This needs to be actually done for all browsers, since pageX/pageY includes this information
1310     //Ugly IE fix
1311     if((this.offsetParent[0] === document.body) ||
1312     (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1313     po = { top: 0, left: 0 };
1314     }
1315    
1316     return {
1317     top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
1318     left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1319     };
1320    
1321     },
1322    
1323     _getRelativeOffset: function() {
1324    
1325     if(this.cssPosition === "relative") {
1326     var p = this.element.position();
1327     return {
1328     top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1329     left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1330     };
1331     } else {
1332     return { top: 0, left: 0 };
1333     }
1334    
1335     },
1336    
1337     _cacheMargins: function() {
1338     this.margins = {
1339     left: (parseInt(this.element.css("marginLeft"),10) || 0),
1340     top: (parseInt(this.element.css("marginTop"),10) || 0),
1341     right: (parseInt(this.element.css("marginRight"),10) || 0),
1342     bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1343     };
1344     },
1345    
1346     _cacheHelperProportions: function() {
1347     this.helperProportions = {
1348     width: this.helper.outerWidth(),
1349     height: this.helper.outerHeight()
1350     };
1351     },
1352    
1353     _setContainment: function() {
1354    
1355     var over, c, ce,
1356     o = this.options;
1357    
1358     if ( !o.containment ) {
1359     this.containment = null;
1360     return;
1361     }
1362    
1363     if ( o.containment === "window" ) {
1364     this.containment = [
1365     $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1366     $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
1367     $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
1368     $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1369     ];
1370     return;
1371     }
1372    
1373     if ( o.containment === "document") {
1374     this.containment = [
1375     0,
1376     0,
1377     $( document ).width() - this.helperProportions.width - this.margins.left,
1378     ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1379     ];
1380     return;
1381     }
1382    
1383     if ( o.containment.constructor === Array ) {
1384     this.containment = o.containment;
1385     return;
1386     }
1387    
1388     if ( o.containment === "parent" ) {
1389     o.containment = this.helper[ 0 ].parentNode;
1390     }
1391    
1392     c = $( o.containment );
1393     ce = c[ 0 ];
1394    
1395     if( !ce ) {
1396     return;
1397     }
1398    
1399     over = c.css( "overflow" ) !== "hidden";
1400    
1401     this.containment = [
1402     ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
1403     ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
1404     ( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) - ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) - this.helperProportions.width - this.margins.left - this.margins.right,
1405     ( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) - ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) - this.helperProportions.height - this.margins.top - this.margins.bottom
1406     ];
1407     this.relative_container = c;
1408     },
1409    
1410     _convertPositionTo: function(d, pos) {
1411    
1412     if(!pos) {
1413     pos = this.position;
1414     }
1415    
1416     var mod = d === "absolute" ? 1 : -1,
1417     scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
1418    
1419     //Cache the scroll
1420     if (!this.offset.scroll) {
1421     this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1422     }
1423    
1424     return {
1425     top: (
1426     pos.top + // The absolute mouse position
1427     this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
1428     this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
1429     ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
1430     ),
1431     left: (
1432     pos.left + // The absolute mouse position
1433     this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
1434     this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
1435     ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
1436     )
1437     };
1438    
1439     },
1440    
1441     _generatePosition: function(event) {
1442    
1443     var containment, co, top, left,
1444     o = this.options,
1445     scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
1446     pageX = event.pageX,
1447     pageY = event.pageY;
1448    
1449     //Cache the scroll
1450     if (!this.offset.scroll) {
1451     this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1452     }
1453    
1454     /*
1455     * - Position constraining -
1456     * Constrain the position to a mix of grid, containment.
1457     */
1458    
1459     // If we are not dragging yet, we won't check for options
1460     if ( this.originalPosition ) {
1461     if ( this.containment ) {
1462     if ( this.relative_container ){
1463     co = this.relative_container.offset();
1464     containment = [
1465     this.containment[ 0 ] + co.left,
1466     this.containment[ 1 ] + co.top,
1467     this.containment[ 2 ] + co.left,
1468     this.containment[ 3 ] + co.top
1469     ];
1470     }
1471     else {
1472     containment = this.containment;
1473     }
1474    
1475     if(event.pageX - this.offset.click.left < containment[0]) {
1476     pageX = containment[0] + this.offset.click.left;
1477     }
1478     if(event.pageY - this.offset.click.top < containment[1]) {
1479     pageY = containment[1] + this.offset.click.top;
1480     }
1481     if(event.pageX - this.offset.click.left > containment[2]) {
1482     pageX = containment[2] + this.offset.click.left;
1483     }
1484     if(event.pageY - this.offset.click.top > containment[3]) {
1485     pageY = containment[3] + this.offset.click.top;
1486     }
1487     }
1488    
1489     if(o.grid) {
1490     //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1491     top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1492     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;
1493    
1494     left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1495     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;
1496     }
1497    
1498     }
1499    
1500     return {
1501     top: (
1502     pageY - // The absolute mouse position
1503     this.offset.click.top - // Click offset (relative to the element)
1504     this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
1505     this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
1506     ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
1507     ),
1508     left: (
1509     pageX - // The absolute mouse position
1510     this.offset.click.left - // Click offset (relative to the element)
1511     this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
1512     this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
1513     ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
1514     )
1515     };
1516    
1517     },
1518    
1519     _clear: function() {
1520     this.helper.removeClass("ui-draggable-dragging");
1521     if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
1522     this.helper.remove();
1523     }
1524     this.helper = null;
1525     this.cancelHelperRemoval = false;
1526     },
1527    
1528     // From now on bulk stuff - mainly helpers
1529    
1530     _trigger: function(type, event, ui) {
1531     ui = ui || this._uiHash();
1532     $.ui.plugin.call(this, type, [event, ui]);
1533     //The absolute position has to be recalculated after plugins
1534     if(type === "drag") {
1535     this.positionAbs = this._convertPositionTo("absolute");
1536     }
1537     return $.Widget.prototype._trigger.call(this, type, event, ui);
1538     },
1539    
1540     plugins: {},
1541    
1542     _uiHash: function() {
1543     return {
1544     helper: this.helper,
1545     position: this.position,
1546     originalPosition: this.originalPosition,
1547     offset: this.positionAbs
1548     };
1549     }
1550    
1551     });
1552    
1553     $.ui.plugin.add("draggable", "connectToSortable", {
1554     start: function(event, ui) {
1555    
1556     var inst = $(this).data("ui-draggable"), o = inst.options,
1557     uiSortable = $.extend({}, ui, { item: inst.element });
1558     inst.sortables = [];
1559     $(o.connectToSortable).each(function() {
1560     var sortable = $.data(this, "ui-sortable");
1561     if (sortable && !sortable.options.disabled) {
1562     inst.sortables.push({
1563     instance: sortable,
1564     shouldRevert: sortable.options.revert
1565     });
1566     sortable.refreshPositions(); // Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
1567     sortable._trigger("activate", event, uiSortable);
1568     }
1569     });
1570    
1571     },
1572     stop: function(event, ui) {
1573    
1574     //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
1575     var inst = $(this).data("ui-draggable"),
1576     uiSortable = $.extend({}, ui, { item: inst.element });
1577    
1578     $.each(inst.sortables, function() {
1579     if(this.instance.isOver) {
1580    
1581     this.instance.isOver = 0;
1582    
1583     inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
1584     this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
1585    
1586     //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
1587     if(this.shouldRevert) {
1588     this.instance.options.revert = this.shouldRevert;
1589     }
1590    
1591     //Trigger the stop of the sortable
1592     this.instance._mouseStop(event);
1593    
1594     this.instance.options.helper = this.instance.options._helper;
1595    
1596     //If the helper has been the original item, restore properties in the sortable
1597     if(inst.options.helper === "original") {
1598     this.instance.currentItem.css({ top: "auto", left: "auto" });
1599     }
1600    
1601     } else {
1602     this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
1603     this.instance._trigger("deactivate", event, uiSortable);
1604     }
1605    
1606     });
1607    
1608     },
1609     drag: function(event, ui) {
1610    
1611     var inst = $(this).data("ui-draggable"), that = this;
1612    
1613     $.each(inst.sortables, function() {
1614    
1615     var innermostIntersecting = false,
1616     thisSortable = this;
1617    
1618     //Copy over some variables to allow calling the sortable's native _intersectsWith
1619     this.instance.positionAbs = inst.positionAbs;
1620     this.instance.helperProportions = inst.helperProportions;
1621     this.instance.offset.click = inst.offset.click;
1622    
1623     if(this.instance._intersectsWith(this.instance.containerCache)) {
1624     innermostIntersecting = true;
1625     $.each(inst.sortables, function () {
1626     this.instance.positionAbs = inst.positionAbs;
1627     this.instance.helperProportions = inst.helperProportions;
1628     this.instance.offset.click = inst.offset.click;
1629     if (this !== thisSortable &&
1630     this.instance._intersectsWith(this.instance.containerCache) &&
1631     $.contains(thisSortable.instance.element[0], this.instance.element[0])
1632     ) {
1633     innermostIntersecting = false;
1634     }
1635     return innermostIntersecting;
1636     });
1637     }
1638    
1639    
1640     if(innermostIntersecting) {
1641     //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
1642     if(!this.instance.isOver) {
1643    
1644     this.instance.isOver = 1;
1645     //Now we fake the start of dragging for the sortable instance,
1646     //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
1647     //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
1648     this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
1649     this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
1650     this.instance.options.helper = function() { return ui.helper[0]; };
1651    
1652     event.target = this.instance.currentItem[0];
1653     this.instance._mouseCapture(event, true);
1654     this.instance._mouseStart(event, true, true);
1655    
1656     //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
1657     this.instance.offset.click.top = inst.offset.click.top;
1658     this.instance.offset.click.left = inst.offset.click.left;
1659     this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
1660     this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
1661    
1662     inst._trigger("toSortable", event);
1663     inst.dropped = this.instance.element; //draggable revert needs that
1664     //hack so receive/update callbacks work (mostly)
1665     inst.currentItem = inst.element;
1666     this.instance.fromOutside = inst;
1667    
1668     }
1669    
1670     //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
1671     if(this.instance.currentItem) {
1672     this.instance._mouseDrag(event);
1673     }
1674    
1675     } else {
1676    
1677     //If it doesn't intersect with the sortable, and it intersected before,
1678     //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
1679     if(this.instance.isOver) {
1680    
1681     this.instance.isOver = 0;
1682     this.instance.cancelHelperRemoval = true;
1683    
1684     //Prevent reverting on this forced stop
1685     this.instance.options.revert = false;
1686    
1687     // The out event needs to be triggered independently
1688     this.instance._trigger("out", event, this.instance._uiHash(this.instance));
1689    
1690     this.instance._mouseStop(event, true);
1691     this.instance.options.helper = this.instance.options._helper;
1692    
1693     //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
1694     this.instance.currentItem.remove();
1695     if(this.instance.placeholder) {
1696     this.instance.placeholder.remove();
1697     }
1698    
1699     inst._trigger("fromSortable", event);
1700     inst.dropped = false; //draggable revert needs that
1701     }
1702    
1703     }
1704    
1705     });
1706    
1707     }
1708     });
1709    
1710     $.ui.plugin.add("draggable", "cursor", {
1711     start: function() {
1712     var t = $("body"), o = $(this).data("ui-draggable").options;
1713     if (t.css("cursor")) {
1714     o._cursor = t.css("cursor");
1715     }
1716     t.css("cursor", o.cursor);
1717     },
1718     stop: function() {
1719     var o = $(this).data("ui-draggable").options;
1720     if (o._cursor) {
1721     $("body").css("cursor", o._cursor);
1722     }
1723     }
1724     });
1725    
1726     $.ui.plugin.add("draggable", "opacity", {
1727     start: function(event, ui) {
1728     var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1729     if(t.css("opacity")) {
1730     o._opacity = t.css("opacity");
1731     }
1732     t.css("opacity", o.opacity);
1733     },
1734     stop: function(event, ui) {
1735     var o = $(this).data("ui-draggable").options;
1736     if(o._opacity) {
1737     $(ui.helper).css("opacity", o._opacity);
1738     }
1739     }
1740     });
1741    
1742     $.ui.plugin.add("draggable", "scroll", {
1743     start: function() {
1744     var i = $(this).data("ui-draggable");
1745     if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1746     i.overflowOffset = i.scrollParent.offset();
1747     }
1748     },
1749     drag: function( event ) {
1750    
1751     var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
1752    
1753     if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1754    
1755     if(!o.axis || o.axis !== "x") {
1756     if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
1757     i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
1758     } else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
1759     i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
1760     }
1761     }
1762    
1763     if(!o.axis || o.axis !== "y") {
1764     if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
1765     i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
1766     } else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
1767     i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
1768     }
1769     }
1770    
1771     } else {
1772    
1773     if(!o.axis || o.axis !== "x") {
1774     if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
1775     scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
1776     } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
1777     scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
1778     }
1779     }
1780    
1781     if(!o.axis || o.axis !== "y") {
1782     if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
1783     scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
1784     } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
1785     scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
1786     }
1787     }
1788    
1789     }
1790    
1791     if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
1792     $.ui.ddmanager.prepareOffsets(i, event);
1793     }
1794    
1795     }
1796     });
1797    
1798     $.ui.plugin.add("draggable", "snap", {
1799     start: function() {
1800    
1801     var i = $(this).data("ui-draggable"),
1802     o = i.options;
1803    
1804     i.snapElements = [];
1805    
1806     $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
1807     var $t = $(this),
1808     $o = $t.offset();
1809     if(this !== i.element[0]) {
1810     i.snapElements.push({
1811     item: this,
1812     width: $t.outerWidth(), height: $t.outerHeight(),
1813     top: $o.top, left: $o.left
1814     });
1815     }
1816     });
1817    
1818     },
1819     drag: function(event, ui) {
1820    
1821     var ts, bs, ls, rs, l, r, t, b, i, first,
1822     inst = $(this).data("ui-draggable"),
1823     o = inst.options,
1824     d = o.snapTolerance,
1825     x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
1826     y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
1827    
1828     for (i = inst.snapElements.length - 1; i >= 0; i--){
1829    
1830     l = inst.snapElements[i].left;
1831     r = l + inst.snapElements[i].width;
1832     t = inst.snapElements[i].top;
1833     b = t + inst.snapElements[i].height;
1834    
1835     if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
1836     if(inst.snapElements[i].snapping) {
1837     (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1838     }
1839     inst.snapElements[i].snapping = false;
1840     continue;
1841     }
1842    
1843     if(o.snapMode !== "inner") {
1844     ts = Math.abs(t - y2) <= d;
1845     bs = Math.abs(b - y1) <= d;
1846     ls = Math.abs(l - x2) <= d;
1847     rs = Math.abs(r - x1) <= d;
1848     if(ts) {
1849     ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1850     }
1851     if(bs) {
1852     ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1853     }
1854     if(ls) {
1855     ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1856     }
1857     if(rs) {
1858     ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1859     }
1860     }
1861    
1862     first = (ts || bs || ls || rs);
1863    
1864     if(o.snapMode !== "outer") {
1865     ts = Math.abs(t - y1) <= d;
1866     bs = Math.abs(b - y2) <= d;
1867     ls = Math.abs(l - x1) <= d;
1868     rs = Math.abs(r - x2) <= d;
1869     if(ts) {
1870     ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1871     }
1872     if(bs) {
1873     ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1874     }
1875     if(ls) {
1876     ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1877     }
1878     if(rs) {
1879     ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1880     }
1881     }
1882    
1883     if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1884     (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1885     }
1886     inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1887    
1888     }
1889    
1890     }
1891     });
1892    
1893     $.ui.plugin.add("draggable", "stack", {
1894     start: function() {
1895     var min,
1896     o = this.data("ui-draggable").options,
1897     group = $.makeArray($(o.stack)).sort(function(a,b) {
1898     return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1899     });
1900    
1901     if (!group.length) { return; }
1902    
1903     min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1904     $(group).each(function(i) {
1905     $(this).css("zIndex", min + i);
1906     });
1907     this.css("zIndex", (min + group.length));
1908     }
1909     });
1910    
1911     $.ui.plugin.add("draggable", "zIndex", {
1912     start: function(event, ui) {
1913     var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1914     if(t.css("zIndex")) {
1915     o._zIndex = t.css("zIndex");
1916     }
1917     t.css("zIndex", o.zIndex);
1918     },
1919     stop: function(event, ui) {
1920     var o = $(this).data("ui-draggable").options;
1921     if(o._zIndex) {
1922     $(ui.helper).css("zIndex", o._zIndex);
1923     }
1924     }
1925     });
1926    
1927     })(jQuery);
1928    
1929     (function( $, undefined ) {
1930    
1931     function isOverAxis( x, reference, size ) {
1932     return ( x > reference ) && ( x < ( reference + size ) );
1933     }
1934    
1935     $.widget("ui.droppable", {
1936     version: "1.10.3",
1937     widgetEventPrefix: "drop",
1938     options: {
1939     accept: "*",
1940     activeClass: false,
1941     addClasses: true,
1942     greedy: false,
1943     hoverClass: false,
1944     scope: "default",
1945     tolerance: "intersect",
1946    
1947     // callbacks
1948     activate: null,
1949     deactivate: null,
1950     drop: null,
1951     out: null,
1952     over: null
1953     },
1954     _create: function() {
1955    
1956     var o = this.options,
1957     accept = o.accept;
1958    
1959     this.isover = false;
1960     this.isout = true;
1961    
1962     this.accept = $.isFunction(accept) ? accept : function(d) {
1963     return d.is(accept);
1964     };
1965    
1966     //Store the droppable's proportions
1967     this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1968    
1969     // Add the reference and positions to the manager
1970     $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1971     $.ui.ddmanager.droppables[o.scope].push(this);
1972    
1973     (o.addClasses && this.element.addClass("ui-droppable"));
1974    
1975     },
1976    
1977     _destroy: function() {
1978     var i = 0,
1979     drop = $.ui.ddmanager.droppables[this.options.scope];
1980    
1981     for ( ; i < drop.length; i++ ) {
1982     if ( drop[i] === this ) {
1983     drop.splice(i, 1);
1984     }
1985     }
1986    
1987     this.element.removeClass("ui-droppable ui-droppable-disabled");
1988     },
1989    
1990     _setOption: function(key, value) {
1991    
1992     if(key === "accept") {
1993     this.accept = $.isFunction(value) ? value : function(d) {
1994     return d.is(value);
1995     };
1996     }
1997     $.Widget.prototype._setOption.apply(this, arguments);
1998     },
1999    
2000     _activate: function(event) {
2001     var draggable = $.ui.ddmanager.current;
2002     if(this.options.activeClass) {
2003     this.element.addClass(this.options.activeClass);
2004     }
2005     if(draggable){
2006     this._trigger("activate", event, this.ui(draggable));
2007     }
2008     },
2009    
2010     _deactivate: function(event) {
2011     var draggable = $.ui.ddmanager.current;
2012     if(this.options.activeClass) {
2013     this.element.removeClass(this.options.activeClass);
2014     }
2015     if(draggable){
2016     this._trigger("deactivate", event, this.ui(draggable));
2017     }
2018     },
2019    
2020     _over: function(event) {
2021    
2022     var draggable = $.ui.ddmanager.current;
2023    
2024     // Bail if draggable and droppable are same element
2025     if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2026     return;
2027     }
2028    
2029     if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2030     if(this.options.hoverClass) {
2031     this.element.addClass(this.options.hoverClass);
2032     }
2033     this._trigger("over", event, this.ui(draggable));
2034     }
2035    
2036     },
2037    
2038     _out: function(event) {
2039    
2040     var draggable = $.ui.ddmanager.current;
2041    
2042     // Bail if draggable and droppable are same element
2043     if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2044     return;
2045     }
2046    
2047     if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2048     if(this.options.hoverClass) {
2049     this.element.removeClass(this.options.hoverClass);
2050     }
2051     this._trigger("out", event, this.ui(draggable));
2052     }
2053    
2054     },
2055    
2056     _drop: function(event,custom) {
2057    
2058     var draggable = custom || $.ui.ddmanager.current,
2059     childrenIntersection = false;
2060    
2061     // Bail if draggable and droppable are same element
2062     if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2063     return false;
2064     }
2065    
2066     this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
2067     var inst = $.data(this, "ui-droppable");
2068     if(
2069     inst.options.greedy &&
2070     !inst.options.disabled &&
2071     inst.options.scope === draggable.options.scope &&
2072     inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
2073     $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2074     ) { childrenIntersection = true; return false; }
2075     });
2076     if(childrenIntersection) {
2077     return false;
2078     }
2079    
2080     if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2081     if(this.options.activeClass) {
2082     this.element.removeClass(this.options.activeClass);
2083     }
2084     if(this.options.hoverClass) {
2085     this.element.removeClass(this.options.hoverClass);
2086     }
2087     this._trigger("drop", event, this.ui(draggable));
2088     return this.element;
2089     }
2090    
2091     return false;
2092    
2093     },
2094    
2095     ui: function(c) {
2096     return {
2097     draggable: (c.currentItem || c.element),
2098     helper: c.helper,
2099     position: c.position,
2100     offset: c.positionAbs
2101     };
2102     }
2103    
2104     });
2105    
2106     $.ui.intersect = function(draggable, droppable, toleranceMode) {
2107    
2108     if (!droppable.offset) {
2109     return false;
2110     }
2111    
2112     var draggableLeft, draggableTop,
2113     x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2114     y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
2115     l = droppable.offset.left, r = l + droppable.proportions.width,
2116     t = droppable.offset.top, b = t + droppable.proportions.height;
2117    
2118     switch (toleranceMode) {
2119     case "fit":
2120     return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
2121     case "intersect":
2122     return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
2123     x2 - (draggable.helperProportions.width / 2) < r && // Left Half
2124     t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
2125     y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2126     case "pointer":
2127     draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2128     draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2129     return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
2130     case "touch":
2131     return (
2132     (y1 >= t && y1 <= b) || // Top edge touching
2133     (y2 >= t && y2 <= b) || // Bottom edge touching
2134     (y1 < t && y2 > b) // Surrounded vertically
2135     ) && (
2136     (x1 >= l && x1 <= r) || // Left edge touching
2137     (x2 >= l && x2 <= r) || // Right edge touching
2138     (x1 < l && x2 > r) // Surrounded horizontally
2139     );
2140     default:
2141     return false;
2142     }
2143    
2144     };
2145    
2146     /*
2147     This manager tracks offsets of draggables and droppables
2148     */
2149     $.ui.ddmanager = {
2150     current: null,
2151     droppables: { "default": [] },
2152     prepareOffsets: function(t, event) {
2153    
2154     var i, j,
2155     m = $.ui.ddmanager.droppables[t.options.scope] || [],
2156     type = event ? event.type : null, // workaround for #2317
2157     list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
2158    
2159     droppablesLoop: for (i = 0; i < m.length; i++) {
2160    
2161     //No disabled and non-accepted
2162     if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2163     continue;
2164     }
2165    
2166     // Filter out elements in the current dragged item
2167     for (j=0; j < list.length; j++) {
2168     if(list[j] === m[i].element[0]) {
2169     m[i].proportions.height = 0;
2170     continue droppablesLoop;
2171     }
2172     }
2173    
2174     m[i].visible = m[i].element.css("display") !== "none";
2175     if(!m[i].visible) {
2176     continue;
2177     }
2178    
2179     //Activate the droppable if used directly from draggables
2180     if(type === "mousedown") {
2181     m[i]._activate.call(m[i], event);
2182     }
2183    
2184     m[i].offset = m[i].element.offset();
2185     m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2186    
2187     }
2188    
2189     },
2190     drop: function(draggable, event) {
2191    
2192     var dropped = false;
2193     // Create a copy of the droppables in case the list changes during the drop (#9116)
2194     $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
2195    
2196     if(!this.options) {
2197     return;
2198     }
2199     if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2200     dropped = this._drop.call(this, event) || dropped;
2201     }
2202    
2203     if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2204     this.isout = true;
2205     this.isover = false;
2206     this._deactivate.call(this, event);
2207     }
2208    
2209     });
2210     return dropped;
2211    
2212     },
2213     dragStart: function( draggable, event ) {
2214     //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2215     draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2216     if( !draggable.options.refreshPositions ) {
2217     $.ui.ddmanager.prepareOffsets( draggable, event );
2218     }
2219     });
2220     },
2221     drag: function(draggable, event) {
2222    
2223     //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2224     if(draggable.options.refreshPositions) {
2225     $.ui.ddmanager.prepareOffsets(draggable, event);
2226     }
2227    
2228     //Run through all droppables and check their positions based on specific tolerance options
2229     $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2230    
2231     if(this.options.disabled || this.greedyChild || !this.visible) {
2232     return;
2233     }
2234    
2235     var parentInstance, scope, parent,
2236     intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2237     c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2238     if(!c) {
2239     return;
2240     }
2241    
2242     if (this.options.greedy) {
2243     // find droppable parents with same scope
2244     scope = this.options.scope;
2245     parent = this.element.parents(":data(ui-droppable)").filter(function () {
2246     return $.data(this, "ui-droppable").options.scope === scope;
2247     });
2248    
2249     if (parent.length) {
2250     parentInstance = $.data(parent[0], "ui-droppable");
2251     parentInstance.greedyChild = (c === "isover");
2252     }
2253     }
2254    
2255     // we just moved into a greedy child
2256     if (parentInstance && c === "isover") {
2257     parentInstance.isover = false;
2258     parentInstance.isout = true;
2259     parentInstance._out.call(parentInstance, event);
2260     }
2261    
2262     this[c] = true;
2263     this[c === "isout" ? "isover" : "isout"] = false;
2264     this[c === "isover" ? "_over" : "_out"].call(this, event);
2265    
2266     // we just moved out of a greedy child
2267     if (parentInstance && c === "isout") {
2268     parentInstance.isout = false;
2269     parentInstance.isover = true;
2270     parentInstance._over.call(parentInstance, event);
2271     }
2272     });
2273    
2274     },
2275     dragStop: function( draggable, event ) {
2276     draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2277     //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2278     if( !draggable.options.refreshPositions ) {
2279     $.ui.ddmanager.prepareOffsets( draggable, event );
2280     }
2281     }
2282     };
2283    
2284     })(jQuery);
2285    
2286     (function( $, undefined ) {
2287    
2288     function num(v) {
2289     return parseInt(v, 10) || 0;
2290     }
2291    
2292     function isNumber(value) {
2293     return !isNaN(parseInt(value, 10));
2294     }
2295    
2296     $.widget("ui.resizable", $.ui.mouse, {
2297     version: "1.10.3",
2298     widgetEventPrefix: "resize",
2299     options: {
2300     alsoResize: false,
2301     animate: false,
2302     animateDuration: "slow",
2303     animateEasing: "swing",
2304     aspectRatio: false,
2305     autoHide: false,
2306     containment: false,
2307     ghost: false,
2308     grid: false,
2309     handles: "e,s,se",
2310     helper: false,
2311     maxHeight: null,
2312     maxWidth: null,
2313     minHeight: 10,
2314     minWidth: 10,
2315     // See #7960
2316     zIndex: 90,
2317    
2318     // callbacks
2319     resize: null,
2320     start: null,
2321     stop: null
2322     },
2323     _create: function() {
2324    
2325     var n, i, handle, axis, hname,
2326     that = this,
2327     o = this.options;
2328     this.element.addClass("ui-resizable");
2329    
2330     $.extend(this, {
2331     _aspectRatio: !!(o.aspectRatio),
2332     aspectRatio: o.aspectRatio,
2333     originalElement: this.element,
2334     _proportionallyResizeElements: [],
2335     _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2336     });
2337    
2338     //Wrap the element if it cannot hold child nodes
2339     if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2340    
2341     //Create a wrapper element and set the wrapper to the new current internal element
2342     this.element.wrap(
2343     $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2344     position: this.element.css("position"),
2345     width: this.element.outerWidth(),
2346     height: this.element.outerHeight(),
2347     top: this.element.css("top"),
2348     left: this.element.css("left")
2349     })
2350     );
2351    
2352     //Overwrite the original this.element
2353     this.element = this.element.parent().data(
2354     "ui-resizable", this.element.data("ui-resizable")
2355     );
2356    
2357     this.elementIsWrapper = true;
2358    
2359     //Move margins to the wrapper
2360     this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2361     this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2362    
2363     //Prevent Safari textarea resize
2364     this.originalResizeStyle = this.originalElement.css("resize");
2365     this.originalElement.css("resize", "none");
2366    
2367     //Push the actual element to our proportionallyResize internal array
2368     this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2369    
2370     // avoid IE jump (hard set the margin)
2371     this.originalElement.css({ margin: this.originalElement.css("margin") });
2372    
2373     // fix handlers offset
2374     this._proportionallyResize();
2375    
2376     }
2377    
2378     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" });
2379     if(this.handles.constructor === String) {
2380    
2381     if ( this.handles === "all") {
2382     this.handles = "n,e,s,w,se,sw,ne,nw";
2383     }
2384    
2385     n = this.handles.split(",");
2386     this.handles = {};
2387    
2388     for(i = 0; i < n.length; i++) {
2389    
2390     handle = $.trim(n[i]);
2391     hname = "ui-resizable-"+handle;
2392     axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2393    
2394     // Apply zIndex to all handles - see #7960
2395     axis.css({ zIndex: o.zIndex });
2396    
2397     //TODO : What's going on here?
2398     if ("se" === handle) {
2399     axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2400     }
2401    
2402     //Insert into internal handles object and append to element
2403     this.handles[handle] = ".ui-resizable-"+handle;
2404     this.element.append(axis);
2405     }
2406    
2407     }
2408    
2409     this._renderAxis = function(target) {
2410    
2411     var i, axis, padPos, padWrapper;
2412    
2413     target = target || this.element;
2414    
2415     for(i in this.handles) {
2416    
2417     if(this.handles[i].constructor === String) {
2418     this.handles[i] = $(this.handles[i], this.element).show();
2419     }
2420    
2421     //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2422     if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2423    
2424     axis = $(this.handles[i], this.element);
2425    
2426     //Checking the correct pad and border
2427     padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2428    
2429     //The padding type i have to apply...
2430     padPos = [ "padding",
2431     /ne|nw|n/.test(i) ? "Top" :
2432     /se|sw|s/.test(i) ? "Bottom" :
2433     /^e$/.test(i) ? "Right" : "Left" ].join("");
2434    
2435     target.css(padPos, padWrapper);
2436    
2437     this._proportionallyResize();
2438    
2439     }
2440    
2441     //TODO: What's that good for? There's not anything to be executed left
2442     if(!$(this.handles[i]).length) {
2443     continue;
2444     }
2445     }
2446     };
2447    
2448     //TODO: make renderAxis a prototype function
2449     this._renderAxis(this.element);
2450    
2451     this._handles = $(".ui-resizable-handle", this.element)
2452     .disableSelection();
2453    
2454     //Matching axis name
2455     this._handles.mouseover(function() {
2456     if (!that.resizing) {
2457     if (this.className) {
2458     axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2459     }
2460     //Axis, default = se
2461     that.axis = axis && axis[1] ? axis[1] : "se";
2462     }
2463     });
2464    
2465     //If we want to auto hide the elements
2466     if (o.autoHide) {
2467     this._handles.hide();
2468     $(this.element)
2469     .addClass("ui-resizable-autohide")
2470     .mouseenter(function() {
2471     if (o.disabled) {
2472     return;
2473     }
2474     $(this).removeClass("ui-resizable-autohide");
2475     that._handles.show();
2476     })
2477     .mouseleave(function(){
2478     if (o.disabled) {
2479     return;
2480     }
2481     if (!that.resizing) {
2482     $(this).addClass("ui-resizable-autohide");
2483     that._handles.hide();
2484     }
2485     });
2486     }
2487    
2488     //Initialize the mouse interaction
2489     this._mouseInit();
2490    
2491     },
2492    
2493     _destroy: function() {
2494    
2495     this._mouseDestroy();
2496    
2497     var wrapper,
2498     _destroy = function(exp) {
2499     $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2500     .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2501     };
2502    
2503     //TODO: Unwrap at same DOM position
2504     if (this.elementIsWrapper) {
2505     _destroy(this.element);
2506     wrapper = this.element;
2507     this.originalElement.css({
2508     position: wrapper.css("position"),
2509     width: wrapper.outerWidth(),
2510     height: wrapper.outerHeight(),
2511     top: wrapper.css("top"),
2512     left: wrapper.css("left")
2513     }).insertAfter( wrapper );
2514     wrapper.remove();
2515     }
2516    
2517     this.originalElement.css("resize", this.originalResizeStyle);
2518     _destroy(this.originalElement);
2519    
2520     return this;
2521     },
2522    
2523     _mouseCapture: function(event) {
2524     var i, handle,
2525     capture = false;
2526    
2527     for (i in this.handles) {
2528     handle = $(this.handles[i])[0];
2529     if (handle === event.target || $.contains(handle, event.target)) {
2530     capture = true;
2531     }
2532     }
2533    
2534     return !this.options.disabled && capture;
2535     },
2536    
2537     _mouseStart: function(event) {
2538    
2539     var curleft, curtop, cursor,
2540     o = this.options,
2541     iniPos = this.element.position(),
2542     el = this.element;
2543    
2544     this.resizing = true;
2545    
2546     // bugfix for http://dev.jquery.com/ticket/1749
2547     if ( (/absolute/).test( el.css("position") ) ) {
2548     el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
2549     } else if (el.is(".ui-draggable")) {
2550     el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
2551     }
2552    
2553     this._renderProxy();
2554    
2555     curleft = num(this.helper.css("left"));
2556     curtop = num(this.helper.css("top"));
2557    
2558     if (o.containment) {
2559     curleft += $(o.containment).scrollLeft() || 0;
2560     curtop += $(o.containment).scrollTop() || 0;
2561     }
2562    
2563     //Store needed variables
2564     this.offset = this.helper.offset();
2565     this.position = { left: curleft, top: curtop };
2566     this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2567     this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2568     this.originalPosition = { left: curleft, top: curtop };
2569     this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2570     this.originalMousePosition = { left: event.pageX, top: event.pageY };
2571    
2572     //Aspect Ratio
2573     this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2574    
2575     cursor = $(".ui-resizable-" + this.axis).css("cursor");
2576     $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
2577    
2578     el.addClass("ui-resizable-resizing");
2579     this._propagate("start", event);
2580     return true;
2581     },
2582    
2583     _mouseDrag: function(event) {
2584    
2585     //Increase performance, avoid regex
2586     var data,
2587     el = this.helper, props = {},
2588     smp = this.originalMousePosition,
2589     a = this.axis,
2590     prevTop = this.position.top,
2591     prevLeft = this.position.left,
2592     prevWidth = this.size.width,
2593     prevHeight = this.size.height,
2594     dx = (event.pageX-smp.left)||0,
2595     dy = (event.pageY-smp.top)||0,
2596     trigger = this._change[a];
2597    
2598     if (!trigger) {
2599     return false;
2600     }
2601    
2602     // Calculate the attrs that will be change
2603     data = trigger.apply(this, [event, dx, dy]);
2604    
2605     // Put this in the mouseDrag handler since the user can start pressing shift while resizing
2606     this._updateVirtualBoundaries(event.shiftKey);
2607     if (this._aspectRatio || event.shiftKey) {
2608     data = this._updateRatio(data, event);
2609     }
2610    
2611     data = this._respectSize(data, event);
2612    
2613     this._updateCache(data);
2614    
2615     // plugins callbacks need to be called first
2616     this._propagate("resize", event);
2617    
2618     if (this.position.top !== prevTop) {
2619     props.top = this.position.top + "px";
2620     }
2621     if (this.position.left !== prevLeft) {
2622     props.left = this.position.left + "px";
2623     }
2624     if (this.size.width !== prevWidth) {
2625     props.width = this.size.width + "px";
2626     }
2627     if (this.size.height !== prevHeight) {
2628     props.height = this.size.height + "px";
2629     }
2630     el.css(props);
2631    
2632     if (!this._helper && this._proportionallyResizeElements.length) {
2633     this._proportionallyResize();
2634     }
2635    
2636     // Call the user callback if the element was resized
2637     if ( ! $.isEmptyObject(props) ) {
2638     this._trigger("resize", event, this.ui());
2639     }
2640    
2641     return false;
2642     },
2643    
2644     _mouseStop: function(event) {
2645    
2646     this.resizing = false;
2647     var pr, ista, soffseth, soffsetw, s, left, top,
2648     o = this.options, that = this;
2649    
2650     if(this._helper) {
2651    
2652     pr = this._proportionallyResizeElements;
2653     ista = pr.length && (/textarea/i).test(pr[0].nodeName);
2654     soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2655     soffsetw = ista ? 0 : that.sizeDiff.width;
2656    
2657     s = { width: (that.helper.width() - soffsetw), height: (that.helper.height() - soffseth) };
2658     left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2659     top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2660    
2661     if (!o.animate) {
2662     this.element.css($.extend(s, { top: top, left: left }));
2663     }
2664    
2665     that.helper.height(that.size.height);
2666     that.helper.width(that.size.width);
2667    
2668     if (this._helper && !o.animate) {
2669     this._proportionallyResize();
2670     }
2671     }
2672    
2673     $("body").css("cursor", "auto");
2674    
2675     this.element.removeClass("ui-resizable-resizing");
2676    
2677     this._propagate("stop", event);
2678    
2679     if (this._helper) {
2680     this.helper.remove();
2681     }
2682    
2683     return false;
2684    
2685     },
2686    
2687     _updateVirtualBoundaries: function(forceAspectRatio) {
2688     var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
2689     o = this.options;
2690    
2691     b = {
2692     minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
2693     maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
2694     minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
2695     maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
2696     };
2697    
2698     if(this._aspectRatio || forceAspectRatio) {
2699     // We want to create an enclosing box whose aspect ration is the requested one
2700     // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2701     pMinWidth = b.minHeight * this.aspectRatio;
2702     pMinHeight = b.minWidth / this.aspectRatio;
2703     pMaxWidth = b.maxHeight * this.aspectRatio;
2704     pMaxHeight = b.maxWidth / this.aspectRatio;
2705    
2706     if(pMinWidth > b.minWidth) {
2707     b.minWidth = pMinWidth;
2708     }
2709     if(pMinHeight > b.minHeight) {
2710     b.minHeight = pMinHeight;
2711     }
2712     if(pMaxWidth < b.maxWidth) {
2713     b.maxWidth = pMaxWidth;
2714     }
2715     if(pMaxHeight < b.maxHeight) {
2716     b.maxHeight = pMaxHeight;
2717     }
2718     }
2719     this._vBoundaries = b;
2720     },
2721    
2722     _updateCache: function(data) {
2723     this.offset = this.helper.offset();
2724     if (isNumber(data.left)) {
2725     this.position.left = data.left;
2726     }
2727     if (isNumber(data.top)) {
2728     this.position.top = data.top;
2729     }
2730     if (isNumber(data.height)) {
2731     this.size.height = data.height;
2732     }
2733     if (isNumber(data.width)) {
2734     this.size.width = data.width;
2735     }
2736     },
2737    
2738     _updateRatio: function( data ) {
2739    
2740     var cpos = this.position,
2741     csize = this.size,
2742     a = this.axis;
2743    
2744     if (isNumber(data.height)) {
2745     data.width = (data.height * this.aspectRatio);
2746     } else if (isNumber(data.width)) {
2747     data.height = (data.width / this.aspectRatio);
2748     }
2749    
2750     if (a === "sw") {
2751     data.left = cpos.left + (csize.width - data.width);
2752     data.top = null;
2753     }
2754     if (a === "nw") {
2755     data.top = cpos.top + (csize.height - data.height);
2756     data.left = cpos.left + (csize.width - data.width);
2757     }
2758    
2759     return data;
2760     },
2761    
2762     _respectSize: function( data ) {
2763    
2764     var o = this._vBoundaries,
2765     a = this.axis,
2766     ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2767     isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2768     dw = this.originalPosition.left + this.originalSize.width,
2769     dh = this.position.top + this.size.height,
2770     cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2771     if (isminw) {
2772     data.width = o.minWidth;
2773     }
2774     if (isminh) {
2775     data.height = o.minHeight;
2776     }
2777     if (ismaxw) {
2778     data.width = o.maxWidth;
2779     }
2780     if (ismaxh) {
2781     data.height = o.maxHeight;
2782     }
2783    
2784     if (isminw && cw) {
2785     data.left = dw - o.minWidth;
2786     }
2787     if (ismaxw && cw) {
2788     data.left = dw - o.maxWidth;
2789     }
2790     if (isminh && ch) {
2791     data.top = dh - o.minHeight;
2792     }
2793     if (ismaxh && ch) {
2794     data.top = dh - o.maxHeight;
2795     }
2796    
2797     // fixing jump error on top/left - bug #2330
2798     if (!data.width && !data.height && !data.left && data.top) {
2799     data.top = null;
2800     } else if (!data.width && !data.height && !data.top && data.left) {
2801     data.left = null;
2802     }
2803    
2804     return data;
2805     },
2806    
2807     _proportionallyResize: function() {
2808    
2809     if (!this._proportionallyResizeElements.length) {
2810     return;
2811     }
2812    
2813     var i, j, borders, paddings, prel,
2814     element = this.helper || this.element;
2815    
2816     for ( i=0; i < this._proportionallyResizeElements.length; i++) {
2817    
2818     prel = this._proportionallyResizeElements[i];
2819    
2820     if (!this.borderDif) {
2821     this.borderDif = [];
2822     borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2823     paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2824    
2825     for ( j = 0; j < borders.length; j++ ) {
2826     this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2827     }
2828     }
2829    
2830     prel.css({
2831     height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2832     width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2833     });
2834    
2835     }
2836    
2837     },
2838    
2839     _renderProxy: function() {
2840    
2841     var el = this.element, o = this.options;
2842     this.elementOffset = el.offset();
2843    
2844     if(this._helper) {
2845    
2846     this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
2847    
2848     this.helper.addClass(this._helper).css({
2849     width: this.element.outerWidth() - 1,
2850     height: this.element.outerHeight() - 1,
2851     position: "absolute",
2852     left: this.elementOffset.left +"px",
2853     top: this.elementOffset.top +"px",
2854     zIndex: ++o.zIndex //TODO: Don't modify option
2855     });
2856    
2857     this.helper
2858     .appendTo("body")
2859     .disableSelection();
2860    
2861     } else {
2862     this.helper = this.element;
2863     }
2864    
2865     },
2866    
2867     _change: {
2868     e: function(event, dx) {
2869     return { width: this.originalSize.width + dx };
2870     },
2871     w: function(event, dx) {
2872     var cs = this.originalSize, sp = this.originalPosition;
2873     return { left: sp.left + dx, width: cs.width - dx };
2874     },
2875     n: function(event, dx, dy) {
2876     var cs = this.originalSize, sp = this.originalPosition;
2877     return { top: sp.top + dy, height: cs.height - dy };
2878     },
2879     s: function(event, dx, dy) {
2880     return { height: this.originalSize.height + dy };
2881     },
2882     se: function(event, dx, dy) {
2883     return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2884     },
2885     sw: function(event, dx, dy) {
2886     return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2887     },
2888     ne: function(event, dx, dy) {
2889     return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2890     },
2891     nw: function(event, dx, dy) {
2892     return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2893     }
2894     },
2895    
2896     _propagate: function(n, event) {
2897     $.ui.plugin.call(this, n, [event, this.ui()]);
2898     (n !== "resize" && this._trigger(n, event, this.ui()));
2899     },
2900    
2901     plugins: {},
2902    
2903     ui: function() {
2904     return {
2905     originalElement: this.originalElement,
2906     element: this.element,
2907     helper: this.helper,
2908     position: this.position,
2909     size: this.size,
2910     originalSize: this.originalSize,
2911     originalPosition: this.originalPosition
2912     };
2913     }
2914    
2915     });
2916    
2917     /*
2918     * Resizable Extensions
2919     */
2920    
2921     $.ui.plugin.add("resizable", "animate", {
2922    
2923     stop: function( event ) {
2924     var that = $(this).data("ui-resizable"),
2925     o = that.options,
2926     pr = that._proportionallyResizeElements,
2927     ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2928     soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2929     soffsetw = ista ? 0 : that.sizeDiff.width,
2930     style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
2931     left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2932     top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2933    
2934     that.element.animate(
2935     $.extend(style, top && left ? { top: top, left: left } : {}), {
2936     duration: o.animateDuration,
2937     easing: o.animateEasing,
2938     step: function() {
2939    
2940     var data = {
2941     width: parseInt(that.element.css("width"), 10),
2942     height: parseInt(that.element.css("height"), 10),
2943     top: parseInt(that.element.css("top"), 10),
2944     left: parseInt(that.element.css("left"), 10)
2945     };
2946    
2947     if (pr && pr.length) {
2948     $(pr[0]).css({ width: data.width, height: data.height });
2949     }
2950    
2951     // propagating resize, and updating values for each animation step
2952     that._updateCache(data);
2953     that._propagate("resize", event);
2954    
2955     }
2956     }
2957     );
2958     }
2959    
2960     });
2961    
2962     $.ui.plugin.add("resizable", "containment", {
2963    
2964     start: function() {
2965     var element, p, co, ch, cw, width, height,
2966     that = $(this).data("ui-resizable"),
2967     o = that.options,
2968     el = that.element,
2969     oc = o.containment,
2970     ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
2971    
2972     if (!ce) {
2973     return;
2974     }
2975    
2976     that.containerElement = $(ce);
2977    
2978     if (/document/.test(oc) || oc === document) {
2979     that.containerOffset = { left: 0, top: 0 };
2980     that.containerPosition = { left: 0, top: 0 };
2981    
2982     that.parentData = {
2983     element: $(document), left: 0, top: 0,
2984     width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
2985     };
2986     }
2987    
2988     // i'm a node, so compute top, left, right, bottom
2989     else {
2990     element = $(ce);
2991     p = [];
2992     $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
2993    
2994     that.containerOffset = element.offset();
2995     that.containerPosition = element.position();
2996     that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
2997    
2998     co = that.containerOffset;
2999     ch = that.containerSize.height;
3000     cw = that.containerSize.width;
3001     width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
3002     height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
3003    
3004     that.parentData = {
3005     element: ce, left: co.left, top: co.top, width: width, height: height
3006     };
3007     }
3008     },
3009    
3010     resize: function( event ) {
3011     var woset, hoset, isParent, isOffsetRelative,
3012     that = $(this).data("ui-resizable"),
3013     o = that.options,
3014     co = that.containerOffset, cp = that.position,
3015     pRatio = that._aspectRatio || event.shiftKey,
3016     cop = { top:0, left:0 }, ce = that.containerElement;
3017    
3018     if (ce[0] !== document && (/static/).test(ce.css("position"))) {
3019     cop = co;
3020     }
3021    
3022     if (cp.left < (that._helper ? co.left : 0)) {
3023     that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
3024     if (pRatio) {
3025     that.size.height = that.size.width / that.aspectRatio;
3026     }
3027     that.position.left = o.helper ? co.left : 0;
3028     }
3029    
3030     if (cp.top < (that._helper ? co.top : 0)) {
3031     that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
3032     if (pRatio) {
3033     that.size.width = that.size.height * that.aspectRatio;
3034     }
3035     that.position.top = that._helper ? co.top : 0;
3036     }
3037    
3038     that.offset.left = that.parentData.left+that.position.left;
3039     that.offset.top = that.parentData.top+that.position.top;
3040    
3041     woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
3042     hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
3043    
3044     isParent = that.containerElement.get(0) === that.element.parent().get(0);
3045     isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
3046    
3047     if(isParent && isOffsetRelative) {
3048     woset -= that.parentData.left;
3049     }
3050    
3051     if (woset + that.size.width >= that.parentData.width) {
3052     that.size.width = that.parentData.width - woset;
3053     if (pRatio) {
3054     that.size.height = that.size.width / that.aspectRatio;
3055     }
3056     }
3057    
3058     if (hoset + that.size.height >= that.parentData.height) {
3059     that.size.height = that.parentData.height - hoset;
3060     if (pRatio) {
3061     that.size.width = that.size.height * that.aspectRatio;
3062     }
3063     }
3064     },
3065    
3066     stop: function(){
3067     var that = $(this).data("ui-resizable"),
3068     o = that.options,
3069     co = that.containerOffset,
3070     cop = that.containerPosition,
3071     ce = that.containerElement,
3072     helper = $(that.helper),
3073     ho = helper.offset(),
3074     w = helper.outerWidth() - that.sizeDiff.width,
3075     h = helper.outerHeight() - that.sizeDiff.height;
3076    
3077     if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
3078     $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3079     }
3080    
3081     if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
3082     $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3083     }
3084    
3085     }
3086     });
3087    
3088     $.ui.plugin.add("resizable", "alsoResize", {
3089    
3090     start: function () {
3091     var that = $(this).data("ui-resizable"),
3092     o = that.options,
3093     _store = function (exp) {
3094     $(exp).each(function() {
3095     var el = $(this);
3096     el.data("ui-resizable-alsoresize", {
3097     width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
3098     left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
3099     });
3100     });
3101     };
3102    
3103     if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
3104     if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
3105     else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
3106     }else{
3107     _store(o.alsoResize);
3108     }
3109     },
3110    
3111     resize: function (event, ui) {
3112     var that = $(this).data("ui-resizable"),
3113     o = that.options,
3114     os = that.originalSize,
3115     op = that.originalPosition,
3116     delta = {
3117     height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
3118     top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
3119     },
3120    
3121     _alsoResize = function (exp, c) {
3122     $(exp).each(function() {
3123     var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
3124     css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
3125    
3126     $.each(css, function (i, prop) {
3127     var sum = (start[prop]||0) + (delta[prop]||0);
3128     if (sum && sum >= 0) {
3129     style[prop] = sum || null;
3130     }
3131     });
3132    
3133     el.css(style);
3134     });
3135     };
3136    
3137     if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
3138     $.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
3139     }else{
3140     _alsoResize(o.alsoResize);
3141     }
3142     },
3143    
3144     stop: function () {
3145     $(this).removeData("resizable-alsoresize");
3146     }
3147     });
3148    
3149     $.ui.plugin.add("resizable", "ghost", {
3150    
3151     start: function() {
3152    
3153     var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
3154    
3155     that.ghost = that.originalElement.clone();
3156     that.ghost
3157     .css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
3158     .addClass("ui-resizable-ghost")
3159     .addClass(typeof o.ghost === "string" ? o.ghost : "");
3160    
3161     that.ghost.appendTo(that.helper);
3162    
3163     },
3164    
3165     resize: function(){
3166     var that = $(this).data("ui-resizable");
3167     if (that.ghost) {
3168     that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
3169     }
3170     },
3171    
3172     stop: function() {
3173     var that = $(this).data("ui-resizable");
3174     if (that.ghost && that.helper) {
3175     that.helper.get(0).removeChild(that.ghost.get(0));
3176     }
3177     }
3178    
3179     });
3180    
3181     $.ui.plugin.add("resizable", "grid", {
3182    
3183     resize: function() {
3184     var that = $(this).data("ui-resizable"),
3185     o = that.options,
3186     cs = that.size,
3187     os = that.originalSize,
3188     op = that.originalPosition,
3189     a = that.axis,
3190     grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
3191     gridX = (grid[0]||1),
3192     gridY = (grid[1]||1),
3193     ox = Math.round((cs.width - os.width) / gridX) * gridX,
3194     oy = Math.round((cs.height - os.height) / gridY) * gridY,
3195     newWidth = os.width + ox,
3196     newHeight = os.height + oy,
3197     isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
3198     isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
3199     isMinWidth = o.minWidth && (o.minWidth > newWidth),
3200     isMinHeight = o.minHeight && (o.minHeight > newHeight);
3201    
3202     o.grid = grid;
3203    
3204     if (isMinWidth) {
3205     newWidth = newWidth + gridX;
3206     }
3207     if (isMinHeight) {
3208     newHeight = newHeight + gridY;
3209     }
3210     if (isMaxWidth) {
3211     newWidth = newWidth - gridX;
3212     }
3213     if (isMaxHeight) {
3214     newHeight = newHeight - gridY;
3215     }
3216    
3217     if (/^(se|s|e)$/.test(a)) {
3218     that.size.width = newWidth;
3219     that.size.height = newHeight;
3220     } else if (/^(ne)$/.test(a)) {
3221     that.size.width = newWidth;
3222     that.size.height = newHeight;
3223     that.position.top = op.top - oy;
3224     } else if (/^(sw)$/.test(a)) {
3225     that.size.width = newWidth;
3226     that.size.height = newHeight;
3227     that.position.left = op.left - ox;
3228     } else {
3229     that.size.width = newWidth;
3230     that.size.height = newHeight;
3231     that.position.top = op.top - oy;
3232     that.position.left = op.left - ox;
3233     }
3234     }
3235    
3236     });
3237    
3238     })(jQuery);
3239    
3240     (function( $, undefined ) {
3241    
3242     $.widget("ui.selectable", $.ui.mouse, {
3243     version: "1.10.3",
3244     options: {
3245     appendTo: "body",
3246     autoRefresh: true,
3247     distance: 0,
3248     filter: "*",
3249     tolerance: "touch",
3250    
3251     // callbacks
3252     selected: null,
3253     selecting: null,
3254     start: null,
3255     stop: null,
3256     unselected: null,
3257     unselecting: null
3258     },
3259     _create: function() {
3260     var selectees,
3261     that = this;
3262    
3263     this.element.addClass("ui-selectable");
3264    
3265     this.dragged = false;
3266    
3267     // cache selectee children based on filter
3268     this.refresh = function() {
3269     selectees = $(that.options.filter, that.element[0]);
3270     selectees.addClass("ui-selectee");
3271     selectees.each(function() {
3272     var $this = $(this),
3273     pos = $this.offset();
3274     $.data(this, "selectable-item", {
3275     element: this,
3276     $element: $this,
3277     left: pos.left,
3278     top: pos.top,
3279     right: pos.left + $this.outerWidth(),
3280     bottom: pos.top + $this.outerHeight(),
3281     startselected: false,
3282     selected: $this.hasClass("ui-selected"),
3283     selecting: $this.hasClass("ui-selecting"),
3284     unselecting: $this.hasClass("ui-unselecting")
3285     });
3286     });
3287     };
3288     this.refresh();
3289    
3290     this.selectees = selectees.addClass("ui-selectee");
3291    
3292     this._mouseInit();
3293    
3294     this.helper = $("<div class='ui-selectable-helper'></div>");
3295     },
3296    
3297     _destroy: function() {
3298     this.selectees
3299     .removeClass("ui-selectee")
3300     .removeData("selectable-item");
3301     this.element
3302     .removeClass("ui-selectable ui-selectable-disabled");
3303     this._mouseDestroy();
3304     },
3305    
3306     _mouseStart: function(event) {
3307     var that = this,
3308     options = this.options;
3309    
3310     this.opos = [event.pageX, event.pageY];
3311    
3312     if (this.options.disabled) {
3313     return;
3314     }
3315    
3316     this.selectees = $(options.filter, this.element[0]);
3317    
3318     this._trigger("start", event);
3319    
3320     $(options.appendTo).append(this.helper);
3321     // position helper (lasso)
3322     this.helper.css({
3323     "left": event.pageX,
3324     "top": event.pageY,
3325     "width": 0,
3326     "height": 0
3327     });
3328    
3329     if (options.autoRefresh) {
3330     this.refresh();
3331     }
3332    
3333     this.selectees.filter(".ui-selected").each(function() {
3334     var selectee = $.data(this, "selectable-item");
3335     selectee.startselected = true;
3336     if (!event.metaKey && !event.ctrlKey) {
3337     selectee.$element.removeClass("ui-selected");
3338     selectee.selected = false;
3339     selectee.$element.addClass("ui-unselecting");
3340     selectee.unselecting = true;
3341     // selectable UNSELECTING callback
3342     that._trigger("unselecting", event, {
3343     unselecting: selectee.element
3344     });
3345     }
3346     });
3347    
3348     $(event.target).parents().addBack().each(function() {
3349     var doSelect,
3350     selectee = $.data(this, "selectable-item");
3351     if (selectee) {
3352     doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
3353     selectee.$element
3354     .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
3355     .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
3356     selectee.unselecting = !doSelect;
3357     selectee.selecting = doSelect;
3358     selectee.selected = doSelect;
3359     // selectable (UN)SELECTING callback
3360     if (doSelect) {
3361     that._trigger("selecting", event, {
3362     selecting: selectee.element
3363     });
3364     } else {
3365     that._trigger("unselecting", event, {
3366     unselecting: selectee.element
3367     });
3368     }
3369     return false;
3370     }
3371     });
3372    
3373     },
3374    
3375     _mouseDrag: function(event) {
3376    
3377     this.dragged = true;
3378    
3379     if (this.options.disabled) {
3380     return;
3381     }
3382    
3383     var tmp,
3384     that = this,
3385     options = this.options,
3386     x1 = this.opos[0],
3387     y1 = this.opos[1],
3388     x2 = event.pageX,
3389     y2 = event.pageY;
3390    
3391     if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
3392     if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
3393     this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
3394    
3395     this.selectees.each(function() {
3396     var selectee = $.data(this, "selectable-item"),
3397     hit = false;
3398    
3399     //prevent helper from being selected if appendTo: selectable
3400     if (!selectee || selectee.element === that.element[0]) {
3401     return;
3402     }
3403    
3404     if (options.tolerance === "touch") {
3405     hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
3406     } else if (options.tolerance === "fit") {
3407     hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
3408     }
3409    
3410     if (hit) {
3411     // SELECT
3412     if (selectee.selected) {
3413     selectee.$element.removeClass("ui-selected");
3414     selectee.selected = false;
3415     }
3416     if (selectee.unselecting) {
3417     selectee.$element.removeClass("ui-unselecting");
3418     selectee.unselecting = false;
3419     }
3420     if (!selectee.selecting) {
3421     selectee.$element.addClass("ui-selecting");
3422     selectee.selecting = true;
3423     // selectable SELECTING callback
3424     that._trigger("selecting", event, {
3425     selecting: selectee.element
3426     });
3427     }
3428     } else {
3429     // UNSELECT
3430     if (selectee.selecting) {
3431     if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
3432     selectee.$element.removeClass("ui-selecting");
3433     selectee.selecting = false;
3434     selectee.$element.addClass("ui-selected");
3435     selectee.selected = true;
3436     } else {
3437     selectee.$element.removeClass("ui-selecting");
3438     selectee.selecting = false;
3439     if (selectee.startselected) {
3440     selectee.$element.addClass("ui-unselecting");
3441     selectee.unselecting = true;
3442     }
3443     // selectable UNSELECTING callback
3444     that._trigger("unselecting", event, {
3445     unselecting: selectee.element
3446     });
3447     }
3448     }
3449     if (selectee.selected) {
3450     if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
3451     selectee.$element.removeClass("ui-selected");
3452     selectee.selected = false;
3453    
3454     selectee.$element.addClass("ui-unselecting");
3455     selectee.unselecting = true;
3456     // selectable UNSELECTING callback
3457     that._trigger("unselecting", event, {
3458     unselecting: selectee.element
3459     });
3460     }
3461     }
3462     }
3463     });
3464    
3465     return false;
3466     },
3467    
3468     _mouseStop: function(event) {
3469     var that = this;
3470    
3471     this.dragged = false;
3472    
3473     $(".ui-unselecting", this.element[0]).each(function() {
3474     var selectee = $.data(this, "selectable-item");
3475     selectee.$element.removeClass("ui-unselecting");
3476     selectee.unselecting = false;
3477     selectee.startselected = false;
3478     that._trigger("unselected", event, {
3479     unselected: selectee.element
3480     });
3481     });
3482     $(".ui-selecting", this.element[0]).each(function() {
3483     var selectee = $.data(this, "selectable-item");
3484     selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
3485     selectee.selecting = false;
3486     selectee.selected = true;
3487     selectee.startselected = true;
3488     that._trigger("selected", event, {
3489     selected: selectee.element
3490     });
3491     });
3492     this._trigger("stop", event);
3493    
3494     this.helper.remove();
3495    
3496     return false;
3497     }
3498    
3499     });
3500    
3501     })(jQuery);
3502    
3503     (function( $, undefined ) {
3504    
3505     /*jshint loopfunc: true */
3506    
3507     function isOverAxis( x, reference, size ) {
3508     return ( x > reference ) && ( x < ( reference + size ) );
3509     }
3510    
3511     function isFloating(item) {
3512     return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
3513     }
3514    
3515     $.widget("ui.sortable", $.ui.mouse, {
3516     version: "1.10.3",
3517     widgetEventPrefix: "sort",
3518     ready: false,
3519     options: {
3520     appendTo: "parent",
3521     axis: false,
3522     connectWith: false,
3523     containment: false,
3524     cursor: "auto",
3525     cursorAt: false,
3526     dropOnEmpty: true,
3527     forcePlaceholderSize: false,
3528     forceHelperSize: false,
3529     grid: false,
3530     handle: false,
3531     helper: "original",
3532     items: "> *",
3533     opacity: false,
3534     placeholder: false,
3535     revert: false,
3536     scroll: true,
3537     scrollSensitivity: 20,
3538     scrollSpeed: 20,
3539     scope: "default",
3540     tolerance: "intersect",
3541     zIndex: 1000,
3542    
3543     // callbacks
3544     activate: null,
3545     beforeStop: null,
3546     change: null,
3547     deactivate: null,
3548     out: null,
3549     over: null,
3550     receive: null,
3551     remove: null,
3552     sort: null,
3553     start: null,
3554     stop: null,
3555     update: null
3556     },
3557     _create: function() {
3558    
3559     var o = this.options;
3560     this.containerCache = {};
3561     this.element.addClass("ui-sortable");
3562    
3563     //Get the items
3564     this.refresh();
3565    
3566     //Let's determine if the items are being displayed horizontally
3567     this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
3568    
3569     //Let's determine the parent's offset
3570     this.offset = this.element.offset();
3571    
3572     //Initialize mouse events for interaction
3573     this._mouseInit();
3574    
3575     //We're ready to go
3576     this.ready = true;
3577    
3578     },
3579    
3580     _destroy: function() {
3581     this.element
3582     .removeClass("ui-sortable ui-sortable-disabled");
3583     this._mouseDestroy();
3584    
3585     for ( var i = this.items.length - 1; i >= 0; i-- ) {
3586     this.items[i].item.removeData(this.widgetName + "-item");
3587     }
3588    
3589     return this;
3590     },
3591    
3592     _setOption: function(key, value){
3593     if ( key === "disabled" ) {
3594     this.options[ key ] = value;
3595    
3596     this.widget().toggleClass( "ui-sortable-disabled", !!value );
3597     } else {
3598     // Don't call widget base _setOption for disable as it adds ui-state-disabled class
3599     $.Widget.prototype._setOption.apply(this, arguments);
3600     }
3601     },
3602    
3603     _mouseCapture: function(event, overrideHandle) {
3604     var currentItem = null,
3605     validHandle = false,
3606     that = this;
3607    
3608     if (this.reverting) {
3609     return false;
3610     }
3611    
3612     if(this.options.disabled || this.options.type === "static") {
3613     return false;
3614     }
3615    
3616     //We have to refresh the items data once first
3617     this._refreshItems(event);
3618    
3619     //Find out if the clicked node (or one of its parents) is a actual item in this.items
3620     $(event.target).parents().each(function() {
3621     if($.data(this, that.widgetName + "-item") === that) {
3622     currentItem = $(this);
3623     return false;
3624     }
3625     });
3626     if($.data(event.target, that.widgetName + "-item") === that) {
3627     currentItem = $(event.target);
3628     }
3629    
3630     if(!currentItem) {
3631     return false;
3632     }
3633     if(this.options.handle && !overrideHandle) {
3634     $(this.options.handle, currentItem).find("*").addBack().each(function() {
3635     if(this === event.target) {
3636     validHandle = true;
3637     }
3638     });
3639     if(!validHandle) {
3640     return false;
3641     }
3642     }
3643    
3644     this.currentItem = currentItem;
3645     this._removeCurrentsFromItems();
3646     return true;
3647    
3648     },
3649    
3650     _mouseStart: function(event, overrideHandle, noActivation) {
3651    
3652     var i, body,
3653     o = this.options;
3654    
3655     this.currentContainer = this;
3656    
3657     //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
3658     this.refreshPositions();
3659    
3660     //Create and append the visible helper
3661     this.helper = this._createHelper(event);
3662    
3663     //Cache the helper size
3664     this._cacheHelperProportions();
3665    
3666     /*
3667     * - Position generation -
3668     * This block generates everything position related - it's the core of draggables.
3669     */
3670    
3671     //Cache the margins of the original element
3672     this._cacheMargins();
3673    
3674     //Get the next scrolling parent
3675     this.scrollParent = this.helper.scrollParent();
3676    
3677     //The element's absolute position on the page minus margins
3678     this.offset = this.currentItem.offset();
3679     this.offset = {
3680     top: this.offset.top - this.margins.top,
3681     left: this.offset.left - this.margins.left
3682     };
3683    
3684     $.extend(this.offset, {
3685     click: { //Where the click happened, relative to the element
3686     left: event.pageX - this.offset.left,
3687     top: event.pageY - this.offset.top
3688     },
3689     parent: this._getParentOffset(),
3690     relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
3691     });
3692    
3693     // Only after we got the offset, we can change the helper's position to absolute
3694     // TODO: Still need to figure out a way to make relative sorting possible
3695     this.helper.css("position", "absolute");
3696     this.cssPosition = this.helper.css("position");
3697    
3698     //Generate the original position
3699     this.originalPosition = this._generatePosition(event);
3700     this.originalPageX = event.pageX;
3701     this.originalPageY = event.pageY;
3702    
3703     //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
3704     (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
3705    
3706     //Cache the former DOM position
3707     this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
3708    
3709     //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
3710     if(this.helper[0] !== this.currentItem[0]) {
3711     this.currentItem.hide();
3712     }
3713    
3714     //Create the placeholder
3715     this._createPlaceholder();
3716    
3717     //Set a containment if given in the options
3718     if(o.containment) {
3719     this._setContainment();
3720     }
3721    
3722     if( o.cursor && o.cursor !== "auto" ) { // cursor option
3723     body = this.document.find( "body" );
3724    
3725     // support: IE
3726     this.storedCursor = body.css( "cursor" );
3727     body.css( "cursor", o.cursor );
3728    
3729     this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
3730     }
3731    
3732     if(o.opacity) { // opacity option
3733     if (this.helper.css("opacity")) {
3734     this._storedOpacity = this.helper.css("opacity");
3735     }
3736     this.helper.css("opacity", o.opacity);
3737     }
3738    
3739     if(o.zIndex) { // zIndex option
3740     if (this.helper.css("zIndex")) {
3741     this._storedZIndex = this.helper.css("zIndex");
3742     }
3743     this.helper.css("zIndex", o.zIndex);
3744     }
3745    
3746     //Prepare scrolling
3747     if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
3748     this.overflowOffset = this.scrollParent.offset();
3749     }
3750    
3751     //Call callbacks
3752     this._trigger("start", event, this._uiHash());
3753    
3754     //Recache the helper size
3755     if(!this._preserveHelperProportions) {
3756     this._cacheHelperProportions();
3757     }
3758    
3759    
3760     //Post "activate" events to possible containers
3761     if( !noActivation ) {
3762     for ( i = this.containers.length - 1; i >= 0; i-- ) {
3763     this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
3764     }
3765     }
3766    
3767     //Prepare possible droppables
3768     if($.ui.ddmanager) {
3769     $.ui.ddmanager.current = this;
3770     }
3771    
3772     if ($.ui.ddmanager && !o.dropBehaviour) {
3773     $.ui.ddmanager.prepareOffsets(this, event);
3774     }
3775    
3776     this.dragging = true;
3777    
3778     this.helper.addClass("ui-sortable-helper");
3779     this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
3780     return true;
3781    
3782     },
3783    
3784     _mouseDrag: function(event) {
3785     var i, item, itemElement, intersection,
3786     o = this.options,
3787     scrolled = false;
3788    
3789     //Compute the helpers position
3790     this.position = this._generatePosition(event);
3791     this.positionAbs = this._convertPositionTo("absolute");
3792    
3793     if (!this.lastPositionAbs) {
3794     this.lastPositionAbs = this.positionAbs;
3795     }
3796    
3797     //Do scrolling
3798     if(this.options.scroll) {
3799     if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
3800    
3801     if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
3802     this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
3803     } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
3804     this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
3805     }
3806    
3807     if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
3808     this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
3809     } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
3810     this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
3811     }
3812    
3813     } else {
3814    
3815     if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
3816     scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
3817     } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
3818     scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
3819     }
3820    
3821     if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
3822     scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
3823     } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
3824     scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
3825     }
3826    
3827     }
3828    
3829     if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
3830     $.ui.ddmanager.prepareOffsets(this, event);
3831     }
3832     }
3833    
3834     //Regenerate the absolute position used for position checks
3835     this.positionAbs = this._convertPositionTo("absolute");
3836    
3837     //Set the helper position
3838     if(!this.options.axis || this.options.axis !== "y") {
3839     this.helper[0].style.left = this.position.left+"px";
3840     }
3841     if(!this.options.axis || this.options.axis !== "x") {
3842     this.helper[0].style.top = this.position.top+"px";
3843     }
3844    
3845     //Rearrange
3846     for (i = this.items.length - 1; i >= 0; i--) {
3847    
3848     //Cache variables and intersection, continue if no intersection
3849     item = this.items[i];
3850     itemElement = item.item[0];
3851     intersection = this._intersectsWithPointer(item);
3852     if (!intersection) {
3853     continue;
3854     }
3855    
3856     // Only put the placeholder inside the current Container, skip all
3857     // items form other containers. This works because when moving
3858     // an item from one container to another the
3859     // currentContainer is switched before the placeholder is moved.
3860     //
3861     // Without this moving items in "sub-sortables" can cause the placeholder to jitter
3862     // beetween the outer and inner container.
3863     if (item.instance !== this.currentContainer) {
3864     continue;
3865     }
3866    
3867     // cannot intersect with itself
3868     // no useless actions that have been done before
3869     // no action if the item moved is the parent of the item checked
3870     if (itemElement !== this.currentItem[0] &&
3871     this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
3872     !$.contains(this.placeholder[0], itemElement) &&
3873     (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
3874     ) {
3875    
3876     this.direction = intersection === 1 ? "down" : "up";
3877    
3878     if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
3879     this._rearrange(event, item);
3880     } else {
3881     break;
3882     }
3883    
3884     this._trigger("change", event, this._uiHash());
3885     break;
3886     }
3887     }
3888    
3889     //Post events to containers
3890     this._contactContainers(event);
3891    
3892     //Interconnect with droppables
3893     if($.ui.ddmanager) {
3894     $.ui.ddmanager.drag(this, event);
3895     }
3896    
3897     //Call callbacks
3898     this._trigger("sort", event, this._uiHash());
3899    
3900     this.lastPositionAbs = this.positionAbs;
3901     return false;
3902    
3903     },
3904    
3905     _mouseStop: function(event, noPropagation) {
3906    
3907     if(!event) {
3908     return;
3909     }
3910    
3911     //If we are using droppables, inform the manager about the drop
3912     if ($.ui.ddmanager && !this.options.dropBehaviour) {
3913     $.ui.ddmanager.drop(this, event);
3914     }
3915    
3916     if(this.options.revert) {
3917     var that = this,
3918     cur = this.placeholder.offset(),
3919     axis = this.options.axis,
3920     animation = {};
3921    
3922     if ( !axis || axis === "x" ) {
3923     animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
3924     }
3925     if ( !axis || axis === "y" ) {
3926     animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
3927     }
3928     this.reverting = true;
3929     $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
3930     that._clear(event);
3931     });
3932     } else {
3933     this._clear(event, noPropagation);
3934     }
3935    
3936     return false;
3937    
3938     },
3939    
3940     cancel: function() {
3941    
3942     if(this.dragging) {
3943    
3944     this._mouseUp({ target: null });
3945    
3946     if(this.options.helper === "original") {
3947     this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
3948     } else {
3949     this.currentItem.show();
3950     }
3951    
3952     //Post deactivating events to containers
3953     for (var i = this.containers.length - 1; i >= 0; i--){
3954     this.containers[i]._trigger("deactivate", null, this._uiHash(this));
3955     if(this.containers[i].containerCache.over) {
3956     this.containers[i]._trigger("out", null, this._uiHash(this));
3957     this.containers[i].containerCache.over = 0;
3958     }
3959     }
3960    
3961     }
3962    
3963     if (this.placeholder) {
3964     //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3965     if(this.placeholder[0].parentNode) {
3966     this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
3967     }
3968     if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
3969     this.helper.remove();
3970     }
3971    
3972     $.extend(this, {
3973     helper: null,
3974     dragging: false,
3975     reverting: false,
3976     _noFinalSort: null
3977     });
3978    
3979     if(this.domPosition.prev) {
3980     $(this.domPosition.prev).after(this.currentItem);
3981     } else {
3982     $(this.domPosition.parent).prepend(this.currentItem);
3983     }
3984     }
3985    
3986     return this;
3987    
3988     },
3989    
3990     serialize: function(o) {
3991    
3992     var items = this._getItemsAsjQuery(o && o.connected),
3993     str = [];
3994     o = o || {};
3995    
3996     $(items).each(function() {
3997     var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
3998     if (res) {
3999     str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
4000     }
4001     });
4002    
4003     if(!str.length && o.key) {
4004     str.push(o.key + "=");
4005     }
4006    
4007     return str.join("&");
4008    
4009     },
4010    
4011     toArray: function(o) {
4012    
4013     var items = this._getItemsAsjQuery(o && o.connected),
4014     ret = [];
4015    
4016     o = o || {};
4017    
4018     items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
4019     return ret;
4020    
4021     },
4022    
4023     /* Be careful with the following core functions */
4024     _intersectsWith: function(item) {
4025    
4026     var x1 = this.positionAbs.left,
4027     x2 = x1 + this.helperProportions.width,
4028     y1 = this.positionAbs.top,
4029     y2 = y1 + this.helperProportions.height,
4030     l = item.left,
4031     r = l + item.width,
4032     t = item.top,
4033     b = t + item.height,
4034     dyClick = this.offset.click.top,
4035     dxClick = this.offset.click.left,
4036     isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
4037     isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
4038     isOverElement = isOverElementHeight && isOverElementWidth;
4039    
4040     if ( this.options.tolerance === "pointer" ||
4041     this.options.forcePointerForContainers ||
4042     (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
4043     ) {
4044     return isOverElement;
4045     } else {
4046    
4047     return (l < x1 + (this.helperProportions.width / 2) && // Right Half
4048     x2 - (this.helperProportions.width / 2) < r && // Left Half
4049     t < y1 + (this.helperProportions.height / 2) && // Bottom Half
4050     y2 - (this.helperProportions.height / 2) < b ); // Top Half
4051    
4052     }
4053     },
4054    
4055     _intersectsWithPointer: function(item) {
4056    
4057     var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
4058     isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
4059     isOverElement = isOverElementHeight && isOverElementWidth,
4060     verticalDirection = this._getDragVerticalDirection(),
4061     horizontalDirection = this._getDragHorizontalDirection();
4062    
4063     if (!isOverElement) {
4064     return false;
4065     }
4066    
4067     return this.floating ?
4068     ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
4069     : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
4070    
4071     },
4072    
4073     _intersectsWithSides: function(item) {
4074    
4075     var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
4076     isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
4077     verticalDirection = this._getDragVerticalDirection(),
4078     horizontalDirection = this._getDragHorizontalDirection();
4079    
4080     if (this.floating && horizontalDirection) {
4081     return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
4082     } else {
4083     return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
4084     }
4085    
4086     },
4087    
4088     _getDragVerticalDirection: function() {
4089     var delta = this.positionAbs.top - this.lastPositionAbs.top;
4090     return delta !== 0 && (delta > 0 ? "down" : "up");
4091     },
4092    
4093     _getDragHorizontalDirection: function() {
4094     var delta = this.positionAbs.left - this.lastPositionAbs.left;
4095     return delta !== 0 && (delta > 0 ? "right" : "left");
4096     },
4097    
4098     refresh: function(event) {
4099     this._refreshItems(event);
4100     this.refreshPositions();
4101     return this;
4102     },
4103    
4104     _connectWith: function() {
4105     var options = this.options;
4106     return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
4107     },
4108    
4109     _getItemsAsjQuery: function(connected) {
4110    
4111     var i, j, cur, inst,
4112     items = [],
4113     queries = [],
4114     connectWith = this._connectWith();
4115    
4116     if(connectWith && connected) {
4117     for (i = connectWith.length - 1; i >= 0; i--){
4118     cur = $(connectWith[i]);
4119     for ( j = cur.length - 1; j >= 0; j--){
4120     inst = $.data(cur[j], this.widgetFullName);
4121     if(inst && inst !== this && !inst.options.disabled) {
4122     queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
4123     }
4124     }
4125     }
4126     }
4127    
4128     queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
4129    
4130     for (i = queries.length - 1; i >= 0; i--){
4131     queries[i][0].each(function() {
4132     items.push(this);
4133     });
4134     }
4135    
4136     return $(items);
4137    
4138     },
4139    
4140     _removeCurrentsFromItems: function() {
4141    
4142     var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
4143    
4144     this.items = $.grep(this.items, function (item) {
4145     for (var j=0; j < list.length; j++) {
4146     if(list[j] === item.item[0]) {
4147     return false;
4148     }
4149     }
4150     return true;
4151     });
4152    
4153     },
4154    
4155     _refreshItems: function(event) {
4156    
4157     this.items = [];
4158     this.containers = [this];
4159    
4160     var i, j, cur, inst, targetData, _queries, item, queriesLength,
4161     items = this.items,
4162     queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
4163     connectWith = this._connectWith();
4164    
4165     if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
4166     for (i = connectWith.length - 1; i >= 0; i--){
4167     cur = $(connectWith[i]);
4168     for (j = cur.length - 1; j >= 0; j--){
4169     inst = $.data(cur[j], this.widgetFullName);
4170     if(inst && inst !== this && !inst.options.disabled) {
4171     queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
4172     this.containers.push(inst);
4173     }
4174     }
4175     }
4176     }
4177    
4178     for (i = queries.length - 1; i >= 0; i--) {
4179     targetData = queries[i][1];
4180     _queries = queries[i][0];
4181    
4182     for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
4183     item = $(_queries[j]);
4184    
4185     item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
4186    
4187     items.push({
4188     item: item,
4189     instance: targetData,
4190     width: 0, height: 0,
4191     left: 0, top: 0
4192     });
4193     }
4194     }
4195    
4196     },
4197    
4198     refreshPositions: function(fast) {
4199    
4200     //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
4201     if(this.offsetParent && this.helper) {
4202     this.offset.parent = this._getParentOffset();
4203     }
4204    
4205     var i, item, t, p;
4206    
4207     for (i = this.items.length - 1; i >= 0; i--){
4208     item = this.items[i];
4209    
4210     //We ignore calculating positions of all connected containers when we're not over them
4211     if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
4212     continue;
4213     }
4214    
4215     t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
4216    
4217     if (!fast) {
4218     item.width = t.outerWidth();
4219     item.height = t.outerHeight();
4220     }
4221    
4222     p = t.offset();
4223     item.left = p.left;
4224     item.top = p.top;
4225     }
4226    
4227     if(this.options.custom && this.options.custom.refreshContainers) {
4228     this.options.custom.refreshContainers.call(this);
4229     } else {
4230     for (i = this.containers.length - 1; i >= 0; i--){
4231     p = this.containers[i].element.offset();
4232     this.containers[i].containerCache.left = p.left;
4233     this.containers[i].containerCache.top = p.top;
4234     this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
4235     this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
4236     }
4237     }
4238    
4239     return this;
4240     },
4241    
4242     _createPlaceholder: function(that) {
4243     that = that || this;
4244     var className,
4245     o = that.options;
4246    
4247     if(!o.placeholder || o.placeholder.constructor === String) {
4248     className = o.placeholder;
4249     o.placeholder = {
4250     element: function() {
4251    
4252     var nodeName = that.currentItem[0].nodeName.toLowerCase(),
4253     element = $( "<" + nodeName + ">", that.document[0] )
4254     .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
4255     .removeClass("ui-sortable-helper");
4256    
4257     if ( nodeName === "tr" ) {
4258     that.currentItem.children().each(function() {
4259     $( "<td>&#160;</td>", that.document[0] )
4260     .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
4261     .appendTo( element );
4262     });
4263     } else if ( nodeName === "img" ) {
4264     element.attr( "src", that.currentItem.attr( "src" ) );
4265     }
4266    
4267     if ( !className ) {
4268     element.css( "visibility", "hidden" );
4269     }
4270    
4271     return element;
4272     },
4273     update: function(container, p) {
4274    
4275     // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
4276     // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
4277     if(className && !o.forcePlaceholderSize) {
4278     return;
4279     }
4280    
4281     //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
4282     if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
4283     if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
4284     }
4285     };
4286     }
4287    
4288     //Create the placeholder
4289     that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
4290    
4291     //Append it after the actual current item
4292     that.currentItem.after(that.placeholder);
4293    
4294     //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
4295     o.placeholder.update(that, that.placeholder);
4296    
4297     },
4298    
4299     _contactContainers: function(event) {
4300     var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
4301     innermostContainer = null,
4302     innermostIndex = null;
4303    
4304     // get innermost container that intersects with item
4305     for (i = this.containers.length - 1; i >= 0; i--) {
4306    
4307     // never consider a container that's located within the item itself
4308     if($.contains(this.currentItem[0], this.containers[i].element[0])) {
4309     continue;
4310     }
4311    
4312     if(this._intersectsWith(this.containers[i].containerCache)) {
4313    
4314     // if we've already found a container and it's more "inner" than this, then continue
4315     if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
4316     continue;
4317     }
4318    
4319     innermostContainer = this.containers[i];
4320     innermostIndex = i;
4321    
4322     } else {
4323     // container doesn't intersect. trigger "out" event if necessary
4324     if(this.containers[i].containerCache.over) {
4325     this.containers[i]._trigger("out", event, this._uiHash(this));
4326     this.containers[i].containerCache.over = 0;
4327     }
4328     }
4329    
4330     }
4331    
4332     // if no intersecting containers found, return
4333     if(!innermostContainer) {
4334     return;
4335     }
4336    
4337     // move the item into the container if it's not there already
4338     if(this.containers.length === 1) {
4339     if (!this.containers[innermostIndex].containerCache.over) {
4340     this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
4341     this.containers[innermostIndex].containerCache.over = 1;
4342     }
4343     } else {
4344    
4345     //When entering a new container, we will find the item with the least distance and append our item near it
4346     dist = 10000;
4347     itemWithLeastDistance = null;
4348     floating = innermostContainer.floating || isFloating(this.currentItem);
4349     posProperty = floating ? "left" : "top";
4350     sizeProperty = floating ? "width" : "height";
4351     base = this.positionAbs[posProperty] + this.offset.click[posProperty];
4352     for (j = this.items.length - 1; j >= 0; j--) {
4353     if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
4354     continue;
4355     }
4356     if(this.items[j].item[0] === this.currentItem[0]) {
4357     continue;
4358     }
4359     if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
4360     continue;
4361     }
4362     cur = this.items[j].item.offset()[posProperty];
4363     nearBottom = false;
4364     if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
4365     nearBottom = true;
4366     cur += this.items[j][sizeProperty];
4367     }
4368    
4369     if(Math.abs(cur - base) < dist) {
4370     dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
4371     this.direction = nearBottom ? "up": "down";
4372     }
4373     }
4374    
4375     //Check if dropOnEmpty is enabled
4376     if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
4377     return;
4378     }
4379    
4380     if(this.currentContainer === this.containers[innermostIndex]) {
4381     return;
4382     }
4383    
4384     itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
4385     this._trigger("change", event, this._uiHash());
4386     this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
4387     this.currentContainer = this.containers[innermostIndex];
4388    
4389     //Update the placeholder
4390     this.options.placeholder.update(this.currentContainer, this.placeholder);
4391    
4392     this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
4393     this.containers[innermostIndex].containerCache.over = 1;
4394     }
4395    
4396    
4397     },
4398    
4399     _createHelper: function(event) {
4400    
4401     var o = this.options,
4402     helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
4403    
4404     //Add the helper to the DOM if that didn't happen already
4405     if(!helper.parents("body").length) {
4406     $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
4407     }
4408    
4409     if(helper[0] === this.currentItem[0]) {
4410     this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
4411     }
4412    
4413     if(!helper[0].style.width || o.forceHelperSize) {
4414     helper.width(this.currentItem.width());
4415     }
4416     if(!helper[0].style.height || o.forceHelperSize) {
4417     helper.height(this.currentItem.height());
4418     }
4419    
4420     return helper;
4421    
4422     },
4423    
4424     _adjustOffsetFromHelper: function(obj) {
4425     if (typeof obj === "string") {
4426     obj = obj.split(" ");
4427     }
4428     if ($.isArray(obj)) {
4429     obj = {left: +obj[0], top: +obj[1] || 0};
4430     }
4431     if ("left" in obj) {
4432     this.offset.click.left = obj.left + this.margins.left;
4433     }
4434     if ("right" in obj) {
4435     this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
4436     }
4437     if ("top" in obj) {
4438     this.offset.click.top = obj.top + this.margins.top;
4439     }
4440     if ("bottom" in obj) {
4441     this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
4442     }
4443     },
4444    
4445     _getParentOffset: function() {
4446    
4447    
4448     //Get the offsetParent and cache its position
4449     this.offsetParent = this.helper.offsetParent();
4450     var po = this.offsetParent.offset();
4451    
4452     // This is a special case where we need to modify a offset calculated on start, since the following happened:
4453     // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
4454     // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
4455     // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
4456     if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
4457     po.left += this.scrollParent.scrollLeft();
4458     po.top += this.scrollParent.scrollTop();
4459     }
4460    
4461     // This needs to be actually done for all browsers, since pageX/pageY includes this information
4462     // with an ugly IE fix
4463     if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
4464     po = { top: 0, left: 0 };
4465     }
4466    
4467     return {
4468     top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
4469     left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
4470     };
4471    
4472     },
4473    
4474     _getRelativeOffset: function() {
4475    
4476     if(this.cssPosition === "relative") {
4477     var p = this.currentItem.position();
4478     return {
4479     top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
4480     left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
4481     };
4482     } else {
4483     return { top: 0, left: 0 };
4484     }
4485    
4486     },
4487    
4488     _cacheMargins: function() {
4489     this.margins = {
4490     left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
4491     top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
4492     };
4493     },
4494    
4495     _cacheHelperProportions: function() {
4496     this.helperProportions = {
4497     width: this.helper.outerWidth(),
4498     height: this.helper.outerHeight()
4499     };
4500     },
4501    
4502     _setContainment: function() {
4503    
4504     var ce, co, over,
4505     o = this.options;
4506     if(o.containment === "parent") {
4507     o.containment = this.helper[0].parentNode;
4508     }
4509     if(o.containment === "document" || o.containment === "window") {
4510     this.containment = [
4511     0 - this.offset.relative.left - this.offset.parent.left,
4512     0 - this.offset.relative.top - this.offset.parent.top,
4513     $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
4514     ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
4515     ];
4516     }
4517    
4518     if(!(/^(document|window|parent)$/).test(o.containment)) {
4519     ce = $(o.containment)[0];
4520     co = $(o.containment).offset();
4521     over = ($(ce).css("overflow") !== "hidden");
4522    
4523     this.containment = [
4524     co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
4525     co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
4526     co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
4527     co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
4528     ];
4529     }
4530    
4531     },
4532    
4533     _convertPositionTo: function(d, pos) {
4534    
4535     if(!pos) {
4536     pos = this.position;
4537     }
4538     var mod = d === "absolute" ? 1 : -1,
4539     scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
4540     scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
4541    
4542     return {
4543     top: (
4544     pos.top + // The absolute mouse position
4545     this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
4546     this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
4547     ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
4548     ),
4549     left: (
4550     pos.left + // The absolute mouse position
4551     this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
4552     this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
4553     ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
4554     )
4555     };
4556    
4557     },
4558    
4559     _generatePosition: function(event) {
4560    
4561     var top, left,
4562     o = this.options,
4563     pageX = event.pageX,
4564     pageY = event.pageY,
4565     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);
4566    
4567     // This is another very weird special case that only happens for relative elements:
4568     // 1. If the css position is relative
4569     // 2. and the scroll parent is the document or similar to the offset parent
4570     // we have to refresh the relative offset during the scroll so there are no jumps
4571     if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
4572     this.offset.relative = this._getRelativeOffset();
4573     }
4574    
4575     /*
4576     * - Position constraining -
4577     * Constrain the position to a mix of grid, containment.
4578     */
4579    
4580     if(this.originalPosition) { //If we are not dragging yet, we won't check for options
4581    
4582     if(this.containment) {
4583     if(event.pageX - this.offset.click.left < this.containment[0]) {
4584     pageX = this.containment[0] + this.offset.click.left;
4585     }
4586     if(event.pageY - this.offset.click.top < this.containment[1]) {
4587     pageY = this.containment[1] + this.offset.click.top;
4588     }
4589     if(event.pageX - this.offset.click.left > this.containment[2]) {
4590     pageX = this.containment[2] + this.offset.click.left;
4591     }
4592     if(event.pageY - this.offset.click.top > this.containment[3]) {
4593     pageY = this.containment[3] + this.offset.click.top;
4594     }
4595     }
4596    
4597     if(o.grid) {
4598     top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
4599     pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
4600    
4601     left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
4602     pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
4603     }
4604    
4605     }
4606    
4607     return {
4608     top: (
4609     pageY - // The absolute mouse position
4610     this.offset.click.top - // Click offset (relative to the element)
4611     this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
4612     this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
4613     ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
4614     ),
4615     left: (
4616     pageX - // The absolute mouse position
4617     this.offset.click.left - // Click offset (relative to the element)
4618     this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
4619     this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
4620     ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
4621     )
4622     };
4623    
4624     },
4625    
4626     _rearrange: function(event, i, a, hardRefresh) {
4627    
4628     a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
4629    
4630     //Various things done here to improve the performance:
4631     // 1. we create a setTimeout, that calls refreshPositions
4632     // 2. on the instance, we have a counter variable, that get's higher after every append
4633     // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
4634     // 4. this lets only the last addition to the timeout stack through
4635     this.counter = this.counter ? ++this.counter : 1;
4636     var counter = this.counter;
4637    
4638     this._delay(function() {
4639     if(counter === this.counter) {
4640     this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
4641     }
4642     });
4643    
4644     },
4645    
4646     _clear: function(event, noPropagation) {
4647    
4648     this.reverting = false;
4649     // We delay all events that have to be triggered to after the point where the placeholder has been removed and
4650     // everything else normalized again
4651     var i,
4652     delayedTriggers = [];
4653    
4654     // We first have to update the dom position of the actual currentItem
4655     // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
4656     if(!this._noFinalSort && this.currentItem.parent().length) {
4657     this.placeholder.before(this.currentItem);
4658     }
4659     this._noFinalSort = null;
4660    
4661     if(this.helper[0] === this.currentItem[0]) {
4662     for(i in this._storedCSS) {
4663     if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
4664     this._storedCSS[i] = "";
4665     }
4666     }
4667     this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
4668     } else {
4669     this.currentItem.show();
4670     }
4671    
4672     if(this.fromOutside && !noPropagation) {
4673     delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
4674     }
4675     if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
4676     delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
4677     }
4678    
4679     // Check if the items Container has Changed and trigger appropriate
4680     // events.
4681     if (this !== this.currentContainer) {
4682     if(!noPropagation) {
4683     delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
4684     delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
4685     delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
4686     }
4687     }
4688    
4689    
4690     //Post events to containers
4691     for (i = this.containers.length - 1; i >= 0; i--){
4692     if(!noPropagation) {
4693     delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); }; }).call(this, this.containers[i]));
4694     }
4695     if(this.containers[i].containerCache.over) {
4696     delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); }; }).call(this, this.containers[i]));
4697     this.containers[i].containerCache.over = 0;
4698     }
4699     }
4700    
4701     //Do what was originally in plugins
4702     if ( this.storedCursor ) {
4703     this.document.find( "body" ).css( "cursor", this.storedCursor );
4704     this.storedStylesheet.remove();
4705     }
4706     if(this._storedOpacity) {
4707     this.helper.css("opacity", this._storedOpacity);
4708     }
4709     if(this._storedZIndex) {
4710     this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
4711     }
4712    
4713     this.dragging = false;
4714     if(this.cancelHelperRemoval) {
4715     if(!noPropagation) {
4716     this._trigger("beforeStop", event, this._uiHash());
4717     for (i=0; i < delayedTriggers.length; i++) {
4718     delayedTriggers[i].call(this, event);
4719     } //Trigger all delayed events
4720     this._trigger("stop", event, this._uiHash());
4721     }
4722    
4723     this.fromOutside = false;
4724     return false;
4725     }
4726    
4727     if(!noPropagation) {
4728     this._trigger("beforeStop", event, this._uiHash());
4729     }
4730    
4731     //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
4732     this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
4733    
4734     if(this.helper[0] !== this.currentItem[0]) {
4735     this.helper.remove();
4736     }
4737     this.helper = null;
4738    
4739     if(!noPropagation) {
4740     for (i=0; i < delayedTriggers.length; i++) {
4741     delayedTriggers[i].call(this, event);
4742     } //Trigger all delayed events
4743     this._trigger("stop", event, this._uiHash());
4744     }
4745    
4746     this.fromOutside = false;
4747     return true;
4748    
4749     },
4750    
4751     _trigger: function() {
4752     if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
4753     this.cancel();
4754     }
4755     },
4756    
4757     _uiHash: function(_inst) {
4758     var inst = _inst || this;
4759     return {
4760     helper: inst.helper,
4761     placeholder: inst.placeholder || $([]),
4762     position: inst.position,
4763     originalPosition: inst.originalPosition,
4764     offset: inst.positionAbs,
4765     item: inst.currentItem,
4766     sender: _inst ? _inst.element : null
4767     };
4768     }
4769    
4770     });
4771    
4772     })(jQuery);
4773    
4774     (function($, undefined) {
4775    
4776     var dataSpace = "ui-effects-";
4777    
4778     $.effects = {
4779     effect: {}
4780     };
4781    
4782     /*!
4783     * jQuery Color Animations v2.1.2
4784     * https://github.com/jquery/jquery-color
4785     *
4786     * Copyright 2013 jQuery Foundation and other contributors
4787     * Released under the MIT license.
4788     * http://jquery.org/license
4789     *
4790     * Date: Wed Jan 16 08:47:09 2013 -0600
4791     */
4792     (function( jQuery, undefined ) {
4793    
4794     var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
4795    
4796     // plusequals test for += 100 -= 100
4797     rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
4798     // a set of RE's that can match strings and generate color tuples.
4799     stringParsers = [{
4800     re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4801     parse: function( execResult ) {
4802     return [
4803     execResult[ 1 ],
4804     execResult[ 2 ],
4805     execResult[ 3 ],
4806     execResult[ 4 ]
4807     ];
4808     }
4809     }, {
4810     re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4811     parse: function( execResult ) {
4812     return [
4813     execResult[ 1 ] * 2.55,
4814     execResult[ 2 ] * 2.55,
4815     execResult[ 3 ] * 2.55,
4816     execResult[ 4 ]
4817     ];
4818     }
4819     }, {
4820     // this regex ignores A-F because it's compared against an already lowercased string
4821     re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
4822     parse: function( execResult ) {
4823     return [
4824     parseInt( execResult[ 1 ], 16 ),
4825     parseInt( execResult[ 2 ], 16 ),
4826     parseInt( execResult[ 3 ], 16 )
4827     ];
4828     }
4829     }, {
4830     // this regex ignores A-F because it's compared against an already lowercased string
4831     re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
4832     parse: function( execResult ) {
4833     return [
4834     parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
4835     parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
4836     parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
4837     ];
4838     }
4839     }, {
4840     re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4841     space: "hsla",
4842     parse: function( execResult ) {
4843     return [
4844     execResult[ 1 ],
4845     execResult[ 2 ] / 100,
4846     execResult[ 3 ] / 100,
4847     execResult[ 4 ]
4848     ];
4849     }
4850     }],
4851    
4852     // jQuery.Color( )
4853     color = jQuery.Color = function( color, green, blue, alpha ) {
4854     return new jQuery.Color.fn.parse( color, green, blue, alpha );
4855     },
4856     spaces = {
4857     rgba: {
4858     props: {
4859     red: {
4860     idx: 0,
4861     type: "byte"
4862     },
4863     green: {
4864     idx: 1,
4865     type: "byte"
4866     },
4867     blue: {
4868     idx: 2,
4869     type: "byte"
4870     }
4871     }
4872     },
4873    
4874     hsla: {
4875     props: {
4876     hue: {
4877     idx: 0,
4878     type: "degrees"
4879     },
4880     saturation: {
4881     idx: 1,
4882     type: "percent"
4883     },
4884     lightness: {
4885     idx: 2,
4886     type: "percent"
4887     }
4888     }
4889     }
4890     },
4891     propTypes = {
4892     "byte": {
4893     floor: true,
4894     max: 255
4895     },
4896     "percent": {
4897     max: 1
4898     },
4899     "degrees": {
4900     mod: 360,
4901     floor: true
4902     }
4903     },
4904     support = color.support = {},
4905    
4906     // element for support tests
4907     supportElem = jQuery( "<p>" )[ 0 ],
4908    
4909     // colors = jQuery.Color.names
4910     colors,
4911    
4912     // local aliases of functions called often
4913     each = jQuery.each;
4914    
4915     // determine rgba support immediately
4916     supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
4917     support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
4918    
4919     // define cache name and alpha properties
4920     // for rgba and hsla spaces
4921     each( spaces, function( spaceName, space ) {
4922     space.cache = "_" + spaceName;
4923     space.props.alpha = {
4924     idx: 3,
4925     type: "percent",
4926     def: 1
4927     };
4928     });
4929    
4930     function clamp( value, prop, allowEmpty ) {
4931     var type = propTypes[ prop.type ] || {};
4932    
4933     if ( value == null ) {
4934     return (allowEmpty || !prop.def) ? null : prop.def;
4935     }
4936    
4937     // ~~ is an short way of doing floor for positive numbers
4938     value = type.floor ? ~~value : parseFloat( value );
4939    
4940     // IE will pass in empty strings as value for alpha,
4941     // which will hit this case
4942     if ( isNaN( value ) ) {
4943     return prop.def;
4944     }
4945    
4946     if ( type.mod ) {
4947     // we add mod before modding to make sure that negatives values
4948     // get converted properly: -10 -> 350
4949     return (value + type.mod) % type.mod;
4950     }
4951    
4952     // for now all property types without mod have min and max
4953     return 0 > value ? 0 : type.max < value ? type.max : value;
4954     }
4955    
4956     function stringParse( string ) {
4957     var inst = color(),
4958     rgba = inst._rgba = [];
4959    
4960     string = string.toLowerCase();
4961    
4962     each( stringParsers, function( i, parser ) {
4963     var parsed,
4964     match = parser.re.exec( string ),
4965     values = match && parser.parse( match ),
4966     spaceName = parser.space || "rgba";
4967    
4968     if ( values ) {
4969     parsed = inst[ spaceName ]( values );
4970    
4971     // if this was an rgba parse the assignment might happen twice
4972     // oh well....
4973     inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
4974     rgba = inst._rgba = parsed._rgba;
4975    
4976     // exit each( stringParsers ) here because we matched
4977     return false;
4978     }
4979     });
4980    
4981     // Found a stringParser that handled it
4982     if ( rgba.length ) {
4983    
4984     // if this came from a parsed string, force "transparent" when alpha is 0
4985     // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
4986     if ( rgba.join() === "0,0,0,0" ) {
4987     jQuery.extend( rgba, colors.transparent );
4988     }
4989     return inst;
4990     }
4991    
4992     // named colors
4993     return colors[ string ];
4994     }
4995    
4996     color.fn = jQuery.extend( color.prototype, {
4997     parse: function( red, green, blue, alpha ) {
4998     if ( red === undefined ) {
4999     this._rgba = [ null, null, null, null ];
5000     return this;
5001     }
5002     if ( red.jquery || red.nodeType ) {
5003     red = jQuery( red ).css( green );
5004     green = undefined;
5005     }
5006    
5007     var inst = this,
5008     type = jQuery.type( red ),
5009     rgba = this._rgba = [];
5010    
5011     // more than 1 argument specified - assume ( red, green, blue, alpha )
5012     if ( green !== undefined ) {
5013     red = [ red, green, blue, alpha ];
5014     type = "array";
5015     }
5016    
5017     if ( type === "string" ) {
5018     return this.parse( stringParse( red ) || colors._default );
5019     }
5020    
5021     if ( type === "array" ) {
5022     each( spaces.rgba.props, function( key, prop ) {
5023     rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
5024     });
5025     return this;
5026     }
5027    
5028     if ( type === "object" ) {
5029     if ( red instanceof color ) {
5030     each( spaces, function( spaceName, space ) {
5031     if ( red[ space.cache ] ) {
5032     inst[ space.cache ] = red[ space.cache ].slice();
5033     }
5034     });
5035     } else {
5036     each( spaces, function( spaceName, space ) {
5037     var cache = space.cache;
5038     each( space.props, function( key, prop ) {
5039    
5040     // if the cache doesn't exist, and we know how to convert
5041     if ( !inst[ cache ] && space.to ) {
5042    
5043     // if the value was null, we don't need to copy it
5044     // if the key was alpha, we don't need to copy it either
5045     if ( key === "alpha" || red[ key ] == null ) {
5046     return;
5047     }
5048     inst[ cache ] = space.to( inst._rgba );
5049     }
5050    
5051     // this is the only case where we allow nulls for ALL properties.
5052     // call clamp with alwaysAllowEmpty
5053     inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
5054     });
5055    
5056     // everything defined but alpha?
5057     if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
5058     // use the default of 1
5059     inst[ cache ][ 3 ] = 1;
5060     if ( space.from ) {
5061     inst._rgba = space.from( inst[ cache ] );
5062     }
5063     }
5064     });
5065     }
5066     return this;
5067     }
5068     },
5069     is: function( compare ) {
5070     var is = color( compare ),
5071     same = true,
5072     inst = this;
5073    
5074     each( spaces, function( _, space ) {
5075     var localCache,
5076     isCache = is[ space.cache ];
5077     if (isCache) {
5078     localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
5079     each( space.props, function( _, prop ) {
5080     if ( isCache[ prop.idx ] != null ) {
5081     same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
5082     return same;
5083     }
5084     });
5085     }
5086     return same;
5087     });
5088     return same;
5089     },
5090     _space: function() {
5091     var used = [],
5092     inst = this;
5093     each( spaces, function( spaceName, space ) {
5094     if ( inst[ space.cache ] ) {
5095     used.push( spaceName );
5096     }
5097     });
5098     return used.pop();
5099     },
5100     transition: function( other, distance ) {
5101     var end = color( other ),
5102     spaceName = end._space(),
5103     space = spaces[ spaceName ],
5104     startColor = this.alpha() === 0 ? color( "transparent" ) : this,
5105     start = startColor[ space.cache ] || space.to( startColor._rgba ),
5106     result = start.slice();
5107    
5108     end = end[ space.cache ];
5109     each( space.props, function( key, prop ) {
5110     var index = prop.idx,
5111     startValue = start[ index ],
5112     endValue = end[ index ],
5113     type = propTypes[ prop.type ] || {};
5114    
5115     // if null, don't override start value
5116     if ( endValue === null ) {
5117     return;
5118     }
5119     // if null - use end
5120     if ( startValue === null ) {
5121     result[ index ] = endValue;
5122     } else {
5123     if ( type.mod ) {
5124     if ( endValue - startValue > type.mod / 2 ) {
5125     startValue += type.mod;
5126     } else if ( startValue - endValue > type.mod / 2 ) {
5127     startValue -= type.mod;
5128     }
5129     }
5130     result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
5131     }
5132     });
5133     return this[ spaceName ]( result );
5134     },
5135     blend: function( opaque ) {
5136     // if we are already opaque - return ourself
5137     if ( this._rgba[ 3 ] === 1 ) {
5138     return this;
5139     }
5140    
5141     var rgb = this._rgba.slice(),
5142     a = rgb.pop(),
5143     blend = color( opaque )._rgba;
5144    
5145     return color( jQuery.map( rgb, function( v, i ) {
5146     return ( 1 - a ) * blend[ i ] + a * v;
5147     }));
5148     },
5149     toRgbaString: function() {
5150     var prefix = "rgba(",
5151     rgba = jQuery.map( this._rgba, function( v, i ) {
5152     return v == null ? ( i > 2 ? 1 : 0 ) : v;
5153     });
5154    
5155     if ( rgba[ 3 ] === 1 ) {
5156     rgba.pop();
5157     prefix = "rgb(";
5158     }
5159    
5160     return prefix + rgba.join() + ")";
5161     },
5162     toHslaString: function() {
5163     var prefix = "hsla(",
5164     hsla = jQuery.map( this.hsla(), function( v, i ) {
5165     if ( v == null ) {
5166     v = i > 2 ? 1 : 0;
5167     }
5168    
5169     // catch 1 and 2
5170     if ( i && i < 3 ) {
5171     v = Math.round( v * 100 ) + "%";
5172     }
5173     return v;
5174     });
5175    
5176     if ( hsla[ 3 ] === 1 ) {
5177     hsla.pop();
5178     prefix = "hsl(";
5179     }
5180     return prefix + hsla.join() + ")";
5181     },
5182     toHexString: function( includeAlpha ) {
5183     var rgba = this._rgba.slice(),
5184     alpha = rgba.pop();
5185    
5186     if ( includeAlpha ) {
5187     rgba.push( ~~( alpha * 255 ) );
5188     }
5189    
5190     return "#" + jQuery.map( rgba, function( v ) {
5191    
5192     // default to 0 when nulls exist
5193     v = ( v || 0 ).toString( 16 );
5194     return v.length === 1 ? "0" + v : v;
5195     }).join("");
5196     },
5197     toString: function() {
5198     return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
5199     }
5200     });
5201     color.fn.parse.prototype = color.fn;
5202    
5203     // hsla conversions adapted from:
5204     // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
5205    
5206     function hue2rgb( p, q, h ) {
5207     h = ( h + 1 ) % 1;
5208     if ( h * 6 < 1 ) {
5209     return p + (q - p) * h * 6;
5210     }
5211     if ( h * 2 < 1) {
5212     return q;
5213     }
5214     if ( h * 3 < 2 ) {
5215     return p + (q - p) * ((2/3) - h) * 6;
5216     }
5217     return p;
5218     }
5219    
5220     spaces.hsla.to = function ( rgba ) {
5221     if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
5222     return [ null, null, null, rgba[ 3 ] ];
5223     }
5224     var r = rgba[ 0 ] / 255,
5225     g = rgba[ 1 ] / 255,
5226     b = rgba[ 2 ] / 255,
5227     a = rgba[ 3 ],
5228     max = Math.max( r, g, b ),
5229     min = Math.min( r, g, b ),
5230     diff = max - min,
5231     add = max + min,
5232     l = add * 0.5,
5233     h, s;
5234    
5235     if ( min === max ) {
5236     h = 0;
5237     } else if ( r === max ) {
5238     h = ( 60 * ( g - b ) / diff ) + 360;
5239     } else if ( g === max ) {
5240     h = ( 60 * ( b - r ) / diff ) + 120;
5241     } else {
5242     h = ( 60 * ( r - g ) / diff ) + 240;
5243     }
5244    
5245     // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
5246     // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
5247     if ( diff === 0 ) {
5248     s = 0;
5249     } else if ( l <= 0.5 ) {
5250     s = diff / add;
5251     } else {
5252     s = diff / ( 2 - add );
5253     }
5254     return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
5255     };
5256    
5257     spaces.hsla.from = function ( hsla ) {
5258     if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
5259     return [ null, null, null, hsla[ 3 ] ];
5260     }
5261     var h = hsla[ 0 ] / 360,
5262     s = hsla[ 1 ],
5263     l = hsla[ 2 ],
5264     a = hsla[ 3 ],
5265     q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
5266     p = 2 * l - q;
5267    
5268     return [
5269     Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
5270     Math.round( hue2rgb( p, q, h ) * 255 ),
5271     Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
5272     a
5273     ];
5274     };
5275    
5276    
5277     each( spaces, function( spaceName, space ) {
5278     var props = space.props,
5279     cache = space.cache,
5280     to = space.to,
5281     from = space.from;
5282    
5283     // makes rgba() and hsla()
5284     color.fn[ spaceName ] = function( value ) {
5285    
5286     // generate a cache for this space if it doesn't exist
5287     if ( to && !this[ cache ] ) {
5288     this[ cache ] = to( this._rgba );
5289     }
5290     if ( value === undefined ) {
5291     return this[ cache ].slice();
5292     }
5293    
5294     var ret,
5295     type = jQuery.type( value ),
5296     arr = ( type === "array" || type === "object" ) ? value : arguments,
5297     local = this[ cache ].slice();
5298    
5299     each( props, function( key, prop ) {
5300     var val = arr[ type === "object" ? key : prop.idx ];
5301     if ( val == null ) {
5302     val = local[ prop.idx ];
5303     }
5304     local[ prop.idx ] = clamp( val, prop );
5305     });
5306    
5307     if ( from ) {
5308     ret = color( from( local ) );
5309     ret[ cache ] = local;
5310     return ret;
5311     } else {
5312     return color( local );
5313     }
5314     };
5315    
5316     // makes red() green() blue() alpha() hue() saturation() lightness()
5317     each( props, function( key, prop ) {
5318     // alpha is included in more than one space
5319     if ( color.fn[ key ] ) {
5320     return;
5321     }
5322     color.fn[ key ] = function( value ) {
5323     var vtype = jQuery.type( value ),
5324     fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
5325     local = this[ fn ](),
5326     cur = local[ prop.idx ],
5327     match;
5328    
5329     if ( vtype === "undefined" ) {
5330     return cur;
5331     }
5332    
5333     if ( vtype === "function" ) {
5334     value = value.call( this, cur );
5335     vtype = jQuery.type( value );
5336     }
5337     if ( value == null && prop.empty ) {
5338     return this;
5339     }
5340     if ( vtype === "string" ) {
5341     match = rplusequals.exec( value );
5342     if ( match ) {
5343     value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
5344     }
5345     }
5346     local[ prop.idx ] = value;
5347     return this[ fn ]( local );
5348     };
5349     });
5350     });
5351    
5352     // add cssHook and .fx.step function for each named hook.
5353     // accept a space separated string of properties
5354     color.hook = function( hook ) {
5355     var hooks = hook.split( " " );
5356     each( hooks, function( i, hook ) {
5357     jQuery.cssHooks[ hook ] = {
5358     set: function( elem, value ) {
5359     var parsed, curElem,
5360     backgroundColor = "";
5361    
5362     if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
5363     value = color( parsed || value );
5364     if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
5365     curElem = hook === "backgroundColor" ? elem.parentNode : elem;
5366     while (
5367     (backgroundColor === "" || backgroundColor === "transparent") &&
5368     curElem && curElem.style
5369     ) {
5370     try {
5371     backgroundColor = jQuery.css( curElem, "backgroundColor" );
5372     curElem = curElem.parentNode;
5373     } catch ( e ) {
5374     }
5375     }
5376    
5377     value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
5378     backgroundColor :
5379     "_default" );
5380     }
5381    
5382     value = value.toRgbaString();
5383     }
5384     try {
5385     elem.style[ hook ] = value;
5386     } catch( e ) {
5387     // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
5388     }
5389     }
5390     };
5391     jQuery.fx.step[ hook ] = function( fx ) {
5392     if ( !fx.colorInit ) {
5393     fx.start = color( fx.elem, hook );
5394     fx.end = color( fx.end );
5395     fx.colorInit = true;
5396     }
5397     jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
5398     };
5399     });
5400    
5401     };
5402    
5403     color.hook( stepHooks );
5404    
5405     jQuery.cssHooks.borderColor = {
5406     expand: function( value ) {
5407     var expanded = {};
5408    
5409     each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
5410     expanded[ "border" + part + "Color" ] = value;
5411     });
5412     return expanded;
5413     }
5414     };
5415    
5416     // Basic color names only.
5417     // Usage of any of the other color names requires adding yourself or including
5418     // jquery.color.svg-names.js.
5419     colors = jQuery.Color.names = {
5420     // 4.1. Basic color keywords
5421     aqua: "#00ffff",
5422     black: "#000000",
5423     blue: "#0000ff",
5424     fuchsia: "#ff00ff",
5425     gray: "#808080",
5426     green: "#008000",
5427     lime: "#00ff00",
5428     maroon: "#800000",
5429     navy: "#000080",
5430     olive: "#808000",
5431     purple: "#800080",
5432     red: "#ff0000",
5433     silver: "#c0c0c0",
5434     teal: "#008080",
5435     white: "#ffffff",
5436     yellow: "#ffff00",
5437    
5438     // 4.2.3. "transparent" color keyword
5439     transparent: [ null, null, null, 0 ],
5440    
5441     _default: "#ffffff"
5442     };
5443    
5444     })( jQuery );
5445    
5446    
5447     /******************************************************************************/
5448     /****************************** CLASS ANIMATIONS ******************************/
5449     /******************************************************************************/
5450     (function() {
5451    
5452     var classAnimationActions = [ "add", "remove", "toggle" ],
5453     shorthandStyles = {
5454     border: 1,
5455     borderBottom: 1,
5456     borderColor: 1,
5457     borderLeft: 1,
5458     borderRight: 1,
5459     borderTop: 1,
5460     borderWidth: 1,
5461     margin: 1,
5462     padding: 1
5463     };
5464    
5465     $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
5466     $.fx.step[ prop ] = function( fx ) {
5467     if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
5468     jQuery.style( fx.elem, prop, fx.end );
5469     fx.setAttr = true;
5470     }
5471     };
5472     });
5473    
5474     function getElementStyles( elem ) {
5475     var key, len,
5476     style = elem.ownerDocument.defaultView ?
5477     elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
5478     elem.currentStyle,
5479     styles = {};
5480    
5481     if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
5482     len = style.length;
5483     while ( len-- ) {
5484     key = style[ len ];
5485     if ( typeof style[ key ] === "string" ) {
5486     styles[ $.camelCase( key ) ] = style[ key ];
5487     }
5488     }
5489     // support: Opera, IE <9
5490     } else {
5491     for ( key in style ) {
5492     if ( typeof style[ key ] === "string" ) {
5493     styles[ key ] = style[ key ];
5494     }
5495     }
5496     }
5497    
5498     return styles;
5499     }
5500    
5501    
5502     function styleDifference( oldStyle, newStyle ) {
5503     var diff = {},
5504     name, value;
5505    
5506     for ( name in newStyle ) {
5507     value = newStyle[ name ];
5508     if ( oldStyle[ name ] !== value ) {
5509     if ( !shorthandStyles[ name ] ) {
5510     if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
5511     diff[ name ] = value;
5512     }
5513     }
5514     }
5515     }
5516    
5517     return diff;
5518     }
5519    
5520     // support: jQuery <1.8
5521     if ( !$.fn.addBack ) {
5522     $.fn.addBack = function( selector ) {
5523     return this.add( selector == null ?
5524     this.prevObject : this.prevObject.filter( selector )
5525     );
5526     };
5527     }
5528    
5529     $.effects.animateClass = function( value, duration, easing, callback ) {
5530     var o = $.speed( duration, easing, callback );
5531    
5532     return this.queue( function() {
5533     var animated = $( this ),
5534     baseClass = animated.attr( "class" ) || "",
5535     applyClassChange,
5536     allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
5537    
5538     // map the animated objects to store the original styles.
5539     allAnimations = allAnimations.map(function() {
5540     var el = $( this );
5541     return {
5542     el: el,
5543     start: getElementStyles( this )
5544     };
5545     });
5546    
5547     // apply class change
5548     applyClassChange = function() {
5549     $.each( classAnimationActions, function(i, action) {
5550     if ( value[ action ] ) {
5551     animated[ action + "Class" ]( value[ action ] );
5552     }
5553     });
5554     };
5555     applyClassChange();
5556    
5557     // map all animated objects again - calculate new styles and diff
5558     allAnimations = allAnimations.map(function() {
5559     this.end = getElementStyles( this.el[ 0 ] );
5560     this.diff = styleDifference( this.start, this.end );
5561     return this;
5562     });
5563    
5564     // apply original class
5565     animated.attr( "class", baseClass );
5566    
5567     // map all animated objects again - this time collecting a promise
5568     allAnimations = allAnimations.map(function() {
5569     var styleInfo = this,
5570     dfd = $.Deferred(),
5571     opts = $.extend({}, o, {
5572     queue: false,
5573     complete: function() {
5574     dfd.resolve( styleInfo );
5575     }
5576     });
5577    
5578     this.el.animate( this.diff, opts );
5579     return dfd.promise();
5580     });
5581    
5582     // once all animations have completed:
5583     $.when.apply( $, allAnimations.get() ).done(function() {
5584    
5585     // set the final class
5586     applyClassChange();
5587    
5588     // for each animated element,
5589     // clear all css properties that were animated
5590     $.each( arguments, function() {
5591     var el = this.el;
5592     $.each( this.diff, function(key) {
5593     el.css( key, "" );
5594     });
5595     });
5596    
5597     // this is guarnteed to be there if you use jQuery.speed()
5598     // it also handles dequeuing the next anim...
5599     o.complete.call( animated[ 0 ] );
5600     });
5601     });
5602     };
5603    
5604     $.fn.extend({
5605     addClass: (function( orig ) {
5606     return function( classNames, speed, easing, callback ) {
5607     return speed ?
5608     $.effects.animateClass.call( this,
5609     { add: classNames }, speed, easing, callback ) :
5610     orig.apply( this, arguments );
5611     };
5612     })( $.fn.addClass ),
5613    
5614     removeClass: (function( orig ) {
5615     return function( classNames, speed, easing, callback ) {
5616     return arguments.length > 1 ?
5617     $.effects.animateClass.call( this,
5618     { remove: classNames }, speed, easing, callback ) :
5619     orig.apply( this, arguments );
5620     };
5621     })( $.fn.removeClass ),
5622    
5623     toggleClass: (function( orig ) {
5624     return function( classNames, force, speed, easing, callback ) {
5625     if ( typeof force === "boolean" || force === undefined ) {
5626     if ( !speed ) {
5627     // without speed parameter
5628     return orig.apply( this, arguments );
5629     } else {
5630     return $.effects.animateClass.call( this,
5631     (force ? { add: classNames } : { remove: classNames }),
5632     speed, easing, callback );
5633     }
5634     } else {
5635     // without force parameter
5636     return $.effects.animateClass.call( this,
5637     { toggle: classNames }, force, speed, easing );
5638     }
5639     };
5640     })( $.fn.toggleClass ),
5641    
5642     switchClass: function( remove, add, speed, easing, callback) {
5643     return $.effects.animateClass.call( this, {
5644     add: add,
5645     remove: remove
5646     }, speed, easing, callback );
5647     }
5648     });
5649    
5650     })();
5651    
5652     /******************************************************************************/
5653     /*********************************** EFFECTS **********************************/
5654     /******************************************************************************/
5655    
5656     (function() {
5657    
5658     $.extend( $.effects, {
5659     version: "1.10.3",
5660    
5661     // Saves a set of properties in a data storage
5662     save: function( element, set ) {
5663     for( var i=0; i < set.length; i++ ) {
5664     if ( set[ i ] !== null ) {
5665     element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
5666     }
5667     }
5668     },
5669    
5670     // Restores a set of previously saved properties from a data storage
5671     restore: function( element, set ) {
5672     var val, i;
5673     for( i=0; i < set.length; i++ ) {
5674     if ( set[ i ] !== null ) {
5675     val = element.data( dataSpace + set[ i ] );
5676     // support: jQuery 1.6.2
5677     // http://bugs.jquery.com/ticket/9917
5678     // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
5679     // We can't differentiate between "" and 0 here, so we just assume
5680     // empty string since it's likely to be a more common value...
5681     if ( val === undefined ) {
5682     val = "";
5683     }
5684     element.css( set[ i ], val );
5685     }
5686     }
5687     },
5688    
5689     setMode: function( el, mode ) {
5690     if (mode === "toggle") {
5691     mode = el.is( ":hidden" ) ? "show" : "hide";
5692     }
5693     return mode;
5694     },
5695    
5696     // Translates a [top,left] array into a baseline value
5697     // this should be a little more flexible in the future to handle a string & hash
5698     getBaseline: function( origin, original ) {
5699     var y, x;
5700     switch ( origin[ 0 ] ) {
5701     case "top": y = 0; break;
5702     case "middle": y = 0.5; break;
5703     case "bottom": y = 1; break;
5704     default: y = origin[ 0 ] / original.height;
5705     }
5706     switch ( origin[ 1 ] ) {
5707     case "left": x = 0; break;
5708     case "center": x = 0.5; break;
5709     case "right": x = 1; break;
5710     default: x = origin[ 1 ] / original.width;
5711     }
5712     return {
5713     x: x,
5714     y: y
5715     };
5716     },
5717    
5718     // Wraps the element around a wrapper that copies position properties
5719     createWrapper: function( element ) {
5720    
5721     // if the element is already wrapped, return it
5722     if ( element.parent().is( ".ui-effects-wrapper" )) {
5723     return element.parent();
5724     }
5725    
5726     // wrap the element
5727     var props = {
5728     width: element.outerWidth(true),
5729     height: element.outerHeight(true),
5730     "float": element.css( "float" )
5731     },
5732     wrapper = $( "<div></div>" )
5733     .addClass( "ui-effects-wrapper" )
5734     .css({
5735     fontSize: "100%",
5736     background: "transparent",
5737     border: "none",
5738     margin: 0,
5739     padding: 0
5740     }),
5741     // Store the size in case width/height are defined in % - Fixes #5245
5742     size = {
5743     width: element.width(),
5744     height: element.height()
5745     },
5746     active = document.activeElement;
5747    
5748     // support: Firefox
5749     // Firefox incorrectly exposes anonymous content
5750     // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
5751     try {
5752     active.id;
5753     } catch( e ) {
5754     active = document.body;
5755     }
5756    
5757     element.wrap( wrapper );
5758    
5759     // Fixes #7595 - Elements lose focus when wrapped.
5760     if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
5761     $( active ).focus();
5762     }
5763    
5764     wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
5765    
5766     // transfer positioning properties to the wrapper
5767     if ( element.css( "position" ) === "static" ) {
5768     wrapper.css({ position: "relative" });
5769     element.css({ position: "relative" });
5770     } else {
5771     $.extend( props, {
5772     position: element.css( "position" ),
5773     zIndex: element.css( "z-index" )
5774     });
5775     $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
5776     props[ pos ] = element.css( pos );
5777     if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
5778     props[ pos ] = "auto";
5779     }
5780     });
5781     element.css({
5782     position: "relative",
5783     top: 0,
5784     left: 0,
5785     right: "auto",
5786     bottom: "auto"
5787     });
5788     }
5789     element.css(size);
5790    
5791     return wrapper.css( props ).show();
5792     },
5793    
5794     removeWrapper: function( element ) {
5795     var active = document.activeElement;
5796    
5797     if ( element.parent().is( ".ui-effects-wrapper" ) ) {
5798     element.parent().replaceWith( element );
5799    
5800     // Fixes #7595 - Elements lose focus when wrapped.
5801     if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
5802     $( active ).focus();
5803     }
5804     }
5805    
5806    
5807     return element;
5808     },
5809    
5810     setTransition: function( element, list, factor, value ) {
5811     value = value || {};
5812     $.each( list, function( i, x ) {
5813     var unit = element.cssUnit( x );
5814     if ( unit[ 0 ] > 0 ) {
5815     value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
5816     }
5817     });
5818     return value;
5819     }
5820     });
5821    
5822     // return an effect options object for the given parameters:
5823     function _normalizeArguments( effect, options, speed, callback ) {
5824    
5825     // allow passing all options as the first parameter
5826     if ( $.isPlainObject( effect ) ) {
5827     options = effect;
5828     effect = effect.effect;
5829     }
5830    
5831     // convert to an object
5832     effect = { effect: effect };
5833    
5834     // catch (effect, null, ...)
5835     if ( options == null ) {
5836     options = {};
5837     }
5838    
5839     // catch (effect, callback)
5840     if ( $.isFunction( options ) ) {
5841     callback = options;
5842     speed = null;
5843     options = {};
5844     }
5845    
5846     // catch (effect, speed, ?)
5847     if ( typeof options === "number" || $.fx.speeds[ options ] ) {
5848     callback = speed;
5849     speed = options;
5850     options = {};
5851     }
5852    
5853     // catch (effect, options, callback)
5854     if ( $.isFunction( speed ) ) {
5855     callback = speed;
5856     speed = null;
5857     }
5858    
5859     // add options to effect
5860     if ( options ) {
5861     $.extend( effect, options );
5862     }
5863    
5864     speed = speed || options.duration;
5865     effect.duration = $.fx.off ? 0 :
5866     typeof speed === "number" ? speed :
5867     speed in $.fx.speeds ? $.fx.speeds[ speed ] :
5868     $.fx.speeds._default;
5869    
5870     effect.complete = callback || options.complete;
5871    
5872     return effect;
5873     }
5874    
5875     function standardAnimationOption( option ) {
5876     // Valid standard speeds (nothing, number, named speed)
5877     if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
5878     return true;
5879     }
5880    
5881     // Invalid strings - treat as "normal" speed
5882     if ( typeof option === "string" && !$.effects.effect[ option ] ) {
5883     return true;
5884     }
5885    
5886     // Complete callback
5887     if ( $.isFunction( option ) ) {
5888     return true;
5889     }
5890    
5891     // Options hash (but not naming an effect)
5892     if ( typeof option === "object" && !option.effect ) {
5893     return true;
5894     }
5895    
5896     // Didn't match any standard API
5897     return false;
5898     }
5899    
5900     $.fn.extend({
5901     effect: function( /* effect, options, speed, callback */ ) {
5902     var args = _normalizeArguments.apply( this, arguments ),
5903     mode = args.mode,
5904     queue = args.queue,
5905     effectMethod = $.effects.effect[ args.effect ];
5906    
5907     if ( $.fx.off || !effectMethod ) {
5908     // delegate to the original method (e.g., .show()) if possible
5909     if ( mode ) {
5910     return this[ mode ]( args.duration, args.complete );
5911     } else {
5912     return this.each( function() {
5913     if ( args.complete ) {
5914     args.complete.call( this );
5915     }
5916     });
5917     }
5918     }
5919    
5920     function run( next ) {
5921     var elem = $( this ),
5922     complete = args.complete,
5923     mode = args.mode;
5924    
5925     function done() {
5926     if ( $.isFunction( complete ) ) {
5927     complete.call( elem[0] );
5928     }
5929     if ( $.isFunction( next ) ) {
5930     next();
5931     }
5932     }
5933    
5934     // If the element already has the correct final state, delegate to
5935     // the core methods so the internal tracking of "olddisplay" works.
5936     if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
5937     elem[ mode ]();
5938     done();
5939     } else {
5940     effectMethod.call( elem[0], args, done );
5941     }
5942     }
5943    
5944     return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
5945     },
5946    
5947     show: (function( orig ) {
5948     return function( option ) {
5949     if ( standardAnimationOption( option ) ) {
5950     return orig.apply( this, arguments );
5951     } else {
5952     var args = _normalizeArguments.apply( this, arguments );
5953     args.mode = "show";
5954     return this.effect.call( this, args );
5955     }
5956     };
5957     })( $.fn.show ),
5958    
5959     hide: (function( orig ) {
5960     return function( option ) {
5961     if ( standardAnimationOption( option ) ) {
5962     return orig.apply( this, arguments );
5963     } else {
5964     var args = _normalizeArguments.apply( this, arguments );
5965     args.mode = "hide";
5966     return this.effect.call( this, args );
5967     }
5968     };
5969     })( $.fn.hide ),
5970    
5971     toggle: (function( orig ) {
5972     return function( option ) {
5973     if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
5974     return orig.apply( this, arguments );
5975     } else {
5976     var args = _normalizeArguments.apply( this, arguments );
5977     args.mode = "toggle";
5978     return this.effect.call( this, args );
5979     }
5980     };
5981     })( $.fn.toggle ),
5982    
5983     // helper functions
5984     cssUnit: function(key) {
5985     var style = this.css( key ),
5986     val = [];
5987    
5988     $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
5989     if ( style.indexOf( unit ) > 0 ) {
5990     val = [ parseFloat( style ), unit ];
5991     }
5992     });
5993     return val;
5994     }
5995     });
5996    
5997     })();
5998    
5999     /******************************************************************************/
6000     /*********************************** EASING ***********************************/
6001     /******************************************************************************/
6002    
6003     (function() {
6004    
6005     // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
6006    
6007     var baseEasings = {};
6008    
6009     $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
6010     baseEasings[ name ] = function( p ) {
6011     return Math.pow( p, i + 2 );
6012     };
6013     });
6014    
6015     $.extend( baseEasings, {
6016     Sine: function ( p ) {
6017     return 1 - Math.cos( p * Math.PI / 2 );
6018     },
6019     Circ: function ( p ) {
6020     return 1 - Math.sqrt( 1 - p * p );
6021     },
6022     Elastic: function( p ) {
6023     return p === 0 || p === 1 ? p :
6024     -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
6025     },
6026     Back: function( p ) {
6027     return p * p * ( 3 * p - 2 );
6028     },
6029     Bounce: function ( p ) {
6030     var pow2,
6031     bounce = 4;
6032    
6033     while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
6034     return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
6035     }
6036     });
6037    
6038     $.each( baseEasings, function( name, easeIn ) {
6039     $.easing[ "easeIn" + name ] = easeIn;
6040     $.easing[ "easeOut" + name ] = function( p ) {
6041     return 1 - easeIn( 1 - p );
6042     };
6043     $.easing[ "easeInOut" + name ] = function( p ) {
6044     return p < 0.5 ?
6045     easeIn( p * 2 ) / 2 :
6046     1 - easeIn( p * -2 + 2 ) / 2;
6047     };
6048     });
6049    
6050     })();
6051    
6052     })(jQuery);
6053    
6054     (function( $, undefined ) {
6055    
6056     var uid = 0,
6057     hideProps = {},
6058     showProps = {};
6059    
6060     hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
6061     hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
6062     showProps.height = showProps.paddingTop = showProps.paddingBottom =
6063     showProps.borderTopWidth = showProps.borderBottomWidth = "show";
6064    
6065     $.widget( "ui.accordion", {
6066     version: "1.10.3",
6067     options: {
6068     active: 0,
6069     animate: {},
6070     collapsible: false,
6071     event: "click",
6072     header: "> li > :first-child,> :not(li):even",
6073     heightStyle: "auto",
6074     icons: {
6075     activeHeader: "ui-icon-triangle-1-s",
6076     header: "ui-icon-triangle-1-e"
6077     },
6078    
6079     // callbacks
6080     activate: null,
6081     beforeActivate: null
6082     },
6083    
6084     _create: function() {
6085     var options = this.options;
6086     this.prevShow = this.prevHide = $();
6087     this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
6088     // ARIA
6089     .attr( "role", "tablist" );
6090    
6091     // don't allow collapsible: false and active: false / null
6092     if ( !options.collapsible && (options.active === false || options.active == null) ) {
6093     options.active = 0;
6094     }
6095    
6096     this._processPanels();
6097     // handle negative values
6098     if ( options.active < 0 ) {
6099     options.active += this.headers.length;
6100     }
6101     this._refresh();
6102     },
6103    
6104     _getCreateEventData: function() {
6105     return {
6106     header: this.active,
6107     panel: !this.active.length ? $() : this.active.next(),
6108     content: !this.active.length ? $() : this.active.next()
6109     };
6110     },
6111    
6112     _createIcons: function() {
6113     var icons = this.options.icons;
6114     if ( icons ) {
6115     $( "<span>" )
6116     .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
6117     .prependTo( this.headers );
6118     this.active.children( ".ui-accordion-header-icon" )
6119     .removeClass( icons.header )
6120     .addClass( icons.activeHeader );
6121     this.headers.addClass( "ui-accordion-icons" );
6122     }
6123     },
6124    
6125     _destroyIcons: function() {
6126     this.headers
6127     .removeClass( "ui-accordion-icons" )
6128     .children( ".ui-accordion-header-icon" )
6129     .remove();
6130     },
6131    
6132     _destroy: function() {
6133     var contents;
6134    
6135     // clean up main element
6136     this.element
6137     .removeClass( "ui-accordion ui-widget ui-helper-reset" )
6138     .removeAttr( "role" );
6139    
6140     // clean up headers
6141     this.headers
6142     .removeClass( "ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
6143     .removeAttr( "role" )
6144     .removeAttr( "aria-selected" )
6145     .removeAttr( "aria-controls" )
6146     .removeAttr( "tabIndex" )
6147     .each(function() {
6148     if ( /^ui-accordion/.test( this.id ) ) {
6149     this.removeAttribute( "id" );
6150     }
6151     });
6152     this._destroyIcons();
6153    
6154     // clean up content panels
6155     contents = this.headers.next()
6156     .css( "display", "" )
6157     .removeAttr( "role" )
6158     .removeAttr( "aria-expanded" )
6159     .removeAttr( "aria-hidden" )
6160     .removeAttr( "aria-labelledby" )
6161     .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
6162     .each(function() {
6163     if ( /^ui-accordion/.test( this.id ) ) {
6164     this.removeAttribute( "id" );
6165     }
6166     });
6167     if ( this.options.heightStyle !== "content" ) {
6168     contents.css( "height", "" );
6169     }
6170     },
6171    
6172     _setOption: function( key, value ) {
6173     if ( key === "active" ) {
6174     // _activate() will handle invalid values and update this.options
6175     this._activate( value );
6176     return;
6177     }
6178    
6179     if ( key === "event" ) {
6180     if ( this.options.event ) {
6181     this._off( this.headers, this.options.event );
6182     }
6183     this._setupEvents( value );
6184     }
6185    
6186     this._super( key, value );
6187    
6188     // setting collapsible: false while collapsed; open first panel
6189     if ( key === "collapsible" && !value && this.options.active === false ) {
6190     this._activate( 0 );
6191     }
6192    
6193     if ( key === "icons" ) {
6194     this._destroyIcons();
6195     if ( value ) {
6196     this._createIcons();
6197     }
6198     }
6199    
6200     // #5332 - opacity doesn't cascade to positioned elements in IE
6201     // so we need to add the disabled class to the headers and panels
6202     if ( key === "disabled" ) {
6203     this.headers.add( this.headers.next() )
6204     .toggleClass( "ui-state-disabled", !!value );
6205     }
6206     },
6207    
6208     _keydown: function( event ) {
6209     /*jshint maxcomplexity:15*/
6210     if ( event.altKey || event.ctrlKey ) {
6211     return;
6212     }
6213    
6214     var keyCode = $.ui.keyCode,
6215     length = this.headers.length,
6216     currentIndex = this.headers.index( event.target ),
6217     toFocus = false;
6218    
6219     switch ( event.keyCode ) {
6220     case keyCode.RIGHT:
6221     case keyCode.DOWN:
6222     toFocus = this.headers[ ( currentIndex + 1 ) % length ];
6223     break;
6224     case keyCode.LEFT:
6225     case keyCode.UP:
6226     toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
6227     break;
6228     case keyCode.SPACE:
6229     case keyCode.ENTER:
6230     this._eventHandler( event );
6231     break;
6232     case keyCode.HOME:
6233     toFocus = this.headers[ 0 ];
6234     break;
6235     case keyCode.END:
6236     toFocus = this.headers[ length - 1 ];
6237     break;
6238     }
6239    
6240     if ( toFocus ) {
6241     $( event.target ).attr( "tabIndex", -1 );
6242     $( toFocus ).attr( "tabIndex", 0 );
6243     toFocus.focus();
6244     event.preventDefault();
6245     }
6246     },
6247    
6248     _panelKeyDown : function( event ) {
6249     if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
6250     $( event.currentTarget ).prev().focus();
6251     }
6252     },
6253    
6254     refresh: function() {
6255     var options = this.options;
6256     this._processPanels();
6257    
6258     // was collapsed or no panel
6259     if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
6260     options.active = false;
6261     this.active = $();
6262     // active false only when collapsible is true
6263     } else if ( options.active === false ) {
6264     this._activate( 0 );
6265     // was active, but active panel is gone
6266     } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
6267     // all remaining panel are disabled
6268     if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
6269     options.active = false;
6270     this.active = $();
6271     // activate previous panel
6272     } else {
6273     this._activate( Math.max( 0, options.active - 1 ) );
6274     }
6275     // was active, active panel still exists
6276     } else {
6277     // make sure active index is correct
6278     options.active = this.headers.index( this.active );
6279     }
6280    
6281     this._destroyIcons();
6282    
6283     this._refresh();
6284     },
6285    
6286     _processPanels: function() {
6287     this.headers = this.element.find( this.options.header )
6288     .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
6289    
6290     this.headers.next()
6291     .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
6292     .filter(":not(.ui-accordion-content-active)")
6293     .hide();
6294     },
6295    
6296     _refresh: function() {
6297     var maxHeight,
6298     options = this.options,
6299     heightStyle = options.heightStyle,
6300     parent = this.element.parent(),
6301     accordionId = this.accordionId = "ui-accordion-" +
6302     (this.element.attr( "id" ) || ++uid);
6303    
6304     this.active = this._findActive( options.active )
6305     .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
6306     .removeClass( "ui-corner-all" );
6307     this.active.next()
6308     .addClass( "ui-accordion-content-active" )
6309     .show();
6310    
6311     this.headers
6312     .attr( "role", "tab" )
6313     .each(function( i ) {
6314     var header = $( this ),
6315     headerId = header.attr( "id" ),
6316     panel = header.next(),
6317     panelId = panel.attr( "id" );
6318     if ( !headerId ) {
6319     headerId = accordionId + "-header-" + i;
6320     header.attr( "id", headerId );
6321     }
6322     if ( !panelId ) {
6323     panelId = accordionId + "-panel-" + i;
6324     panel.attr( "id", panelId );
6325     }
6326     header.attr( "aria-controls", panelId );
6327     panel.attr( "aria-labelledby", headerId );
6328     })
6329     .next()
6330     .attr( "role", "tabpanel" );
6331    
6332     this.headers
6333     .not( this.active )
6334     .attr({
6335     "aria-selected": "false",
6336     tabIndex: -1
6337     })
6338     .next()
6339     .attr({
6340     "aria-expanded": "false",
6341     "aria-hidden": "true"
6342     })
6343     .hide();
6344    
6345     // make sure at least one header is in the tab order
6346     if ( !this.active.length ) {
6347     this.headers.eq( 0 ).attr( "tabIndex", 0 );
6348     } else {
6349     this.active.attr({
6350     "aria-selected": "true",
6351     tabIndex: 0
6352     })
6353     .next()
6354     .attr({
6355     "aria-expanded": "true",
6356     "aria-hidden": "false"
6357     });
6358     }
6359    
6360     this._createIcons();
6361    
6362     this._setupEvents( options.event );
6363    
6364     if ( heightStyle === "fill" ) {
6365     maxHeight = parent.height();
6366     this.element.siblings( ":visible" ).each(function() {
6367     var elem = $( this ),
6368     position = elem.css( "position" );
6369    
6370     if ( position === "absolute" || position === "fixed" ) {
6371     return;
6372     }
6373     maxHeight -= elem.outerHeight( true );
6374     });
6375    
6376     this.headers.each(function() {
6377     maxHeight -= $( this ).outerHeight( true );
6378     });
6379    
6380     this.headers.next()
6381     .each(function() {
6382     $( this ).height( Math.max( 0, maxHeight -
6383     $( this ).innerHeight() + $( this ).height() ) );
6384     })
6385     .css( "overflow", "auto" );
6386     } else if ( heightStyle === "auto" ) {
6387     maxHeight = 0;
6388     this.headers.next()
6389     .each(function() {
6390     maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
6391     })
6392     .height( maxHeight );
6393     }
6394     },
6395    
6396     _activate: function( index ) {
6397     var active = this._findActive( index )[ 0 ];
6398    
6399     // trying to activate the already active panel
6400     if ( active === this.active[ 0 ] ) {
6401     return;
6402     }
6403    
6404     // trying to collapse, simulate a click on the currently active header
6405     active = active || this.active[ 0 ];
6406    
6407     this._eventHandler({
6408     target: active,
6409     currentTarget: active,
6410     preventDefault: $.noop
6411     });
6412     },
6413    
6414     _findActive: function( selector ) {
6415     return typeof selector === "number" ? this.headers.eq( selector ) : $();
6416     },
6417    
6418     _setupEvents: function( event ) {
6419     var events = {
6420     keydown: "_keydown"
6421     };
6422     if ( event ) {
6423     $.each( event.split(" "), function( index, eventName ) {
6424     events[ eventName ] = "_eventHandler";
6425     });
6426     }
6427    
6428     this._off( this.headers.add( this.headers.next() ) );
6429     this._on( this.headers, events );
6430     this._on( this.headers.next(), { keydown: "_panelKeyDown" });
6431     this._hoverable( this.headers );
6432     this._focusable( this.headers );
6433     },
6434    
6435     _eventHandler: function( event ) {
6436     var options = this.options,
6437     active = this.active,
6438     clicked = $( event.currentTarget ),
6439     clickedIsActive = clicked[ 0 ] === active[ 0 ],
6440     collapsing = clickedIsActive && options.collapsible,
6441     toShow = collapsing ? $() : clicked.next(),
6442     toHide = active.next(),
6443     eventData = {
6444     oldHeader: active,
6445     oldPanel: toHide,
6446     newHeader: collapsing ? $() : clicked,
6447     newPanel: toShow
6448     };
6449    
6450     event.preventDefault();
6451    
6452     if (
6453     // click on active header, but not collapsible
6454     ( clickedIsActive && !options.collapsible ) ||
6455     // allow canceling activation
6456     ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
6457     return;
6458     }
6459    
6460     options.active = collapsing ? false : this.headers.index( clicked );
6461    
6462     // when the call to ._toggle() comes after the class changes
6463     // it causes a very odd bug in IE 8 (see #6720)
6464     this.active = clickedIsActive ? $() : clicked;
6465     this._toggle( eventData );
6466    
6467     // switch classes
6468     // corner classes on the previously active header stay after the animation
6469     active.removeClass( "ui-accordion-header-active ui-state-active" );
6470     if ( options.icons ) {
6471     active.children( ".ui-accordion-header-icon" )
6472     .removeClass( options.icons.activeHeader )
6473     .addClass( options.icons.header );
6474     }
6475    
6476     if ( !clickedIsActive ) {
6477     clicked
6478     .removeClass( "ui-corner-all" )
6479     .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
6480     if ( options.icons ) {
6481     clicked.children( ".ui-accordion-header-icon" )
6482     .removeClass( options.icons.header )
6483     .addClass( options.icons.activeHeader );
6484     }
6485    
6486     clicked
6487     .next()
6488     .addClass( "ui-accordion-content-active" );
6489     }
6490     },
6491    
6492     _toggle: function( data ) {
6493     var toShow = data.newPanel,
6494     toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
6495    
6496     // handle activating a panel during the animation for another activation
6497     this.prevShow.add( this.prevHide ).stop( true, true );
6498     this.prevShow = toShow;
6499     this.prevHide = toHide;
6500    
6501     if ( this.options.animate ) {
6502     this._animate( toShow, toHide, data );
6503     } else {
6504     toHide.hide();
6505     toShow.show();
6506     this._toggleComplete( data );
6507     }
6508    
6509     toHide.attr({
6510     "aria-expanded": "false",
6511     "aria-hidden": "true"
6512     });
6513     toHide.prev().attr( "aria-selected", "false" );
6514     // if we're switching panels, remove the old header from the tab order
6515     // if we're opening from collapsed state, remove the previous header from the tab order
6516     // if we're collapsing, then keep the collapsing header in the tab order
6517     if ( toShow.length && toHide.length ) {
6518     toHide.prev().attr( "tabIndex", -1 );
6519     } else if ( toShow.length ) {
6520     this.headers.filter(function() {
6521     return $( this ).attr( "tabIndex" ) === 0;
6522     })
6523     .attr( "tabIndex", -1 );
6524     }
6525    
6526     toShow
6527     .attr({
6528     "aria-expanded": "true",
6529     "aria-hidden": "false"
6530     })
6531     .prev()
6532     .attr({
6533     "aria-selected": "true",
6534     tabIndex: 0
6535     });
6536     },
6537    
6538     _animate: function( toShow, toHide, data ) {
6539     var total, easing, duration,
6540     that = this,
6541     adjust = 0,
6542     down = toShow.length &&
6543     ( !toHide.length || ( toShow.index() < toHide.index() ) ),
6544     animate = this.options.animate || {},
6545     options = down && animate.down || animate,
6546     complete = function() {
6547     that._toggleComplete( data );
6548     };
6549    
6550     if ( typeof options === "number" ) {
6551     duration = options;
6552     }
6553     if ( typeof options === "string" ) {
6554     easing = options;
6555     }
6556     // fall back from options to animation in case of partial down settings
6557     easing = easing || options.easing || animate.easing;
6558     duration = duration || options.duration || animate.duration;
6559    
6560     if ( !toHide.length ) {
6561     return toShow.animate( showProps, duration, easing, complete );
6562     }
6563     if ( !toShow.length ) {
6564     return toHide.animate( hideProps, duration, easing, complete );
6565     }
6566    
6567     total = toShow.show().outerHeight();
6568     toHide.animate( hideProps, {
6569     duration: duration,
6570     easing: easing,
6571     step: function( now, fx ) {
6572     fx.now = Math.round( now );
6573     }
6574     });
6575     toShow
6576     .hide()
6577     .animate( showProps, {
6578     duration: duration,
6579     easing: easing,
6580     complete: complete,
6581     step: function( now, fx ) {
6582     fx.now = Math.round( now );
6583     if ( fx.prop !== "height" ) {
6584     adjust += fx.now;
6585     } else if ( that.options.heightStyle !== "content" ) {
6586     fx.now = Math.round( total - toHide.outerHeight() - adjust );
6587     adjust = 0;
6588     }
6589     }
6590     });
6591     },
6592    
6593     _toggleComplete: function( data ) {
6594     var toHide = data.oldPanel;
6595    
6596     toHide
6597     .removeClass( "ui-accordion-content-active" )
6598     .prev()
6599     .removeClass( "ui-corner-top" )
6600     .addClass( "ui-corner-all" );
6601    
6602     // Work around for rendering bug in IE (#5421)
6603     if ( toHide.length ) {
6604     toHide.parent()[0].className = toHide.parent()[0].className;
6605     }
6606    
6607     this._trigger( "activate", null, data );
6608     }
6609     });
6610    
6611     })( jQuery );
6612    
6613     (function( $, undefined ) {
6614    
6615     // used to prevent race conditions with remote data sources
6616     var requestIndex = 0;
6617    
6618     $.widget( "ui.autocomplete", {
6619     version: "1.10.3",
6620     defaultElement: "<input>",
6621     options: {
6622     appendTo: null,
6623     autoFocus: false,
6624     delay: 300,
6625     minLength: 1,
6626     position: {
6627     my: "left top",
6628     at: "left bottom",
6629     collision: "none"
6630     },
6631     source: null,
6632    
6633     // callbacks
6634     change: null,
6635     close: null,
6636     focus: null,
6637     open: null,
6638     response: null,
6639     search: null,
6640     select: null
6641     },
6642    
6643     pending: 0,
6644    
6645     _create: function() {
6646     // Some browsers only repeat keydown events, not keypress events,
6647     // so we use the suppressKeyPress flag to determine if we've already
6648     // handled the keydown event. #7269
6649     // Unfortunately the code for & in keypress is the same as the up arrow,
6650     // so we use the suppressKeyPressRepeat flag to avoid handling keypress
6651     // events when we know the keydown event was used to modify the
6652     // search term. #7799
6653     var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
6654     nodeName = this.element[0].nodeName.toLowerCase(),
6655     isTextarea = nodeName === "textarea",
6656     isInput = nodeName === "input";
6657    
6658     this.isMultiLine =
6659     // Textareas are always multi-line
6660     isTextarea ? true :
6661     // Inputs are always single-line, even if inside a contentEditable element
6662     // IE also treats inputs as contentEditable
6663     isInput ? false :
6664     // All other element types are determined by whether or not they're contentEditable
6665     this.element.prop( "isContentEditable" );
6666    
6667     this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
6668     this.isNewMenu = true;
6669    
6670     this.element
6671     .addClass( "ui-autocomplete-input" )
6672     .attr( "autocomplete", "off" );
6673    
6674     this._on( this.element, {
6675     keydown: function( event ) {
6676     /*jshint maxcomplexity:15*/
6677     if ( this.element.prop( "readOnly" ) ) {
6678     suppressKeyPress = true;
6679     suppressInput = true;
6680     suppressKeyPressRepeat = true;
6681     return;
6682     }
6683    
6684     suppressKeyPress = false;
6685     suppressInput = false;
6686     suppressKeyPressRepeat = false;
6687     var keyCode = $.ui.keyCode;
6688     switch( event.keyCode ) {
6689     case keyCode.PAGE_UP:
6690     suppressKeyPress = true;
6691     this._move( "previousPage", event );
6692     break;
6693     case keyCode.PAGE_DOWN:
6694     suppressKeyPress = true;
6695     this._move( "nextPage", event );
6696     break;
6697     case keyCode.UP:
6698     suppressKeyPress = true;
6699     this._keyEvent( "previous", event );
6700     break;
6701     case keyCode.DOWN:
6702     suppressKeyPress = true;
6703     this._keyEvent( "next", event );
6704     break;
6705     case keyCode.ENTER:
6706     case keyCode.NUMPAD_ENTER:
6707     // when menu is open and has focus
6708     if ( this.menu.active ) {
6709     // #6055 - Opera still allows the keypress to occur
6710     // which causes forms to submit
6711     suppressKeyPress = true;
6712     event.preventDefault();
6713     this.menu.select( event );
6714     }
6715     break;
6716     case keyCode.TAB:
6717     if ( this.menu.active ) {
6718     this.menu.select( event );
6719     }
6720     break;
6721     case keyCode.ESCAPE:
6722     if ( this.menu.element.is( ":visible" ) ) {
6723     this._value( this.term );
6724     this.close( event );
6725     // Different browsers have different default behavior for escape
6726     // Single press can mean undo or clear
6727     // Double press in IE means clear the whole form
6728     event.preventDefault();
6729     }
6730     break;
6731     default:
6732     suppressKeyPressRepeat = true;
6733     // search timeout should be triggered before the input value is changed
6734     this._searchTimeout( event );
6735     break;
6736     }
6737     },
6738     keypress: function( event ) {
6739     if ( suppressKeyPress ) {
6740     suppressKeyPress = false;
6741     if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
6742     event.preventDefault();
6743     }
6744     return;
6745     }
6746     if ( suppressKeyPressRepeat ) {
6747     return;
6748     }
6749    
6750     // replicate some key handlers to allow them to repeat in Firefox and Opera
6751     var keyCode = $.ui.keyCode;
6752     switch( event.keyCode ) {
6753     case keyCode.PAGE_UP:
6754     this._move( "previousPage", event );
6755     break;
6756     case keyCode.PAGE_DOWN:
6757     this._move( "nextPage", event );
6758     break;
6759     case keyCode.UP:
6760     this._keyEvent( "previous", event );
6761     break;
6762     case keyCode.DOWN:
6763     this._keyEvent( "next", event );
6764     break;
6765     }
6766     },
6767     input: function( event ) {
6768     if ( suppressInput ) {
6769     suppressInput = false;
6770     event.preventDefault();
6771     return;
6772     }
6773     this._searchTimeout( event );
6774     },
6775     focus: function() {
6776     this.selectedItem = null;
6777     this.previous = this._value();
6778     },
6779     blur: function( event ) {
6780     if ( this.cancelBlur ) {
6781     delete this.cancelBlur;
6782     return;
6783     }
6784    
6785     clearTimeout( this.searching );
6786     this.close( event );
6787     this._change( event );
6788     }
6789     });
6790    
6791     this._initSource();
6792     this.menu = $( "<ul>" )
6793     .addClass( "ui-autocomplete ui-front" )
6794     .appendTo( this._appendTo() )
6795     .menu({
6796     // disable ARIA support, the live region takes care of that
6797     role: null
6798     })
6799     .hide()
6800     .data( "ui-menu" );
6801    
6802     this._on( this.menu.element, {
6803     mousedown: function( event ) {
6804     // prevent moving focus out of the text field
6805     event.preventDefault();
6806    
6807     // IE doesn't prevent moving focus even with event.preventDefault()
6808     // so we set a flag to know when we should ignore the blur event
6809     this.cancelBlur = true;
6810     this._delay(function() {
6811     delete this.cancelBlur;
6812     });
6813    
6814     // clicking on the scrollbar causes focus to shift to the body
6815     // but we can't detect a mouseup or a click immediately afterward
6816     // so we have to track the next mousedown and close the menu if
6817     // the user clicks somewhere outside of the autocomplete
6818     var menuElement = this.menu.element[ 0 ];
6819     if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
6820     this._delay(function() {
6821     var that = this;
6822     this.document.one( "mousedown", function( event ) {
6823     if ( event.target !== that.element[ 0 ] &&
6824     event.target !== menuElement &&
6825     !$.contains( menuElement, event.target ) ) {
6826     that.close();
6827     }
6828     });
6829     });
6830     }
6831     },
6832     menufocus: function( event, ui ) {
6833     // support: Firefox
6834     // Prevent accidental activation of menu items in Firefox (#7024 #9118)
6835     if ( this.isNewMenu ) {
6836     this.isNewMenu = false;
6837     if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
6838     this.menu.blur();
6839    
6840     this.document.one( "mousemove", function() {
6841     $( event.target ).trigger( event.originalEvent );
6842     });
6843    
6844     return;
6845     }
6846     }
6847    
6848     var item = ui.item.data( "ui-autocomplete-item" );
6849     if ( false !== this._trigger( "focus", event, { item: item } ) ) {
6850     // use value to match what will end up in the input, if it was a key event
6851     if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
6852     this._value( item.value );
6853     }
6854     } else {
6855     // Normally the input is populated with the item's value as the
6856     // menu is navigated, causing screen readers to notice a change and
6857     // announce the item. Since the focus event was canceled, this doesn't
6858     // happen, so we update the live region so that screen readers can
6859     // still notice the change and announce it.
6860     this.liveRegion.text( item.value );
6861     }
6862     },
6863     menuselect: function( event, ui ) {
6864     var item = ui.item.data( "ui-autocomplete-item" ),
6865     previous = this.previous;
6866    
6867     // only trigger when focus was lost (click on menu)
6868     if ( this.element[0] !== this.document[0].activeElement ) {
6869     this.element.focus();
6870     this.previous = previous;
6871     // #6109 - IE triggers two focus events and the second
6872     // is asynchronous, so we need to reset the previous
6873     // term synchronously and asynchronously :-(
6874     this._delay(function() {
6875     this.previous = previous;
6876     this.selectedItem = item;
6877     });
6878     }
6879    
6880     if ( false !== this._trigger( "select", event, { item: item } ) ) {
6881     this._value( item.value );
6882     }
6883     // reset the term after the select event
6884     // this allows custom select handling to work properly
6885     this.term = this._value();
6886    
6887     this.close( event );
6888     this.selectedItem = item;
6889     }
6890     });
6891    
6892     this.liveRegion = $( "<span>", {
6893     role: "status",
6894     "aria-live": "polite"
6895     })
6896     .addClass( "ui-helper-hidden-accessible" )
6897     .insertBefore( this.element );
6898    
6899     // turning off autocomplete prevents the browser from remembering the
6900     // value when navigating through history, so we re-enable autocomplete
6901     // if the page is unloaded before the widget is destroyed. #7790
6902     this._on( this.window, {
6903     beforeunload: function() {
6904     this.element.removeAttr( "autocomplete" );
6905     }
6906     });
6907     },
6908    
6909     _destroy: function() {
6910     clearTimeout( this.searching );
6911     this.element
6912     .removeClass( "ui-autocomplete-input" )
6913     .removeAttr( "autocomplete" );
6914     this.menu.element.remove();
6915     this.liveRegion.remove();
6916     },
6917    
6918     _setOption: function( key, value ) {
6919     this._super( key, value );
6920     if ( key === "source" ) {
6921     this._initSource();
6922     }
6923     if ( key === "appendTo" ) {
6924     this.menu.element.appendTo( this._appendTo() );
6925     }
6926     if ( key === "disabled" && value && this.xhr ) {
6927     this.xhr.abort();
6928     }
6929     },
6930    
6931     _appendTo: function() {
6932     var element = this.options.appendTo;
6933    
6934     if ( element ) {
6935     element = element.jquery || element.nodeType ?
6936     $( element ) :
6937     this.document.find( element ).eq( 0 );
6938     }
6939    
6940     if ( !element ) {
6941     element = this.element.closest( ".ui-front" );
6942     }
6943    
6944     if ( !element.length ) {
6945     element = this.document[0].body;
6946     }
6947    
6948     return element;
6949     },
6950    
6951     _initSource: function() {
6952     var array, url,
6953     that = this;
6954     if ( $.isArray(this.options.source) ) {
6955     array = this.options.source;
6956     this.source = function( request, response ) {
6957     response( $.ui.autocomplete.filter( array, request.term ) );
6958     };
6959     } else if ( typeof this.options.source === "string" ) {
6960     url = this.options.source;
6961     this.source = function( request, response ) {
6962     if ( that.xhr ) {
6963     that.xhr.abort();
6964     }
6965     that.xhr = $.ajax({
6966     url: url,
6967     data: request,
6968     dataType: "json",
6969     success: function( data ) {
6970     response( data );
6971     },
6972     error: function() {
6973     response( [] );
6974     }
6975     });
6976     };
6977     } else {
6978     this.source = this.options.source;
6979     }
6980     },
6981    
6982     _searchTimeout: function( event ) {
6983     clearTimeout( this.searching );
6984     this.searching = this._delay(function() {
6985     // only search if the value has changed
6986     if ( this.term !== this._value() ) {
6987     this.selectedItem = null;
6988     this.search( null, event );
6989     }
6990     }, this.options.delay );
6991     },
6992    
6993     search: function( value, event ) {
6994     value = value != null ? value : this._value();
6995    
6996     // always save the actual value, not the one passed as an argument
6997     this.term = this._value();
6998    
6999     if ( value.length < this.options.minLength ) {
7000     return this.close( event );
7001     }
7002    
7003     if ( this._trigger( "search", event ) === false ) {
7004     return;
7005     }
7006    
7007     return this._search( value );
7008     },
7009    
7010     _search: function( value ) {
7011     this.pending++;
7012     this.element.addClass( "ui-autocomplete-loading" );
7013     this.cancelSearch = false;
7014    
7015     this.source( { term: value }, this._response() );
7016     },
7017    
7018     _response: function() {
7019     var that = this,
7020     index = ++requestIndex;
7021    
7022     return function( content ) {
7023     if ( index === requestIndex ) {
7024     that.__response( content );
7025     }
7026    
7027     that.pending--;
7028     if ( !that.pending ) {
7029     that.element.removeClass( "ui-autocomplete-loading" );
7030     }
7031     };
7032     },
7033    
7034     __response: function( content ) {
7035     if ( content ) {
7036     content = this._normalize( content );
7037     }
7038     this._trigger( "response", null, { content: content } );
7039     if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
7040     this._suggest( content );
7041     this._trigger( "open" );
7042     } else {
7043     // use ._close() instead of .close() so we don't cancel future searches
7044     this._close();
7045     }
7046     },
7047    
7048     close: function( event ) {
7049     this.cancelSearch = true;
7050     this._close( event );
7051     },
7052    
7053     _close: function( event ) {
7054     if ( this.menu.element.is( ":visible" ) ) {
7055     this.menu.element.hide();
7056     this.menu.blur();
7057     this.isNewMenu = true;
7058     this._trigger( "close", event );
7059     }
7060     },
7061    
7062     _change: function( event ) {
7063     if ( this.previous !== this._value() ) {
7064     this._trigger( "change", event, { item: this.selectedItem } );
7065     }
7066     },
7067    
7068     _normalize: function( items ) {
7069     // assume all items have the right format when the first item is complete
7070     if ( items.length && items[0].label && items[0].value ) {
7071     return items;
7072     }
7073     return $.map( items, function( item ) {
7074     if ( typeof item === "string" ) {
7075     return {
7076     label: item,
7077     value: item
7078     };
7079     }
7080     return $.extend({
7081     label: item.label || item.value,
7082     value: item.value || item.label
7083     }, item );
7084     });
7085     },
7086    
7087     _suggest: function( items ) {
7088     var ul = this.menu.element.empty();
7089     this._renderMenu( ul, items );
7090     this.isNewMenu = true;
7091     this.menu.refresh();
7092    
7093     // size and position menu
7094     ul.show();
7095     this._resizeMenu();
7096     ul.position( $.extend({
7097     of: this.element
7098     }, this.options.position ));
7099    
7100     if ( this.options.autoFocus ) {
7101     this.menu.next();
7102     }
7103     },
7104    
7105     _resizeMenu: function() {
7106     var ul = this.menu.element;
7107     ul.outerWidth( Math.max(
7108     // Firefox wraps long text (possibly a rounding bug)
7109     // so we add 1px to avoid the wrapping (#7513)
7110     ul.width( "" ).outerWidth() + 1,
7111     this.element.outerWidth()
7112     ) );
7113     },
7114    
7115     _renderMenu: function( ul, items ) {
7116     var that = this;
7117     $.each( items, function( index, item ) {
7118     that._renderItemData( ul, item );
7119     });
7120     },
7121    
7122     _renderItemData: function( ul, item ) {
7123     return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
7124     },
7125    
7126     _renderItem: function( ul, item ) {
7127     return $( "<li>" )
7128     .append( $( "<a>" ).text( item.label ) )
7129     .appendTo( ul );
7130     },
7131    
7132     _move: function( direction, event ) {
7133     if ( !this.menu.element.is( ":visible" ) ) {
7134     this.search( null, event );
7135     return;
7136     }
7137     if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
7138     this.menu.isLastItem() && /^next/.test( direction ) ) {
7139     this._value( this.term );
7140     this.menu.blur();
7141     return;
7142     }
7143     this.menu[ direction ]( event );
7144     },
7145    
7146     widget: function() {
7147     return this.menu.element;
7148     },
7149    
7150     _value: function() {
7151     return this.valueMethod.apply( this.element, arguments );
7152     },
7153    
7154     _keyEvent: function( keyEvent, event ) {
7155     if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
7156     this._move( keyEvent, event );
7157    
7158     // prevents moving cursor to beginning/end of the text field in some browsers
7159     event.preventDefault();
7160     }
7161     }
7162     });
7163    
7164     $.extend( $.ui.autocomplete, {
7165     escapeRegex: function( value ) {
7166     return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
7167     },
7168     filter: function(array, term) {
7169     var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
7170     return $.grep( array, function(value) {
7171     return matcher.test( value.label || value.value || value );
7172     });
7173     }
7174     });
7175    
7176    
7177     // live region extension, adding a `messages` option
7178     // NOTE: This is an experimental API. We are still investigating
7179     // a full solution for string manipulation and internationalization.
7180     $.widget( "ui.autocomplete", $.ui.autocomplete, {
7181     options: {
7182     messages: {
7183     noResults: "No search results.",
7184     results: function( amount ) {
7185     return amount + ( amount > 1 ? " results are" : " result is" ) +
7186     " available, use up and down arrow keys to navigate.";
7187     }
7188     }
7189     },
7190    
7191     __response: function( content ) {
7192     var message;
7193     this._superApply( arguments );
7194     if ( this.options.disabled || this.cancelSearch ) {
7195     return;
7196     }
7197     if ( content && content.length ) {
7198     message = this.options.messages.results( content.length );
7199     } else {
7200     message = this.options.messages.noResults;
7201     }
7202     this.liveRegion.text( message );
7203     }
7204     });
7205    
7206     }( jQuery ));
7207    
7208     (function( $, undefined ) {
7209    
7210     var lastActive, startXPos, startYPos, clickDragged,
7211     baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
7212     stateClasses = "ui-state-hover ui-state-active ",
7213     typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
7214     formResetHandler = function() {
7215     var form = $( this );
7216     setTimeout(function() {
7217     form.find( ":ui-button" ).button( "refresh" );
7218     }, 1 );
7219     },
7220     radioGroup = function( radio ) {
7221     var name = radio.name,
7222     form = radio.form,
7223     radios = $( [] );
7224     if ( name ) {
7225     name = name.replace( /'/g, "\\'" );
7226     if ( form ) {
7227     radios = $( form ).find( "[name='" + name + "']" );
7228     } else {
7229     radios = $( "[name='" + name + "']", radio.ownerDocument )
7230     .filter(function() {
7231     return !this.form;
7232     });
7233     }
7234     }
7235     return radios;
7236     };
7237    
7238     $.widget( "ui.button", {
7239     version: "1.10.3",
7240     defaultElement: "<button>",
7241     options: {
7242     disabled: null,
7243     text: true,
7244     label: null,
7245     icons: {
7246     primary: null,
7247     secondary: null
7248     }
7249     },
7250     _create: function() {
7251     this.element.closest( "form" )
7252     .unbind( "reset" + this.eventNamespace )
7253     .bind( "reset" + this.eventNamespace, formResetHandler );
7254    
7255     if ( typeof this.options.disabled !== "boolean" ) {
7256     this.options.disabled = !!this.element.prop( "disabled" );
7257     } else {
7258     this.element.prop( "disabled", this.options.disabled );
7259     }
7260    
7261     this._determineButtonType();
7262     this.hasTitle = !!this.buttonElement.attr( "title" );
7263    
7264     var that = this,
7265     options = this.options,
7266     toggleButton = this.type === "checkbox" || this.type === "radio",
7267     activeClass = !toggleButton ? "ui-state-active" : "",
7268     focusClass = "ui-state-focus";
7269    
7270     if ( options.label === null ) {
7271     options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
7272     }
7273    
7274     this._hoverable( this.buttonElement );
7275    
7276     this.buttonElement
7277     .addClass( baseClasses )
7278     .attr( "role", "button" )
7279     .bind( "mouseenter" + this.eventNamespace, function() {
7280     if ( options.disabled ) {
7281     return;
7282     }
7283     if ( this === lastActive ) {
7284     $( this ).addClass( "ui-state-active" );
7285     }
7286     })
7287     .bind( "mouseleave" + this.eventNamespace, function() {
7288     if ( options.disabled ) {
7289     return;
7290     }
7291     $( this ).removeClass( activeClass );
7292     })
7293     .bind( "click" + this.eventNamespace, function( event ) {
7294     if ( options.disabled ) {
7295     event.preventDefault();
7296     event.stopImmediatePropagation();
7297     }
7298     });
7299    
7300     this.element
7301     .bind( "focus" + this.eventNamespace, function() {
7302     // no need to check disabled, focus won't be triggered anyway
7303     that.buttonElement.addClass( focusClass );
7304     })
7305     .bind( "blur" + this.eventNamespace, function() {
7306     that.buttonElement.removeClass( focusClass );
7307     });
7308    
7309     if ( toggleButton ) {
7310     this.element.bind( "change" + this.eventNamespace, function() {
7311     if ( clickDragged ) {
7312     return;
7313     }
7314     that.refresh();
7315     });
7316     // if mouse moves between mousedown and mouseup (drag) set clickDragged flag
7317     // prevents issue where button state changes but checkbox/radio checked state
7318     // does not in Firefox (see ticket #6970)
7319     this.buttonElement
7320     .bind( "mousedown" + this.eventNamespace, function( event ) {
7321     if ( options.disabled ) {
7322     return;
7323     }
7324     clickDragged = false;
7325     startXPos = event.pageX;
7326     startYPos = event.pageY;
7327     })
7328     .bind( "mouseup" + this.eventNamespace, function( event ) {
7329     if ( options.disabled ) {
7330     return;
7331     }
7332     if ( startXPos !== event.pageX || startYPos !== event.pageY ) {
7333     clickDragged = true;
7334     }
7335     });
7336     }
7337    
7338     if ( this.type === "checkbox" ) {
7339     this.buttonElement.bind( "click" + this.eventNamespace, function() {
7340     if ( options.disabled || clickDragged ) {
7341     return false;
7342     }
7343     });
7344     } else if ( this.type === "radio" ) {
7345     this.buttonElement.bind( "click" + this.eventNamespace, function() {
7346     if ( options.disabled || clickDragged ) {
7347     return false;
7348     }
7349     $( this ).addClass( "ui-state-active" );
7350     that.buttonElement.attr( "aria-pressed", "true" );
7351    
7352     var radio = that.element[ 0 ];
7353     radioGroup( radio )
7354     .not( radio )
7355     .map(function() {
7356     return $( this ).button( "widget" )[ 0 ];
7357     })
7358     .removeClass( "ui-state-active" )
7359     .attr( "aria-pressed", "false" );
7360     });
7361     } else {
7362     this.buttonElement
7363     .bind( "mousedown" + this.eventNamespace, function() {
7364     if ( options.disabled ) {
7365     return false;
7366     }
7367     $( this ).addClass( "ui-state-active" );
7368     lastActive = this;
7369     that.document.one( "mouseup", function() {
7370     lastActive = null;
7371     });
7372     })
7373     .bind( "mouseup" + this.eventNamespace, function() {
7374     if ( options.disabled ) {
7375     return false;
7376     }
7377     $( this ).removeClass( "ui-state-active" );
7378     })
7379     .bind( "keydown" + this.eventNamespace, function(event) {
7380     if ( options.disabled ) {
7381     return false;
7382     }
7383     if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
7384     $( this ).addClass( "ui-state-active" );
7385     }
7386     })
7387     // see #8559, we bind to blur here in case the button element loses
7388     // focus between keydown and keyup, it would be left in an "active" state
7389     .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
7390     $( this ).removeClass( "ui-state-active" );
7391     });
7392    
7393     if ( this.buttonElement.is("a") ) {
7394     this.buttonElement.keyup(function(event) {
7395     if ( event.keyCode === $.ui.keyCode.SPACE ) {
7396     // TODO pass through original event correctly (just as 2nd argument doesn't work)
7397     $( this ).click();
7398     }
7399     });
7400     }
7401     }
7402    
7403     // TODO: pull out $.Widget's handling for the disabled option into
7404     // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
7405     // be overridden by individual plugins
7406     this._setOption( "disabled", options.disabled );
7407     this._resetButton();
7408     },
7409    
7410     _determineButtonType: function() {
7411     var ancestor, labelSelector, checked;
7412    
7413     if ( this.element.is("[type=checkbox]") ) {
7414     this.type = "checkbox";
7415     } else if ( this.element.is("[type=radio]") ) {
7416     this.type = "radio";
7417     } else if ( this.element.is("input") ) {
7418     this.type = "input";
7419     } else {
7420     this.type = "button";
7421     }
7422    
7423     if ( this.type === "checkbox" || this.type === "radio" ) {
7424     // we don't search against the document in case the element
7425     // is disconnected from the DOM
7426     ancestor = this.element.parents().last();
7427     labelSelector = "label[for='" + this.element.attr("id") + "']";
7428     this.buttonElement = ancestor.find( labelSelector );
7429     if ( !this.buttonElement.length ) {
7430     ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
7431     this.buttonElement = ancestor.filter( labelSelector );
7432     if ( !this.buttonElement.length ) {
7433     this.buttonElement = ancestor.find( labelSelector );
7434     }
7435     }
7436     this.element.addClass( "ui-helper-hidden-accessible" );
7437    
7438     checked = this.element.is( ":checked" );
7439     if ( checked ) {
7440     this.buttonElement.addClass( "ui-state-active" );
7441     }
7442     this.buttonElement.prop( "aria-pressed", checked );
7443     } else {
7444     this.buttonElement = this.element;
7445     }
7446     },
7447    
7448     widget: function() {
7449     return this.buttonElement;
7450     },
7451    
7452     _destroy: function() {
7453     this.element
7454     .removeClass( "ui-helper-hidden-accessible" );
7455     this.buttonElement
7456     .removeClass( baseClasses + " " + stateClasses + " " + typeClasses )
7457     .removeAttr( "role" )
7458     .removeAttr( "aria-pressed" )
7459     .html( this.buttonElement.find(".ui-button-text").html() );
7460    
7461     if ( !this.hasTitle ) {
7462     this.buttonElement.removeAttr( "title" );
7463     }
7464     },
7465    
7466     _setOption: function( key, value ) {
7467     this._super( key, value );
7468     if ( key === "disabled" ) {
7469     if ( value ) {
7470     this.element.prop( "disabled", true );
7471     } else {
7472     this.element.prop( "disabled", false );
7473     }
7474     return;
7475     }
7476     this._resetButton();
7477     },
7478    
7479     refresh: function() {
7480     //See #8237 & #8828
7481     var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
7482    
7483     if ( isDisabled !== this.options.disabled ) {
7484     this._setOption( "disabled", isDisabled );
7485     }
7486     if ( this.type === "radio" ) {
7487     radioGroup( this.element[0] ).each(function() {
7488     if ( $( this ).is( ":checked" ) ) {
7489     $( this ).button( "widget" )
7490     .addClass( "ui-state-active" )
7491     .attr( "aria-pressed", "true" );
7492     } else {
7493     $( this ).button( "widget" )
7494     .removeClass( "ui-state-active" )
7495     .attr( "aria-pressed", "false" );
7496     }
7497     });
7498     } else if ( this.type === "checkbox" ) {
7499     if ( this.element.is( ":checked" ) ) {
7500     this.buttonElement
7501     .addClass( "ui-state-active" )
7502     .attr( "aria-pressed", "true" );
7503     } else {
7504     this.buttonElement
7505     .removeClass( "ui-state-active" )
7506     .attr( "aria-pressed", "false" );
7507     }
7508     }
7509     },
7510    
7511     _resetButton: function() {
7512     if ( this.type === "input" ) {
7513     if ( this.options.label ) {
7514     this.element.val( this.options.label );
7515     }
7516     return;
7517     }
7518     var buttonElement = this.buttonElement.removeClass( typeClasses ),
7519     buttonText = $( "<span></span>", this.document[0] )
7520     .addClass( "ui-button-text" )
7521     .html( this.options.label )
7522     .appendTo( buttonElement.empty() )
7523     .text(),
7524     icons = this.options.icons,
7525     multipleIcons = icons.primary && icons.secondary,
7526     buttonClasses = [];
7527    
7528     if ( icons.primary || icons.secondary ) {
7529     if ( this.options.text ) {
7530     buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
7531     }
7532    
7533     if ( icons.primary ) {
7534     buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
7535     }
7536    
7537     if ( icons.secondary ) {
7538     buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
7539     }
7540    
7541     if ( !this.options.text ) {
7542     buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
7543    
7544     if ( !this.hasTitle ) {
7545     buttonElement.attr( "title", $.trim( buttonText ) );
7546     }
7547     }
7548     } else {
7549     buttonClasses.push( "ui-button-text-only" );
7550     }
7551     buttonElement.addClass( buttonClasses.join( " " ) );
7552     }
7553     });
7554    
7555     $.widget( "ui.buttonset", {
7556     version: "1.10.3",
7557     options: {
7558     items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
7559     },
7560    
7561     _create: function() {
7562     this.element.addClass( "ui-buttonset" );
7563     },
7564    
7565     _init: function() {
7566     this.refresh();
7567     },
7568    
7569     _setOption: function( key, value ) {
7570     if ( key === "disabled" ) {
7571     this.buttons.button( "option", key, value );
7572     }
7573    
7574     this._super( key, value );
7575     },
7576    
7577     refresh: function() {
7578     var rtl = this.element.css( "direction" ) === "rtl";
7579    
7580     this.buttons = this.element.find( this.options.items )
7581     .filter( ":ui-button" )
7582     .button( "refresh" )
7583     .end()
7584     .not( ":ui-button" )
7585     .button()
7586     .end()
7587     .map(function() {
7588     return $( this ).button( "widget" )[ 0 ];
7589     })
7590     .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
7591     .filter( ":first" )
7592     .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
7593     .end()
7594     .filter( ":last" )
7595     .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
7596     .end()
7597     .end();
7598     },
7599    
7600     _destroy: function() {
7601     this.element.removeClass( "ui-buttonset" );
7602     this.buttons
7603     .map(function() {
7604     return $( this ).button( "widget" )[ 0 ];
7605     })
7606     .removeClass( "ui-corner-left ui-corner-right" )
7607     .end()
7608     .button( "destroy" );
7609     }
7610     });
7611    
7612     }( jQuery ) );
7613    
7614     (function( $, undefined ) {
7615    
7616     $.extend($.ui, { datepicker: { version: "1.10.3" } });
7617    
7618     var PROP_NAME = "datepicker",
7619     instActive;
7620    
7621     /* Date picker manager.
7622     Use the singleton instance of this class, $.datepicker, to interact with the date picker.
7623     Settings for (groups of) date pickers are maintained in an instance object,
7624     allowing multiple different settings on the same page. */
7625    
7626     function Datepicker() {
7627     this._curInst = null; // The current instance in use
7628     this._keyEvent = false; // If the last event was a key event
7629     this._disabledInputs = []; // List of date picker inputs that have been disabled
7630     this._datepickerShowing = false; // True if the popup picker is showing , false if not
7631     this._inDialog = false; // True if showing within a "dialog", false if not
7632     this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
7633     this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
7634     this._appendClass = "ui-datepicker-append"; // The name of the append marker class
7635     this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
7636     this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
7637     this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
7638     this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
7639     this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
7640     this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
7641     this.regional = []; // Available regional settings, indexed by language code
7642     this.regional[""] = { // Default regional settings
7643     closeText: "Done", // Display text for close link
7644     prevText: "Prev", // Display text for previous month link
7645     nextText: "Next", // Display text for next month link
7646     currentText: "Today", // Display text for current month link
7647     monthNames: ["January","February","March","April","May","June",
7648     "July","August","September","October","November","December"], // Names of months for drop-down and formatting
7649     monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
7650     dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
7651     dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
7652     dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
7653     weekHeader: "Wk", // Column header for week of the year
7654     dateFormat: "mm/dd/yy", // See format options on parseDate
7655     firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
7656     isRTL: false, // True if right-to-left language, false if left-to-right
7657     showMonthAfterYear: false, // True if the year select precedes month, false for month then year
7658     yearSuffix: "" // Additional text to append to the year in the month headers
7659     };
7660     this._defaults = { // Global defaults for all the date picker instances
7661     showOn: "focus", // "focus" for popup on focus,
7662     // "button" for trigger button, or "both" for either
7663     showAnim: "fadeIn", // Name of jQuery animation for popup
7664     showOptions: {}, // Options for enhanced animations
7665     defaultDate: null, // Used when field is blank: actual date,
7666     // +/-number for offset from today, null for today
7667     appendText: "", // Display text following the input box, e.g. showing the format
7668     buttonText: "...", // Text for trigger button
7669     buttonImage: "", // URL for trigger button image
7670     buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
7671     hideIfNoPrevNext: false, // True to hide next/previous month links
7672     // if not applicable, false to just disable them
7673     navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
7674     gotoCurrent: false, // True if today link goes back to current selection instead
7675     changeMonth: false, // True if month can be selected directly, false if only prev/next
7676     changeYear: false, // True if year can be selected directly, false if only prev/next
7677     yearRange: "c-10:c+10", // Range of years to display in drop-down,
7678     // either relative to today's year (-nn:+nn), relative to currently displayed year
7679     // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
7680     showOtherMonths: false, // True to show dates in other months, false to leave blank
7681     selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
7682     showWeek: false, // True to show week of the year, false to not show it
7683     calculateWeek: this.iso8601Week, // How to calculate the week of the year,
7684     // takes a Date and returns the number of the week for it
7685     shortYearCutoff: "+10", // Short year values < this are in the current century,
7686     // > this are in the previous century,
7687     // string value starting with "+" for current year + value
7688     minDate: null, // The earliest selectable date, or null for no limit
7689     maxDate: null, // The latest selectable date, or null for no limit
7690     duration: "fast", // Duration of display/closure
7691     beforeShowDay: null, // Function that takes a date and returns an array with
7692     // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
7693     // [2] = cell title (optional), e.g. $.datepicker.noWeekends
7694     beforeShow: null, // Function that takes an input field and
7695     // returns a set of custom settings for the date picker
7696     onSelect: null, // Define a callback function when a date is selected
7697     onChangeMonthYear: null, // Define a callback function when the month or year is changed
7698     onClose: null, // Define a callback function when the datepicker is closed
7699     numberOfMonths: 1, // Number of months to show at a time
7700     showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
7701     stepMonths: 1, // Number of months to step back/forward
7702     stepBigMonths: 12, // Number of months to step back/forward for the big links
7703     altField: "", // Selector for an alternate field to store selected dates into
7704     altFormat: "", // The date format to use for the alternate field
7705     constrainInput: true, // The input is constrained by the current date format
7706     showButtonPanel: false, // True to show button panel, false to not show it
7707     autoSize: false, // True to size the input for the date format, false to leave as is
7708     disabled: false // The initial disabled state
7709     };
7710     $.extend(this._defaults, this.regional[""]);
7711     this.dpDiv = bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
7712     }
7713    
7714     $.extend(Datepicker.prototype, {
7715     /* Class name added to elements to indicate already configured with a date picker. */
7716     markerClassName: "hasDatepicker",
7717    
7718     //Keep track of the maximum number of rows displayed (see #7043)
7719     maxRows: 4,
7720    
7721     // TODO rename to "widget" when switching to widget factory
7722     _widgetDatepicker: function() {
7723     return this.dpDiv;
7724     },
7725    
7726     /* Override the default settings for all instances of the date picker.
7727     * @param settings object - the new settings to use as defaults (anonymous object)
7728     * @return the manager object
7729     */
7730     setDefaults: function(settings) {
7731     extendRemove(this._defaults, settings || {});
7732     return this;
7733     },
7734    
7735     /* Attach the date picker to a jQuery selection.
7736     * @param target element - the target input field or division or span
7737     * @param settings object - the new settings to use for this date picker instance (anonymous)
7738     */
7739     _attachDatepicker: function(target, settings) {
7740     var nodeName, inline, inst;
7741     nodeName = target.nodeName.toLowerCase();
7742     inline = (nodeName === "div" || nodeName === "span");
7743     if (!target.id) {
7744     this.uuid += 1;
7745     target.id = "dp" + this.uuid;
7746     }
7747     inst = this._newInst($(target), inline);
7748     inst.settings = $.extend({}, settings || {});
7749     if (nodeName === "input") {
7750     this._connectDatepicker(target, inst);
7751     } else if (inline) {
7752     this._inlineDatepicker(target, inst);
7753     }
7754     },
7755    
7756     /* Create a new instance object. */
7757     _newInst: function(target, inline) {
7758     var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
7759     return {id: id, input: target, // associated target
7760     selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
7761     drawMonth: 0, drawYear: 0, // month being drawn
7762     inline: inline, // is datepicker inline or not
7763     dpDiv: (!inline ? this.dpDiv : // presentation div
7764     bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
7765     },
7766    
7767     /* Attach the date picker to an input field. */
7768     _connectDatepicker: function(target, inst) {
7769     var input = $(target);
7770     inst.append = $([]);
7771     inst.trigger = $([]);
7772     if (input.hasClass(this.markerClassName)) {
7773     return;
7774     }
7775     this._attachments(input, inst);
7776     input.addClass(this.markerClassName).keydown(this._doKeyDown).
7777     keypress(this._doKeyPress).keyup(this._doKeyUp);
7778     this._autoSize(inst);
7779     $.data(target, PROP_NAME, inst);
7780     //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
7781     if( inst.settings.disabled ) {
7782     this._disableDatepicker( target );
7783     }
7784     },
7785    
7786     /* Make attachments based on settings. */
7787     _attachments: function(input, inst) {
7788     var showOn, buttonText, buttonImage,
7789     appendText = this._get(inst, "appendText"),
7790     isRTL = this._get(inst, "isRTL");
7791    
7792     if (inst.append) {
7793     inst.append.remove();
7794     }
7795     if (appendText) {
7796     inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
7797     input[isRTL ? "before" : "after"](inst.append);
7798     }
7799    
7800     input.unbind("focus", this._showDatepicker);
7801    
7802     if (inst.trigger) {
7803     inst.trigger.remove();
7804     }
7805    
7806     showOn = this._get(inst, "showOn");
7807     if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
7808     input.focus(this._showDatepicker);
7809     }
7810     if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
7811     buttonText = this._get(inst, "buttonText");
7812     buttonImage = this._get(inst, "buttonImage");
7813     inst.trigger = $(this._get(inst, "buttonImageOnly") ?
7814     $("<img/>").addClass(this._triggerClass).
7815     attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
7816     $("<button type='button'></button>").addClass(this._triggerClass).
7817     html(!buttonImage ? buttonText : $("<img/>").attr(
7818     { src:buttonImage, alt:buttonText, title:buttonText })));
7819     input[isRTL ? "before" : "after"](inst.trigger);
7820     inst.trigger.click(function() {
7821     if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
7822     $.datepicker._hideDatepicker();
7823     } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
7824     $.datepicker._hideDatepicker();
7825     $.datepicker._showDatepicker(input[0]);
7826     } else {
7827     $.datepicker._showDatepicker(input[0]);
7828     }
7829     return false;
7830     });
7831     }
7832     },
7833    
7834     /* Apply the maximum length for the date format. */
7835     _autoSize: function(inst) {
7836     if (this._get(inst, "autoSize") && !inst.inline) {
7837     var findMax, max, maxI, i,
7838     date = new Date(2009, 12 - 1, 20), // Ensure double digits
7839     dateFormat = this._get(inst, "dateFormat");
7840    
7841     if (dateFormat.match(/[DM]/)) {
7842     findMax = function(names) {
7843     max = 0;
7844     maxI = 0;
7845     for (i = 0; i < names.length; i++) {
7846     if (names[i].length > max) {
7847     max = names[i].length;
7848     maxI = i;
7849     }
7850     }
7851     return maxI;
7852     };
7853     date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
7854     "monthNames" : "monthNamesShort"))));
7855     date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
7856     "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
7857     }
7858     inst.input.attr("size", this._formatDate(inst, date).length);
7859     }
7860     },
7861    
7862     /* Attach an inline date picker to a div. */
7863     _inlineDatepicker: function(target, inst) {
7864     var divSpan = $(target);
7865     if (divSpan.hasClass(this.markerClassName)) {
7866     return;
7867     }
7868     divSpan.addClass(this.markerClassName).append(inst.dpDiv);
7869     $.data(target, PROP_NAME, inst);
7870     this._setDate(inst, this._getDefaultDate(inst), true);
7871     this._updateDatepicker(inst);
7872     this._updateAlternate(inst);
7873     //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
7874     if( inst.settings.disabled ) {
7875     this._disableDatepicker( target );
7876     }
7877     // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
7878     // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
7879     inst.dpDiv.css( "display", "block" );
7880     },
7881    
7882     /* Pop-up the date picker in a "dialog" box.
7883     * @param input element - ignored
7884     * @param date string or Date - the initial date to display
7885     * @param onSelect function - the function to call when a date is selected
7886     * @param settings object - update the dialog date picker instance's settings (anonymous object)
7887     * @param pos int[2] - coordinates for the dialog's position within the screen or
7888     * event - with x/y coordinates or
7889     * leave empty for default (screen centre)
7890     * @return the manager object
7891     */
7892     _dialogDatepicker: function(input, date, onSelect, settings, pos) {
7893     var id, browserWidth, browserHeight, scrollX, scrollY,
7894     inst = this._dialogInst; // internal instance
7895    
7896     if (!inst) {
7897     this.uuid += 1;
7898     id = "dp" + this.uuid;
7899     this._dialogInput = $("<input type='text' id='" + id +
7900     "' style='position: absolute; top: -100px; width: 0px;'/>");
7901     this._dialogInput.keydown(this._doKeyDown);
7902     $("body").append(this._dialogInput);
7903     inst = this._dialogInst = this._newInst(this._dialogInput, false);
7904     inst.settings = {};
7905     $.data(this._dialogInput[0], PROP_NAME, inst);
7906     }
7907     extendRemove(inst.settings, settings || {});
7908     date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
7909     this._dialogInput.val(date);
7910    
7911     this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
7912     if (!this._pos) {
7913     browserWidth = document.documentElement.clientWidth;
7914     browserHeight = document.documentElement.clientHeight;
7915     scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
7916     scrollY = document.documentElement.scrollTop || document.body.scrollTop;
7917     this._pos = // should use actual width/height below
7918     [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
7919     }
7920    
7921     // move input on screen for focus, but hidden behind dialog
7922     this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
7923     inst.settings.onSelect = onSelect;
7924     this._inDialog = true;
7925     this.dpDiv.addClass(this._dialogClass);
7926     this._showDatepicker(this._dialogInput[0]);
7927     if ($.blockUI) {
7928     $.blockUI(this.dpDiv);
7929     }
7930     $.data(this._dialogInput[0], PROP_NAME, inst);
7931     return this;
7932     },
7933    
7934     /* Detach a datepicker from its control.
7935     * @param target element - the target input field or division or span
7936     */
7937     _destroyDatepicker: function(target) {
7938     var nodeName,
7939     $target = $(target),
7940     inst = $.data(target, PROP_NAME);
7941    
7942     if (!$target.hasClass(this.markerClassName)) {
7943     return;
7944     }
7945    
7946     nodeName = target.nodeName.toLowerCase();
7947     $.removeData(target, PROP_NAME);
7948     if (nodeName === "input") {
7949     inst.append.remove();
7950     inst.trigger.remove();
7951     $target.removeClass(this.markerClassName).
7952     unbind("focus", this._showDatepicker).
7953     unbind("keydown", this._doKeyDown).
7954     unbind("keypress", this._doKeyPress).
7955     unbind("keyup", this._doKeyUp);
7956     } else if (nodeName === "div" || nodeName === "span") {
7957     $target.removeClass(this.markerClassName).empty();
7958     }
7959     },
7960    
7961     /* Enable the date picker to a jQuery selection.
7962     * @param target element - the target input field or division or span
7963     */
7964     _enableDatepicker: function(target) {
7965     var nodeName, inline,
7966     $target = $(target),
7967     inst = $.data(target, PROP_NAME);
7968    
7969     if (!$target.hasClass(this.markerClassName)) {
7970     return;
7971     }
7972    
7973     nodeName = target.nodeName.toLowerCase();
7974     if (nodeName === "input") {
7975     target.disabled = false;
7976     inst.trigger.filter("button").
7977     each(function() { this.disabled = false; }).end().
7978     filter("img").css({opacity: "1.0", cursor: ""});
7979     } else if (nodeName === "div" || nodeName === "span") {
7980     inline = $target.children("." + this._inlineClass);
7981     inline.children().removeClass("ui-state-disabled");
7982     inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
7983     prop("disabled", false);
7984     }
7985     this._disabledInputs = $.map(this._disabledInputs,
7986     function(value) { return (value === target ? null : value); }); // delete entry
7987     },
7988    
7989     /* Disable the date picker to a jQuery selection.
7990     * @param target element - the target input field or division or span
7991     */
7992     _disableDatepicker: function(target) {
7993     var nodeName, inline,
7994     $target = $(target),
7995     inst = $.data(target, PROP_NAME);
7996    
7997     if (!$target.hasClass(this.markerClassName)) {
7998     return;
7999     }
8000    
8001     nodeName = target.nodeName.toLowerCase();
8002     if (nodeName === "input") {
8003     target.disabled = true;
8004     inst.trigger.filter("button").
8005     each(function() { this.disabled = true; }).end().
8006     filter("img").css({opacity: "0.5", cursor: "default"});
8007     } else if (nodeName === "div" || nodeName === "span") {
8008     inline = $target.children("." + this._inlineClass);
8009     inline.children().addClass("ui-state-disabled");
8010     inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
8011     prop("disabled", true);
8012     }
8013     this._disabledInputs = $.map(this._disabledInputs,
8014     function(value) { return (value === target ? null : value); }); // delete entry
8015     this._disabledInputs[this._disabledInputs.length] = target;
8016     },
8017    
8018     /* Is the first field in a jQuery collection disabled as a datepicker?
8019     * @param target element - the target input field or division or span
8020     * @return boolean - true if disabled, false if enabled
8021     */
8022     _isDisabledDatepicker: function(target) {
8023     if (!target) {
8024     return false;
8025     }
8026     for (var i = 0; i < this._disabledInputs.length; i++) {
8027     if (this._disabledInputs[i] === target) {
8028     return true;
8029     }
8030     }
8031     return false;
8032     },
8033    
8034     /* Retrieve the instance data for the target control.
8035     * @param target element - the target input field or division or span
8036     * @return object - the associated instance data
8037     * @throws error if a jQuery problem getting data
8038     */
8039     _getInst: function(target) {
8040     try {
8041     return $.data(target, PROP_NAME);
8042     }
8043     catch (err) {
8044     throw "Missing instance data for this datepicker";
8045     }
8046     },
8047    
8048     /* Update or retrieve the settings for a date picker attached to an input field or division.
8049     * @param target element - the target input field or division or span
8050     * @param name object - the new settings to update or
8051     * string - the name of the setting to change or retrieve,
8052     * when retrieving also "all" for all instance settings or
8053     * "defaults" for all global defaults
8054     * @param value any - the new value for the setting
8055     * (omit if above is an object or to retrieve a value)
8056     */
8057     _optionDatepicker: function(target, name, value) {
8058     var settings, date, minDate, maxDate,
8059     inst = this._getInst(target);
8060    
8061     if (arguments.length === 2 && typeof name === "string") {
8062     return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
8063     (inst ? (name === "all" ? $.extend({}, inst.settings) :
8064     this._get(inst, name)) : null));
8065     }
8066    
8067     settings = name || {};
8068     if (typeof name === "string") {
8069     settings = {};
8070     settings[name] = value;
8071     }
8072    
8073     if (inst) {
8074     if (this._curInst === inst) {
8075     this._hideDatepicker();
8076     }
8077    
8078     date = this._getDateDatepicker(target, true);
8079     minDate = this._getMinMaxDate(inst, "min");
8080     maxDate = this._getMinMaxDate(inst, "max");
8081     extendRemove(inst.settings, settings);
8082     // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
8083     if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
8084     inst.settings.minDate = this._formatDate(inst, minDate);
8085     }
8086     if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
8087     inst.settings.maxDate = this._formatDate(inst, maxDate);
8088     }
8089     if ( "disabled" in settings ) {
8090     if ( settings.disabled ) {
8091     this._disableDatepicker(target);
8092     } else {
8093     this._enableDatepicker(target);
8094     }
8095     }
8096     this._attachments($(target), inst);
8097     this._autoSize(inst);
8098     this._setDate(inst, date);
8099     this._updateAlternate(inst);
8100     this._updateDatepicker(inst);
8101     }
8102     },
8103    
8104     // change method deprecated
8105     _changeDatepicker: function(target, name, value) {
8106     this._optionDatepicker(target, name, value);
8107     },
8108    
8109     /* Redraw the date picker attached to an input field or division.
8110     * @param target element - the target input field or division or span
8111     */
8112     _refreshDatepicker: function(target) {
8113     var inst = this._getInst(target);
8114     if (inst) {
8115     this._updateDatepicker(inst);
8116     }
8117     },
8118    
8119     /* Set the dates for a jQuery selection.
8120     * @param target element - the target input field or division or span
8121     * @param date Date - the new date
8122     */
8123     _setDateDatepicker: function(target, date) {
8124     var inst = this._getInst(target);
8125     if (inst) {
8126     this._setDate(inst, date);
8127     this._updateDatepicker(inst);
8128     this._updateAlternate(inst);
8129     }
8130     },
8131    
8132     /* Get the date(s) for the first entry in a jQuery selection.
8133     * @param target element - the target input field or division or span
8134     * @param noDefault boolean - true if no default date is to be used
8135     * @return Date - the current date
8136     */
8137     _getDateDatepicker: function(target, noDefault) {
8138     var inst = this._getInst(target);
8139     if (inst && !inst.inline) {
8140     this._setDateFromField(inst, noDefault);
8141     }
8142     return (inst ? this._getDate(inst) : null);
8143     },
8144    
8145     /* Handle keystrokes. */
8146     _doKeyDown: function(event) {
8147     var onSelect, dateStr, sel,
8148     inst = $.datepicker._getInst(event.target),
8149     handled = true,
8150     isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
8151    
8152     inst._keyEvent = true;
8153     if ($.datepicker._datepickerShowing) {
8154     switch (event.keyCode) {
8155     case 9: $.datepicker._hideDatepicker();
8156     handled = false;
8157     break; // hide on tab out
8158     case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
8159     $.datepicker._currentClass + ")", inst.dpDiv);
8160     if (sel[0]) {
8161     $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
8162     }
8163    
8164     onSelect = $.datepicker._get(inst, "onSelect");
8165     if (onSelect) {
8166     dateStr = $.datepicker._formatDate(inst);
8167    
8168     // trigger custom callback
8169     onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
8170     } else {
8171     $.datepicker._hideDatepicker();
8172     }
8173    
8174     return false; // don't submit the form
8175     case 27: $.datepicker._hideDatepicker();
8176     break; // hide on escape
8177     case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8178     -$.datepicker._get(inst, "stepBigMonths") :
8179     -$.datepicker._get(inst, "stepMonths")), "M");
8180     break; // previous month/year on page up/+ ctrl
8181     case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8182     +$.datepicker._get(inst, "stepBigMonths") :
8183     +$.datepicker._get(inst, "stepMonths")), "M");
8184     break; // next month/year on page down/+ ctrl
8185     case 35: if (event.ctrlKey || event.metaKey) {
8186     $.datepicker._clearDate(event.target);
8187     }
8188     handled = event.ctrlKey || event.metaKey;
8189     break; // clear on ctrl or command +end
8190     case 36: if (event.ctrlKey || event.metaKey) {
8191     $.datepicker._gotoToday(event.target);
8192     }
8193     handled = event.ctrlKey || event.metaKey;
8194     break; // current on ctrl or command +home
8195     case 37: if (event.ctrlKey || event.metaKey) {
8196     $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
8197     }
8198     handled = event.ctrlKey || event.metaKey;
8199     // -1 day on ctrl or command +left
8200     if (event.originalEvent.altKey) {
8201     $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8202     -$.datepicker._get(inst, "stepBigMonths") :
8203     -$.datepicker._get(inst, "stepMonths")), "M");
8204     }
8205     // next month/year on alt +left on Mac
8206     break;
8207     case 38: if (event.ctrlKey || event.metaKey) {
8208     $.datepicker._adjustDate(event.target, -7, "D");
8209     }
8210     handled = event.ctrlKey || event.metaKey;
8211     break; // -1 week on ctrl or command +up
8212     case 39: if (event.ctrlKey || event.metaKey) {
8213     $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
8214     }
8215     handled = event.ctrlKey || event.metaKey;
8216     // +1 day on ctrl or command +right
8217     if (event.originalEvent.altKey) {
8218     $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8219     +$.datepicker._get(inst, "stepBigMonths") :
8220     +$.datepicker._get(inst, "stepMonths")), "M");
8221     }
8222     // next month/year on alt +right
8223     break;
8224     case 40: if (event.ctrlKey || event.metaKey) {
8225     $.datepicker._adjustDate(event.target, +7, "D");
8226     }
8227     handled = event.ctrlKey || event.metaKey;
8228     break; // +1 week on ctrl or command +down
8229     default: handled = false;
8230     }
8231     } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
8232     $.datepicker._showDatepicker(this);
8233     } else {
8234     handled = false;
8235     }
8236    
8237     if (handled) {
8238     event.preventDefault();
8239     event.stopPropagation();
8240     }
8241     },
8242    
8243     /* Filter entered characters - based on date format. */
8244     _doKeyPress: function(event) {
8245     var chars, chr,
8246     inst = $.datepicker._getInst(event.target);
8247    
8248     if ($.datepicker._get(inst, "constrainInput")) {
8249     chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
8250     chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
8251     return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
8252     }
8253     },
8254    
8255     /* Synchronise manual entry and field/alternate field. */
8256     _doKeyUp: function(event) {
8257     var date,
8258     inst = $.datepicker._getInst(event.target);
8259    
8260     if (inst.input.val() !== inst.lastVal) {
8261     try {
8262     date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
8263     (inst.input ? inst.input.val() : null),
8264     $.datepicker._getFormatConfig(inst));
8265    
8266     if (date) { // only if valid
8267     $.datepicker._setDateFromField(inst);
8268     $.datepicker._updateAlternate(inst);
8269     $.datepicker._updateDatepicker(inst);
8270     }
8271     }
8272     catch (err) {
8273     }
8274     }
8275     return true;
8276     },
8277    
8278     /* Pop-up the date picker for a given input field.
8279     * If false returned from beforeShow event handler do not show.
8280     * @param input element - the input field attached to the date picker or
8281     * event - if triggered by focus
8282     */
8283     _showDatepicker: function(input) {
8284     input = input.target || input;
8285     if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
8286     input = $("input", input.parentNode)[0];
8287     }
8288    
8289     if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
8290     return;
8291     }
8292    
8293     var inst, beforeShow, beforeShowSettings, isFixed,
8294     offset, showAnim, duration;
8295    
8296     inst = $.datepicker._getInst(input);
8297     if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
8298     $.datepicker._curInst.dpDiv.stop(true, true);
8299     if ( inst && $.datepicker._datepickerShowing ) {
8300     $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
8301     }
8302     }
8303    
8304     beforeShow = $.datepicker._get(inst, "beforeShow");
8305     beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
8306     if(beforeShowSettings === false){
8307     return;
8308     }
8309     extendRemove(inst.settings, beforeShowSettings);
8310    
8311     inst.lastVal = null;
8312     $.datepicker._lastInput = input;
8313     $.datepicker._setDateFromField(inst);
8314    
8315     if ($.datepicker._inDialog) { // hide cursor
8316     input.value = "";
8317     }
8318     if (!$.datepicker._pos) { // position below input
8319     $.datepicker._pos = $.datepicker._findPos(input);
8320     $.datepicker._pos[1] += input.offsetHeight; // add the height
8321     }
8322    
8323     isFixed = false;
8324     $(input).parents().each(function() {
8325     isFixed |= $(this).css("position") === "fixed";
8326     return !isFixed;
8327     });
8328    
8329     offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
8330     $.datepicker._pos = null;
8331     //to avoid flashes on Firefox
8332     inst.dpDiv.empty();
8333     // determine sizing offscreen
8334     inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
8335     $.datepicker._updateDatepicker(inst);
8336     // fix width for dynamic number of date pickers
8337     // and adjust position before showing
8338     offset = $.datepicker._checkOffset(inst, offset, isFixed);
8339     inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
8340     "static" : (isFixed ? "fixed" : "absolute")), display: "none",
8341     left: offset.left + "px", top: offset.top + "px"});
8342    
8343     if (!inst.inline) {
8344     showAnim = $.datepicker._get(inst, "showAnim");
8345     duration = $.datepicker._get(inst, "duration");
8346     inst.dpDiv.zIndex($(input).zIndex()+1);
8347     $.datepicker._datepickerShowing = true;
8348    
8349     if ( $.effects && $.effects.effect[ showAnim ] ) {
8350     inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
8351     } else {
8352     inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
8353     }
8354    
8355     if ( $.datepicker._shouldFocusInput( inst ) ) {
8356     inst.input.focus();
8357     }
8358    
8359     $.datepicker._curInst = inst;
8360     }
8361     },
8362    
8363     /* Generate the date picker content. */
8364     _updateDatepicker: function(inst) {
8365     this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
8366     instActive = inst; // for delegate hover events
8367     inst.dpDiv.empty().append(this._generateHTML(inst));
8368     this._attachHandlers(inst);
8369     inst.dpDiv.find("." + this._dayOverClass + " a").mouseover();
8370    
8371     var origyearshtml,
8372     numMonths = this._getNumberOfMonths(inst),
8373     cols = numMonths[1],
8374     width = 17;
8375    
8376     inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
8377     if (cols > 1) {
8378     inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
8379     }
8380     inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
8381     "Class"]("ui-datepicker-multi");
8382     inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
8383     "Class"]("ui-datepicker-rtl");
8384    
8385     if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
8386     inst.input.focus();
8387     }
8388    
8389     // deffered render of the years select (to avoid flashes on Firefox)
8390     if( inst.yearshtml ){
8391     origyearshtml = inst.yearshtml;
8392     setTimeout(function(){
8393     //assure that inst.yearshtml didn't change.
8394     if( origyearshtml === inst.yearshtml && inst.yearshtml ){
8395     inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
8396     }
8397     origyearshtml = inst.yearshtml = null;
8398     }, 0);
8399     }
8400     },
8401    
8402     // #6694 - don't focus the input if it's already focused
8403     // this breaks the change event in IE
8404     // Support: IE and jQuery <1.9
8405     _shouldFocusInput: function( inst ) {
8406     return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
8407     },
8408    
8409     /* Check positioning to remain on screen. */
8410     _checkOffset: function(inst, offset, isFixed) {
8411     var dpWidth = inst.dpDiv.outerWidth(),
8412     dpHeight = inst.dpDiv.outerHeight(),
8413     inputWidth = inst.input ? inst.input.outerWidth() : 0,
8414     inputHeight = inst.input ? inst.input.outerHeight() : 0,
8415     viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
8416     viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
8417    
8418     offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
8419     offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
8420     offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
8421    
8422     // now check if datepicker is showing outside window viewport - move to a better place if so.
8423     offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
8424     Math.abs(offset.left + dpWidth - viewWidth) : 0);
8425     offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
8426     Math.abs(dpHeight + inputHeight) : 0);
8427    
8428     return offset;
8429     },
8430    
8431     /* Find an object's position on the screen. */
8432     _findPos: function(obj) {
8433     var position,
8434     inst = this._getInst(obj),
8435     isRTL = this._get(inst, "isRTL");
8436    
8437     while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
8438     obj = obj[isRTL ? "previousSibling" : "nextSibling"];
8439     }
8440    
8441     position = $(obj).offset();
8442     return [position.left, position.top];
8443     },
8444    
8445     /* Hide the date picker from view.
8446     * @param input element - the input field attached to the date picker
8447     */
8448     _hideDatepicker: function(input) {
8449     var showAnim, duration, postProcess, onClose,
8450     inst = this._curInst;
8451    
8452     if (!inst || (input && inst !== $.data(input, PROP_NAME))) {
8453     return;
8454     }
8455    
8456     if (this._datepickerShowing) {
8457     showAnim = this._get(inst, "showAnim");
8458     duration = this._get(inst, "duration");
8459     postProcess = function() {
8460     $.datepicker._tidyDialog(inst);
8461     };
8462    
8463     // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
8464     if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
8465     inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
8466     } else {
8467     inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
8468     (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
8469     }
8470    
8471     if (!showAnim) {
8472     postProcess();
8473     }
8474     this._datepickerShowing = false;
8475    
8476     onClose = this._get(inst, "onClose");
8477     if (onClose) {
8478     onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
8479     }
8480    
8481     this._lastInput = null;
8482     if (this._inDialog) {
8483     this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
8484     if ($.blockUI) {
8485     $.unblockUI();
8486     $("body").append(this.dpDiv);
8487     }
8488     }
8489     this._inDialog = false;
8490     }
8491     },
8492    
8493     /* Tidy up after a dialog display. */
8494     _tidyDialog: function(inst) {
8495     inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
8496     },
8497    
8498     /* Close date picker if clicked elsewhere. */
8499     _checkExternalClick: function(event) {
8500     if (!$.datepicker._curInst) {
8501     return;
8502     }
8503    
8504     var $target = $(event.target),
8505     inst = $.datepicker._getInst($target[0]);
8506    
8507     if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
8508     $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
8509     !$target.hasClass($.datepicker.markerClassName) &&
8510     !$target.closest("." + $.datepicker._triggerClass).length &&
8511     $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
8512     ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
8513     $.datepicker._hideDatepicker();
8514     }
8515     },
8516    
8517     /* Adjust one of the date sub-fields. */
8518     _adjustDate: function(id, offset, period) {
8519     var target = $(id),
8520     inst = this._getInst(target[0]);
8521    
8522     if (this._isDisabledDatepicker(target[0])) {
8523     return;
8524     }
8525     this._adjustInstDate(inst, offset +
8526     (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
8527     period);
8528     this._updateDatepicker(inst);
8529     },
8530    
8531     /* Action for current link. */
8532     _gotoToday: function(id) {
8533     var date,
8534     target = $(id),
8535     inst = this._getInst(target[0]);
8536    
8537     if (this._get(inst, "gotoCurrent") && inst.currentDay) {
8538     inst.selectedDay = inst.currentDay;
8539     inst.drawMonth = inst.selectedMonth = inst.currentMonth;
8540     inst.drawYear = inst.selectedYear = inst.currentYear;
8541     } else {
8542     date = new Date();
8543     inst.selectedDay = date.getDate();
8544     inst.drawMonth = inst.selectedMonth = date.getMonth();
8545     inst.drawYear = inst.selectedYear = date.getFullYear();
8546     }
8547     this._notifyChange(inst);
8548     this._adjustDate(target);
8549     },
8550    
8551     /* Action for selecting a new month/year. */
8552     _selectMonthYear: function(id, select, period) {
8553     var target = $(id),
8554     inst = this._getInst(target[0]);
8555    
8556     inst["selected" + (period === "M" ? "Month" : "Year")] =
8557     inst["draw" + (period === "M" ? "Month" : "Year")] =
8558     parseInt(select.options[select.selectedIndex].value,10);
8559    
8560     this._notifyChange(inst);
8561     this._adjustDate(target);
8562     },
8563    
8564     /* Action for selecting a day. */
8565     _selectDay: function(id, month, year, td) {
8566     var inst,
8567     target = $(id);
8568    
8569     if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
8570     return;
8571     }
8572    
8573     inst = this._getInst(target[0]);
8574     inst.selectedDay = inst.currentDay = $("a", td).html();
8575     inst.selectedMonth = inst.currentMonth = month;
8576     inst.selectedYear = inst.currentYear = year;
8577     this._selectDate(id, this._formatDate(inst,
8578     inst.currentDay, inst.currentMonth, inst.currentYear));
8579     },
8580    
8581     /* Erase the input field and hide the date picker. */
8582     _clearDate: function(id) {
8583     var target = $(id);
8584     this._selectDate(target, "");
8585     },
8586    
8587     /* Update the input field with the selected date. */
8588     _selectDate: function(id, dateStr) {
8589     var onSelect,
8590     target = $(id),
8591     inst = this._getInst(target[0]);
8592    
8593     dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
8594     if (inst.input) {
8595     inst.input.val(dateStr);
8596     }
8597     this._updateAlternate(inst);
8598    
8599     onSelect = this._get(inst, "onSelect");
8600     if (onSelect) {
8601     onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
8602     } else if (inst.input) {
8603     inst.input.trigger("change"); // fire the change event
8604     }
8605    
8606     if (inst.inline){
8607     this._updateDatepicker(inst);
8608     } else {
8609     this._hideDatepicker();
8610     this._lastInput = inst.input[0];
8611     if (typeof(inst.input[0]) !== "object") {
8612     inst.input.focus(); // restore focus
8613     }
8614     this._lastInput = null;
8615     }
8616     },
8617    
8618     /* Update any alternate field to synchronise with the main field. */
8619     _updateAlternate: function(inst) {
8620     var altFormat, date, dateStr,
8621     altField = this._get(inst, "altField");
8622    
8623     if (altField) { // update alternate field too
8624     altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
8625     date = this._getDate(inst);
8626     dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
8627     $(altField).each(function() { $(this).val(dateStr); });
8628     }
8629     },
8630    
8631     /* Set as beforeShowDay function to prevent selection of weekends.
8632     * @param date Date - the date to customise
8633     * @return [boolean, string] - is this date selectable?, what is its CSS class?
8634     */
8635     noWeekends: function(date) {
8636     var day = date.getDay();
8637     return [(day > 0 && day < 6), ""];
8638     },
8639    
8640     /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
8641     * @param date Date - the date to get the week for
8642     * @return number - the number of the week within the year that contains this date
8643     */
8644     iso8601Week: function(date) {
8645     var time,
8646     checkDate = new Date(date.getTime());
8647    
8648     // Find Thursday of this week starting on Monday
8649     checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
8650    
8651     time = checkDate.getTime();
8652     checkDate.setMonth(0); // Compare with Jan 1
8653     checkDate.setDate(1);
8654     return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
8655     },
8656    
8657     /* Parse a string value into a date object.
8658     * See formatDate below for the possible formats.
8659     *
8660     * @param format string - the expected format of the date
8661     * @param value string - the date in the above format
8662     * @param settings Object - attributes include:
8663     * shortYearCutoff number - the cutoff year for determining the century (optional)
8664     * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
8665     * dayNames string[7] - names of the days from Sunday (optional)
8666     * monthNamesShort string[12] - abbreviated names of the months (optional)
8667     * monthNames string[12] - names of the months (optional)
8668     * @return Date - the extracted date value or null if value is blank
8669     */
8670     parseDate: function (format, value, settings) {
8671     if (format == null || value == null) {
8672     throw "Invalid arguments";
8673     }
8674    
8675     value = (typeof value === "object" ? value.toString() : value + "");
8676     if (value === "") {
8677     return null;
8678     }
8679    
8680     var iFormat, dim, extra,
8681     iValue = 0,
8682     shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
8683     shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
8684     new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
8685     dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8686     dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8687     monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8688     monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8689     year = -1,
8690     month = -1,
8691     day = -1,
8692     doy = -1,
8693     literal = false,
8694     date,
8695     // Check whether a format character is doubled
8696     lookAhead = function(match) {
8697     var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8698     if (matches) {
8699     iFormat++;
8700     }
8701     return matches;
8702     },
8703     // Extract a number from the string value
8704     getNumber = function(match) {
8705     var isDoubled = lookAhead(match),
8706     size = (match === "@" ? 14 : (match === "!" ? 20 :
8707     (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
8708     digits = new RegExp("^\\d{1," + size + "}"),
8709     num = value.substring(iValue).match(digits);
8710     if (!num) {
8711     throw "Missing number at position " + iValue;
8712     }
8713     iValue += num[0].length;
8714     return parseInt(num[0], 10);
8715     },
8716     // Extract a name from the string value and convert to an index
8717     getName = function(match, shortNames, longNames) {
8718     var index = -1,
8719     names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
8720     return [ [k, v] ];
8721     }).sort(function (a, b) {
8722     return -(a[1].length - b[1].length);
8723     });
8724    
8725     $.each(names, function (i, pair) {
8726     var name = pair[1];
8727     if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
8728     index = pair[0];
8729     iValue += name.length;
8730     return false;
8731     }
8732     });
8733     if (index !== -1) {
8734     return index + 1;
8735     } else {
8736     throw "Unknown name at position " + iValue;
8737     }
8738     },
8739     // Confirm that a literal character matches the string value
8740     checkLiteral = function() {
8741     if (value.charAt(iValue) !== format.charAt(iFormat)) {
8742     throw "Unexpected literal at position " + iValue;
8743     }
8744     iValue++;
8745     };
8746    
8747     for (iFormat = 0; iFormat < format.length; iFormat++) {
8748     if (literal) {
8749     if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8750     literal = false;
8751     } else {
8752     checkLiteral();
8753     }
8754     } else {
8755     switch (format.charAt(iFormat)) {
8756     case "d":
8757     day = getNumber("d");
8758     break;
8759     case "D":
8760     getName("D", dayNamesShort, dayNames);
8761     break;
8762     case "o":
8763     doy = getNumber("o");
8764     break;
8765     case "m":
8766     month = getNumber("m");
8767     break;
8768     case "M":
8769     month = getName("M", monthNamesShort, monthNames);
8770     break;
8771     case "y":
8772     year = getNumber("y");
8773     break;
8774     case "@":
8775     date = new Date(getNumber("@"));
8776     year = date.getFullYear();
8777     month = date.getMonth() + 1;
8778     day = date.getDate();
8779     break;
8780     case "!":
8781     date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
8782     year = date.getFullYear();
8783     month = date.getMonth() + 1;
8784     day = date.getDate();
8785     break;
8786     case "'":
8787     if (lookAhead("'")){
8788     checkLiteral();
8789     } else {
8790     literal = true;
8791     }
8792     break;
8793     default:
8794     checkLiteral();
8795     }
8796     }
8797     }
8798    
8799     if (iValue < value.length){
8800     extra = value.substr(iValue);
8801     if (!/^\s+/.test(extra)) {
8802     throw "Extra/unparsed characters found in date: " + extra;
8803     }
8804     }
8805    
8806     if (year === -1) {
8807     year = new Date().getFullYear();
8808     } else if (year < 100) {
8809     year += new Date().getFullYear() - new Date().getFullYear() % 100 +
8810     (year <= shortYearCutoff ? 0 : -100);
8811     }
8812    
8813     if (doy > -1) {
8814     month = 1;
8815     day = doy;
8816     do {
8817     dim = this._getDaysInMonth(year, month - 1);
8818     if (day <= dim) {
8819     break;
8820     }
8821     month++;
8822     day -= dim;
8823     } while (true);
8824     }
8825    
8826     date = this._daylightSavingAdjust(new Date(year, month - 1, day));
8827     if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
8828     throw "Invalid date"; // E.g. 31/02/00
8829     }
8830     return date;
8831     },
8832    
8833     /* Standard date formats. */
8834     ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
8835     COOKIE: "D, dd M yy",
8836     ISO_8601: "yy-mm-dd",
8837     RFC_822: "D, d M y",
8838     RFC_850: "DD, dd-M-y",
8839     RFC_1036: "D, d M y",
8840     RFC_1123: "D, d M yy",
8841     RFC_2822: "D, d M yy",
8842     RSS: "D, d M y", // RFC 822
8843     TICKS: "!",
8844     TIMESTAMP: "@",
8845     W3C: "yy-mm-dd", // ISO 8601
8846    
8847     _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
8848     Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
8849    
8850     /* Format a date object into a string value.
8851     * The format can be combinations of the following:
8852     * d - day of month (no leading zero)
8853     * dd - day of month (two digit)
8854     * o - day of year (no leading zeros)
8855     * oo - day of year (three digit)
8856     * D - day name short
8857     * DD - day name long
8858     * m - month of year (no leading zero)
8859     * mm - month of year (two digit)
8860     * M - month name short
8861     * MM - month name long
8862     * y - year (two digit)
8863     * yy - year (four digit)
8864     * @ - Unix timestamp (ms since 01/01/1970)
8865     * ! - Windows ticks (100ns since 01/01/0001)
8866     * "..." - literal text
8867     * '' - single quote
8868     *
8869     * @param format string - the desired format of the date
8870     * @param date Date - the date value to format
8871     * @param settings Object - attributes include:
8872     * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
8873     * dayNames string[7] - names of the days from Sunday (optional)
8874     * monthNamesShort string[12] - abbreviated names of the months (optional)
8875     * monthNames string[12] - names of the months (optional)
8876     * @return string - the date in the above format
8877     */
8878     formatDate: function (format, date, settings) {
8879     if (!date) {
8880     return "";
8881     }
8882    
8883     var iFormat,
8884     dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8885     dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8886     monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8887     monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8888     // Check whether a format character is doubled
8889     lookAhead = function(match) {
8890     var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8891     if (matches) {
8892     iFormat++;
8893     }
8894     return matches;
8895     },
8896     // Format a number, with leading zero if necessary
8897     formatNumber = function(match, value, len) {
8898     var num = "" + value;
8899     if (lookAhead(match)) {
8900     while (num.length < len) {
8901     num = "0" + num;
8902     }
8903     }
8904     return num;
8905     },
8906     // Format a name, short or long as requested
8907     formatName = function(match, value, shortNames, longNames) {
8908     return (lookAhead(match) ? longNames[value] : shortNames[value]);
8909     },
8910     output = "",
8911     literal = false;
8912    
8913     if (date) {
8914     for (iFormat = 0; iFormat < format.length; iFormat++) {
8915     if (literal) {
8916     if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8917     literal = false;
8918     } else {
8919     output += format.charAt(iFormat);
8920     }
8921     } else {
8922     switch (format.charAt(iFormat)) {
8923     case "d":
8924     output += formatNumber("d", date.getDate(), 2);
8925     break;
8926     case "D":
8927     output += formatName("D", date.getDay(), dayNamesShort, dayNames);
8928     break;
8929     case "o":
8930     output += formatNumber("o",
8931     Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
8932     break;
8933     case "m":
8934     output += formatNumber("m", date.getMonth() + 1, 2);
8935     break;
8936     case "M":
8937     output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
8938     break;
8939     case "y":
8940     output += (lookAhead("y") ? date.getFullYear() :
8941     (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
8942     break;
8943     case "@":
8944     output += date.getTime();
8945     break;
8946     case "!":
8947     output += date.getTime() * 10000 + this._ticksTo1970;
8948     break;
8949     case "'":
8950     if (lookAhead("'")) {
8951     output += "'";
8952     } else {
8953     literal = true;
8954     }
8955     break;
8956     default:
8957     output += format.charAt(iFormat);
8958     }
8959     }
8960     }
8961     }
8962     return output;
8963     },
8964    
8965     /* Extract all possible characters from the date format. */
8966     _possibleChars: function (format) {
8967     var iFormat,
8968     chars = "",
8969     literal = false,
8970     // Check whether a format character is doubled
8971     lookAhead = function(match) {
8972     var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8973     if (matches) {
8974     iFormat++;
8975     }
8976     return matches;
8977     };
8978    
8979     for (iFormat = 0; iFormat < format.length; iFormat++) {
8980     if (literal) {
8981     if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8982     literal = false;
8983     } else {
8984     chars += format.charAt(iFormat);
8985     }
8986     } else {
8987     switch (format.charAt(iFormat)) {
8988     case "d": case "m": case "y": case "@":
8989     chars += "0123456789";
8990     break;
8991     case "D": case "M":
8992     return null; // Accept anything
8993     case "'":
8994     if (lookAhead("'")) {
8995     chars += "'";
8996     } else {
8997     literal = true;
8998     }
8999     break;
9000     default:
9001     chars += format.charAt(iFormat);
9002     }
9003     }
9004     }
9005     return chars;
9006     },
9007    
9008     /* Get a setting value, defaulting if necessary. */
9009     _get: function(inst, name) {
9010     return inst.settings[name] !== undefined ?
9011     inst.settings[name] : this._defaults[name];
9012     },
9013    
9014     /* Parse existing date and initialise date picker. */
9015     _setDateFromField: function(inst, noDefault) {
9016     if (inst.input.val() === inst.lastVal) {
9017     return;
9018     }
9019    
9020     var dateFormat = this._get(inst, "dateFormat"),
9021     dates = inst.lastVal = inst.input ? inst.input.val() : null,
9022     defaultDate = this._getDefaultDate(inst),
9023     date = defaultDate,
9024     settings = this._getFormatConfig(inst);
9025    
9026     try {
9027     date = this.parseDate(dateFormat, dates, settings) || defaultDate;
9028     } catch (event) {
9029     dates = (noDefault ? "" : dates);
9030     }
9031     inst.selectedDay = date.getDate();
9032     inst.drawMonth = inst.selectedMonth = date.getMonth();
9033     inst.drawYear = inst.selectedYear = date.getFullYear();
9034     inst.currentDay = (dates ? date.getDate() : 0);
9035     inst.currentMonth = (dates ? date.getMonth() : 0);
9036     inst.currentYear = (dates ? date.getFullYear() : 0);
9037     this._adjustInstDate(inst);
9038     },
9039    
9040     /* Retrieve the default date shown on opening. */
9041     _getDefaultDate: function(inst) {
9042     return this._restrictMinMax(inst,
9043     this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
9044     },
9045    
9046     /* A date may be specified as an exact value or a relative one. */
9047     _determineDate: function(inst, date, defaultDate) {
9048     var offsetNumeric = function(offset) {
9049     var date = new Date();
9050     date.setDate(date.getDate() + offset);
9051     return date;
9052     },
9053     offsetString = function(offset) {
9054     try {
9055     return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
9056     offset, $.datepicker._getFormatConfig(inst));
9057     }
9058     catch (e) {
9059     // Ignore
9060     }
9061    
9062     var date = (offset.toLowerCase().match(/^c/) ?
9063     $.datepicker._getDate(inst) : null) || new Date(),
9064     year = date.getFullYear(),
9065     month = date.getMonth(),
9066     day = date.getDate(),
9067     pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
9068     matches = pattern.exec(offset);
9069    
9070     while (matches) {
9071     switch (matches[2] || "d") {
9072     case "d" : case "D" :
9073     day += parseInt(matches[1],10); break;
9074     case "w" : case "W" :
9075     day += parseInt(matches[1],10) * 7; break;
9076     case "m" : case "M" :
9077     month += parseInt(matches[1],10);
9078     day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
9079     break;
9080     case "y": case "Y" :
9081     year += parseInt(matches[1],10);
9082     day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
9083     break;
9084     }
9085     matches = pattern.exec(offset);
9086     }
9087     return new Date(year, month, day);
9088     },
9089     newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
9090     (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
9091    
9092     newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
9093     if (newDate) {
9094     newDate.setHours(0);
9095     newDate.setMinutes(0);
9096     newDate.setSeconds(0);
9097     newDate.setMilliseconds(0);
9098     }
9099     return this._daylightSavingAdjust(newDate);
9100     },
9101    
9102     /* Handle switch to/from daylight saving.
9103     * Hours may be non-zero on daylight saving cut-over:
9104     * > 12 when midnight changeover, but then cannot generate
9105     * midnight datetime, so jump to 1AM, otherwise reset.
9106     * @param date (Date) the date to check
9107     * @return (Date) the corrected date
9108     */
9109     _daylightSavingAdjust: function(date) {
9110     if (!date) {
9111     return null;
9112     }
9113     date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
9114     return date;
9115     },
9116    
9117     /* Set the date(s) directly. */
9118     _setDate: function(inst, date, noChange) {
9119     var clear = !date,
9120     origMonth = inst.selectedMonth,
9121     origYear = inst.selectedYear,
9122     newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
9123    
9124     inst.selectedDay = inst.currentDay = newDate.getDate();
9125     inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
9126     inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
9127     if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
9128     this._notifyChange(inst);
9129     }
9130     this._adjustInstDate(inst);
9131     if (inst.input) {
9132     inst.input.val(clear ? "" : this._formatDate(inst));
9133     }
9134     },
9135    
9136     /* Retrieve the date(s) directly. */
9137     _getDate: function(inst) {
9138     var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
9139     this._daylightSavingAdjust(new Date(
9140     inst.currentYear, inst.currentMonth, inst.currentDay)));
9141     return startDate;
9142     },
9143    
9144     /* Attach the onxxx handlers. These are declared statically so
9145     * they work with static code transformers like Caja.
9146     */
9147     _attachHandlers: function(inst) {
9148     var stepMonths = this._get(inst, "stepMonths"),
9149     id = "#" + inst.id.replace( /\\\\/g, "\\" );
9150     inst.dpDiv.find("[data-handler]").map(function () {
9151     var handler = {
9152     prev: function () {
9153     $.datepicker._adjustDate(id, -stepMonths, "M");
9154     },
9155     next: function () {
9156     $.datepicker._adjustDate(id, +stepMonths, "M");
9157     },
9158     hide: function () {
9159     $.datepicker._hideDatepicker();
9160     },
9161     today: function () {
9162     $.datepicker._gotoToday(id);
9163     },
9164     selectDay: function () {
9165     $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
9166     return false;
9167     },
9168     selectMonth: function () {
9169     $.datepicker._selectMonthYear(id, this, "M");
9170     return false;
9171     },
9172     selectYear: function () {
9173     $.datepicker._selectMonthYear(id, this, "Y");
9174     return false;
9175     }
9176     };
9177     $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
9178     });
9179     },
9180    
9181     /* Generate the HTML for the current state of the date picker. */
9182     _generateHTML: function(inst) {
9183     var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
9184     controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
9185     monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
9186     selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
9187     cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
9188     printDate, dRow, tbody, daySettings, otherMonth, unselectable,
9189     tempDate = new Date(),
9190     today = this._daylightSavingAdjust(
9191     new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
9192     isRTL = this._get(inst, "isRTL"),
9193     showButtonPanel = this._get(inst, "showButtonPanel"),
9194     hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
9195     navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
9196     numMonths = this._getNumberOfMonths(inst),
9197     showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
9198     stepMonths = this._get(inst, "stepMonths"),
9199     isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
9200     currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
9201     new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
9202     minDate = this._getMinMaxDate(inst, "min"),
9203     maxDate = this._getMinMaxDate(inst, "max"),
9204     drawMonth = inst.drawMonth - showCurrentAtPos,
9205     drawYear = inst.drawYear;
9206    
9207     if (drawMonth < 0) {
9208     drawMonth += 12;
9209     drawYear--;
9210     }
9211     if (maxDate) {
9212     maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
9213     maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
9214     maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
9215     while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
9216     drawMonth--;
9217     if (drawMonth < 0) {
9218     drawMonth = 11;
9219     drawYear--;
9220     }
9221     }
9222     }
9223     inst.drawMonth = drawMonth;
9224     inst.drawYear = drawYear;
9225    
9226     prevText = this._get(inst, "prevText");
9227     prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
9228     this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
9229     this._getFormatConfig(inst)));
9230    
9231     prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
9232     "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
9233     " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
9234     (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='"+ prevText +"'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>"));
9235    
9236     nextText = this._get(inst, "nextText");
9237     nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
9238     this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
9239     this._getFormatConfig(inst)));
9240    
9241     next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
9242     "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
9243     " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
9244     (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='"+ nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>"));
9245    
9246     currentText = this._get(inst, "currentText");
9247     gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
9248     currentText = (!navigationAsDateFormat ? currentText :
9249     this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
9250    
9251     controls = (!inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" +
9252     this._get(inst, "closeText") + "</button>" : "");
9253    
9254     buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
9255     (this._isInRange(inst, gotoDate) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" +
9256     ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
9257    
9258     firstDay = parseInt(this._get(inst, "firstDay"),10);
9259     firstDay = (isNaN(firstDay) ? 0 : firstDay);
9260    
9261     showWeek = this._get(inst, "showWeek");
9262     dayNames = this._get(inst, "dayNames");
9263     dayNamesMin = this._get(inst, "dayNamesMin");
9264     monthNames = this._get(inst, "monthNames");
9265     monthNamesShort = this._get(inst, "monthNamesShort");
9266     beforeShowDay = this._get(inst, "beforeShowDay");
9267     showOtherMonths = this._get(inst, "showOtherMonths");
9268     selectOtherMonths = this._get(inst, "selectOtherMonths");
9269     defaultDate = this._getDefaultDate(inst);
9270     html = "";
9271     dow;
9272     for (row = 0; row < numMonths[0]; row++) {
9273     group = "";
9274     this.maxRows = 4;
9275     for (col = 0; col < numMonths[1]; col++) {
9276     selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
9277     cornerClass = " ui-corner-all";
9278     calender = "";
9279     if (isMultiMonth) {
9280     calender += "<div class='ui-datepicker-group";
9281     if (numMonths[1] > 1) {
9282     switch (col) {
9283     case 0: calender += " ui-datepicker-group-first";
9284     cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
9285     case numMonths[1]-1: calender += " ui-datepicker-group-last";
9286     cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
9287     default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
9288     }
9289     }
9290     calender += "'>";
9291     }
9292     calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
9293     (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
9294     (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
9295     this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
9296     row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
9297     "</div><table class='ui-datepicker-calendar'><thead>" +
9298     "<tr>";
9299     thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
9300     for (dow = 0; dow < 7; dow++) { // days of the week
9301     day = (dow + firstDay) % 7;
9302     thead += "<th" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
9303     "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
9304     }
9305     calender += thead + "</tr></thead><tbody>";
9306     daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
9307     if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
9308     inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
9309     }
9310     leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
9311     curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
9312     numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
9313     this.maxRows = numRows;
9314     printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
9315     for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
9316     calender += "<tr>";
9317     tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
9318     this._get(inst, "calculateWeek")(printDate) + "</td>");
9319     for (dow = 0; dow < 7; dow++) { // create date picker days
9320     daySettings = (beforeShowDay ?
9321     beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
9322     otherMonth = (printDate.getMonth() !== drawMonth);
9323     unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
9324     (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
9325     tbody += "<td class='" +
9326     ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
9327     (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
9328     ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
9329     (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
9330     // or defaultDate is current printedDate and defaultDate is selectedDate
9331     " " + this._dayOverClass : "") + // highlight selected day
9332     (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
9333     (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
9334     (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
9335     (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
9336     ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
9337     (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
9338     (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
9339     (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
9340     (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
9341     (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
9342     (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
9343     "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
9344     printDate.setDate(printDate.getDate() + 1);
9345     printDate = this._daylightSavingAdjust(printDate);
9346     }
9347     calender += tbody + "</tr>";
9348     }
9349     drawMonth++;
9350     if (drawMonth > 11) {
9351     drawMonth = 0;
9352     drawYear++;
9353     }
9354     calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
9355     ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
9356     group += calender;
9357     }
9358     html += group;
9359     }
9360     html += buttonPanel;
9361     inst._keyEvent = false;
9362     return html;
9363     },
9364    
9365     /* Generate the month and year header. */
9366     _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
9367     secondary, monthNames, monthNamesShort) {
9368    
9369     var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
9370     changeMonth = this._get(inst, "changeMonth"),
9371     changeYear = this._get(inst, "changeYear"),
9372     showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
9373     html = "<div class='ui-datepicker-title'>",
9374     monthHtml = "";
9375    
9376     // month selection
9377     if (secondary || !changeMonth) {
9378     monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
9379     } else {
9380     inMinYear = (minDate && minDate.getFullYear() === drawYear);
9381     inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
9382     monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
9383     for ( month = 0; month < 12; month++) {
9384     if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
9385     monthHtml += "<option value='" + month + "'" +
9386     (month === drawMonth ? " selected='selected'" : "") +
9387     ">" + monthNamesShort[month] + "</option>";
9388     }
9389     }
9390     monthHtml += "</select>";
9391     }
9392    
9393     if (!showMonthAfterYear) {
9394     html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
9395     }
9396    
9397     // year selection
9398     if ( !inst.yearshtml ) {
9399     inst.yearshtml = "";
9400     if (secondary || !changeYear) {
9401     html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
9402     } else {
9403     // determine range of years to display
9404     years = this._get(inst, "yearRange").split(":");
9405     thisYear = new Date().getFullYear();
9406     determineYear = function(value) {
9407     var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
9408     (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
9409     parseInt(value, 10)));
9410     return (isNaN(year) ? thisYear : year);
9411     };
9412     year = determineYear(years[0]);
9413     endYear = Math.max(year, determineYear(years[1] || ""));
9414     year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
9415     endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
9416     inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
9417     for (; year <= endYear; year++) {
9418     inst.yearshtml += "<option value='" + year + "'" +
9419     (year === drawYear ? " selected='selected'" : "") +
9420     ">" + year + "</option>";
9421     }
9422     inst.yearshtml += "</select>";
9423    
9424     html += inst.yearshtml;
9425     inst.yearshtml = null;
9426     }
9427     }
9428    
9429     html += this._get(inst, "yearSuffix");
9430     if (showMonthAfterYear) {
9431     html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
9432     }
9433     html += "</div>"; // Close datepicker_header
9434     return html;
9435     },
9436    
9437     /* Adjust one of the date sub-fields. */
9438     _adjustInstDate: function(inst, offset, period) {
9439     var year = inst.drawYear + (period === "Y" ? offset : 0),
9440     month = inst.drawMonth + (period === "M" ? offset : 0),
9441     day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
9442     date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
9443    
9444     inst.selectedDay = date.getDate();
9445     inst.drawMonth = inst.selectedMonth = date.getMonth();
9446     inst.drawYear = inst.selectedYear = date.getFullYear();
9447     if (period === "M" || period === "Y") {
9448     this._notifyChange(inst);
9449     }
9450     },
9451    
9452     /* Ensure a date is within any min/max bounds. */
9453     _restrictMinMax: function(inst, date) {
9454     var minDate = this._getMinMaxDate(inst, "min"),
9455     maxDate = this._getMinMaxDate(inst, "max"),
9456     newDate = (minDate && date < minDate ? minDate : date);
9457     return (maxDate && newDate > maxDate ? maxDate : newDate);
9458     },
9459    
9460     /* Notify change of month/year. */
9461     _notifyChange: function(inst) {
9462     var onChange = this._get(inst, "onChangeMonthYear");
9463     if (onChange) {
9464     onChange.apply((inst.input ? inst.input[0] : null),
9465     [inst.selectedYear, inst.selectedMonth + 1, inst]);
9466     }
9467     },
9468    
9469     /* Determine the number of months to show. */
9470     _getNumberOfMonths: function(inst) {
9471     var numMonths = this._get(inst, "numberOfMonths");
9472     return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
9473     },
9474    
9475     /* Determine the current maximum date - ensure no time components are set. */
9476     _getMinMaxDate: function(inst, minMax) {
9477     return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
9478     },
9479    
9480     /* Find the number of days in a given month. */
9481     _getDaysInMonth: function(year, month) {
9482     return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
9483     },
9484    
9485     /* Find the day of the week of the first of a month. */
9486     _getFirstDayOfMonth: function(year, month) {
9487     return new Date(year, month, 1).getDay();
9488     },
9489    
9490     /* Determines if we should allow a "next/prev" month display change. */
9491     _canAdjustMonth: function(inst, offset, curYear, curMonth) {
9492     var numMonths = this._getNumberOfMonths(inst),
9493     date = this._daylightSavingAdjust(new Date(curYear,
9494     curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
9495    
9496     if (offset < 0) {
9497     date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
9498     }
9499     return this._isInRange(inst, date);
9500     },
9501    
9502     /* Is the given date in the accepted range? */
9503     _isInRange: function(inst, date) {
9504     var yearSplit, currentYear,
9505     minDate = this._getMinMaxDate(inst, "min"),
9506     maxDate = this._getMinMaxDate(inst, "max"),
9507     minYear = null,
9508     maxYear = null,
9509     years = this._get(inst, "yearRange");
9510     if (years){
9511     yearSplit = years.split(":");
9512     currentYear = new Date().getFullYear();
9513     minYear = parseInt(yearSplit[0], 10);
9514     maxYear = parseInt(yearSplit[1], 10);
9515     if ( yearSplit[0].match(/[+\-].*/) ) {
9516     minYear += currentYear;
9517     }
9518     if ( yearSplit[1].match(/[+\-].*/) ) {
9519     maxYear += currentYear;
9520     }
9521     }
9522    
9523     return ((!minDate || date.getTime() >= minDate.getTime()) &&
9524     (!maxDate || date.getTime() <= maxDate.getTime()) &&
9525     (!minYear || date.getFullYear() >= minYear) &&
9526     (!maxYear || date.getFullYear() <= maxYear));
9527     },
9528    
9529     /* Provide the configuration settings for formatting/parsing. */
9530     _getFormatConfig: function(inst) {
9531     var shortYearCutoff = this._get(inst, "shortYearCutoff");
9532     shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
9533     new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
9534     return {shortYearCutoff: shortYearCutoff,
9535     dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
9536     monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
9537     },
9538    
9539     /* Format the given date for display. */
9540     _formatDate: function(inst, day, month, year) {
9541     if (!day) {
9542     inst.currentDay = inst.selectedDay;
9543     inst.currentMonth = inst.selectedMonth;
9544     inst.currentYear = inst.selectedYear;
9545     }
9546     var date = (day ? (typeof day === "object" ? day :
9547     this._daylightSavingAdjust(new Date(year, month, day))) :
9548     this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
9549     return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
9550     }
9551     });
9552    
9553     /*
9554     * Bind hover events for datepicker elements.
9555     * Done via delegate so the binding only occurs once in the lifetime of the parent div.
9556     * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
9557     */
9558     function bindHover(dpDiv) {
9559     var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
9560     return dpDiv.delegate(selector, "mouseout", function() {
9561     $(this).removeClass("ui-state-hover");
9562     if (this.className.indexOf("ui-datepicker-prev") !== -1) {
9563     $(this).removeClass("ui-datepicker-prev-hover");
9564     }
9565     if (this.className.indexOf("ui-datepicker-next") !== -1) {
9566     $(this).removeClass("ui-datepicker-next-hover");
9567     }
9568     })
9569     .delegate(selector, "mouseover", function(){
9570     if (!$.datepicker._isDisabledDatepicker( instActive.inline ? dpDiv.parent()[0] : instActive.input[0])) {
9571     $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
9572     $(this).addClass("ui-state-hover");
9573     if (this.className.indexOf("ui-datepicker-prev") !== -1) {
9574     $(this).addClass("ui-datepicker-prev-hover");
9575     }
9576     if (this.className.indexOf("ui-datepicker-next") !== -1) {
9577     $(this).addClass("ui-datepicker-next-hover");
9578     }
9579     }
9580     });
9581     }
9582    
9583     /* jQuery extend now ignores nulls! */
9584     function extendRemove(target, props) {
9585     $.extend(target, props);
9586     for (var name in props) {
9587     if (props[name] == null) {
9588     target[name] = props[name];
9589     }
9590     }
9591     return target;
9592     }
9593    
9594     /* Invoke the datepicker functionality.
9595     @param options string - a command, optionally followed by additional parameters or
9596     Object - settings for attaching new datepicker functionality
9597     @return jQuery object */
9598     $.fn.datepicker = function(options){
9599    
9600     /* Verify an empty collection wasn't passed - Fixes #6976 */
9601     if ( !this.length ) {
9602     return this;
9603     }
9604    
9605     /* Initialise the date picker. */
9606     if (!$.datepicker.initialized) {
9607     $(document).mousedown($.datepicker._checkExternalClick);
9608     $.datepicker.initialized = true;
9609     }
9610    
9611     /* Append datepicker main container to body if not exist. */
9612     if ($("#"+$.datepicker._mainDivId).length === 0) {
9613     $("body").append($.datepicker.dpDiv);
9614     }
9615    
9616     var otherArgs = Array.prototype.slice.call(arguments, 1);
9617     if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
9618     return $.datepicker["_" + options + "Datepicker"].
9619     apply($.datepicker, [this[0]].concat(otherArgs));
9620     }
9621     if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
9622     return $.datepicker["_" + options + "Datepicker"].
9623     apply($.datepicker, [this[0]].concat(otherArgs));
9624     }
9625     return this.each(function() {
9626     typeof options === "string" ?
9627     $.datepicker["_" + options + "Datepicker"].
9628     apply($.datepicker, [this].concat(otherArgs)) :
9629     $.datepicker._attachDatepicker(this, options);
9630     });
9631     };
9632    
9633     $.datepicker = new Datepicker(); // singleton instance
9634     $.datepicker.initialized = false;
9635     $.datepicker.uuid = new Date().getTime();
9636     $.datepicker.version = "1.10.3";
9637    
9638     })(jQuery);
9639    
9640     (function( $, undefined ) {
9641    
9642     var sizeRelatedOptions = {
9643     buttons: true,
9644     height: true,
9645     maxHeight: true,
9646     maxWidth: true,
9647     minHeight: true,
9648     minWidth: true,
9649     width: true
9650     },
9651     resizableRelatedOptions = {
9652     maxHeight: true,
9653     maxWidth: true,
9654     minHeight: true,
9655     minWidth: true
9656     };
9657    
9658     $.widget( "ui.dialog", {
9659     version: "1.10.3",
9660     options: {
9661     appendTo: "body",
9662     autoOpen: true,
9663     buttons: [],
9664     closeOnEscape: true,
9665     closeText: "close",
9666     dialogClass: "",
9667     draggable: true,
9668     hide: null,
9669     height: "auto",
9670     maxHeight: null,
9671     maxWidth: null,
9672     minHeight: 150,
9673     minWidth: 150,
9674     modal: false,
9675     position: {
9676     my: "center",
9677     at: "center",
9678     of: window,
9679     collision: "fit",
9680     // Ensure the titlebar is always visible
9681     using: function( pos ) {
9682     var topOffset = $( this ).css( pos ).offset().top;
9683     if ( topOffset < 0 ) {
9684     $( this ).css( "top", pos.top - topOffset );
9685     }
9686     }
9687     },
9688     resizable: true,
9689     show: null,
9690     title: null,
9691     width: 300,
9692    
9693     // callbacks
9694     beforeClose: null,
9695     close: null,
9696     drag: null,
9697     dragStart: null,
9698     dragStop: null,
9699     focus: null,
9700     open: null,
9701     resize: null,
9702     resizeStart: null,
9703     resizeStop: null
9704     },
9705    
9706     _create: function() {
9707     this.originalCss = {
9708     display: this.element[0].style.display,
9709     width: this.element[0].style.width,
9710     minHeight: this.element[0].style.minHeight,
9711     maxHeight: this.element[0].style.maxHeight,
9712     height: this.element[0].style.height
9713     };
9714     this.originalPosition = {
9715     parent: this.element.parent(),
9716     index: this.element.parent().children().index( this.element )
9717     };
9718     this.originalTitle = this.element.attr("title");
9719     this.options.title = this.options.title || this.originalTitle;
9720    
9721     this._createWrapper();
9722    
9723     this.element
9724     .show()
9725     .removeAttr("title")
9726     .addClass("ui-dialog-content ui-widget-content")
9727     .appendTo( this.uiDialog );
9728    
9729     this._createTitlebar();
9730     this._createButtonPane();
9731    
9732     if ( this.options.draggable && $.fn.draggable ) {
9733     this._makeDraggable();
9734     }
9735     if ( this.options.resizable && $.fn.resizable ) {
9736     this._makeResizable();
9737     }
9738    
9739     this._isOpen = false;
9740     },
9741    
9742     _init: function() {
9743     if ( this.options.autoOpen ) {
9744     this.open();
9745     }
9746     },
9747    
9748     _appendTo: function() {
9749     var element = this.options.appendTo;
9750     if ( element && (element.jquery || element.nodeType) ) {
9751     return $( element );
9752     }
9753     return this.document.find( element || "body" ).eq( 0 );
9754     },
9755    
9756     _destroy: function() {
9757     var next,
9758     originalPosition = this.originalPosition;
9759    
9760     this._destroyOverlay();
9761    
9762     this.element
9763     .removeUniqueId()
9764     .removeClass("ui-dialog-content ui-widget-content")
9765     .css( this.originalCss )
9766     // Without detaching first, the following becomes really slow
9767     .detach();
9768    
9769     this.uiDialog.stop( true, true ).remove();
9770    
9771     if ( this.originalTitle ) {
9772     this.element.attr( "title", this.originalTitle );
9773     }
9774    
9775     next = originalPosition.parent.children().eq( originalPosition.index );
9776     // Don't try to place the dialog next to itself (#8613)
9777     if ( next.length && next[0] !== this.element[0] ) {
9778     next.before( this.element );
9779     } else {
9780     originalPosition.parent.append( this.element );
9781     }
9782     },
9783    
9784     widget: function() {
9785     return this.uiDialog;
9786     },
9787    
9788     disable: $.noop,
9789     enable: $.noop,
9790    
9791     close: function( event ) {
9792     var that = this;
9793    
9794     if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
9795     return;
9796     }
9797    
9798     this._isOpen = false;
9799     this._destroyOverlay();
9800    
9801     if ( !this.opener.filter(":focusable").focus().length ) {
9802     // Hiding a focused element doesn't trigger blur in WebKit
9803     // so in case we have nothing to focus on, explicitly blur the active element
9804     // https://bugs.webkit.org/show_bug.cgi?id=47182
9805     $( this.document[0].activeElement ).blur();
9806     }
9807    
9808     this._hide( this.uiDialog, this.options.hide, function() {
9809     that._trigger( "close", event );
9810     });
9811     },
9812    
9813     isOpen: function() {
9814     return this._isOpen;
9815     },
9816    
9817     moveToTop: function() {
9818     this._moveToTop();
9819     },
9820    
9821     _moveToTop: function( event, silent ) {
9822     var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
9823     if ( moved && !silent ) {
9824     this._trigger( "focus", event );
9825     }
9826     return moved;
9827     },
9828    
9829     open: function() {
9830     var that = this;
9831     if ( this._isOpen ) {
9832     if ( this._moveToTop() ) {
9833     this._focusTabbable();
9834     }
9835     return;
9836     }
9837    
9838     this._isOpen = true;
9839     this.opener = $( this.document[0].activeElement );
9840    
9841     this._size();
9842     this._position();
9843     this._createOverlay();
9844     this._moveToTop( null, true );
9845     this._show( this.uiDialog, this.options.show, function() {
9846     that._focusTabbable();
9847     that._trigger("focus");
9848     });
9849    
9850     this._trigger("open");
9851     },
9852    
9853     _focusTabbable: function() {
9854     // Set focus to the first match:
9855     // 1. First element inside the dialog matching [autofocus]
9856     // 2. Tabbable element inside the content element
9857     // 3. Tabbable element inside the buttonpane
9858     // 4. The close button
9859     // 5. The dialog itself
9860     var hasFocus = this.element.find("[autofocus]");
9861     if ( !hasFocus.length ) {
9862     hasFocus = this.element.find(":tabbable");
9863     }
9864     if ( !hasFocus.length ) {
9865     hasFocus = this.uiDialogButtonPane.find(":tabbable");
9866     }
9867     if ( !hasFocus.length ) {
9868     hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
9869     }
9870     if ( !hasFocus.length ) {
9871     hasFocus = this.uiDialog;
9872     }
9873     hasFocus.eq( 0 ).focus();
9874     },
9875    
9876     _keepFocus: function( event ) {
9877     function checkFocus() {
9878     var activeElement = this.document[0].activeElement,
9879     isActive = this.uiDialog[0] === activeElement ||
9880     $.contains( this.uiDialog[0], activeElement );
9881     if ( !isActive ) {
9882     this._focusTabbable();
9883     }
9884     }
9885     event.preventDefault();
9886     checkFocus.call( this );
9887     // support: IE
9888     // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
9889     // so we check again later
9890     this._delay( checkFocus );
9891     },
9892    
9893     _createWrapper: function() {
9894     this.uiDialog = $("<div>")
9895     .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
9896     this.options.dialogClass )
9897     .hide()
9898     .attr({
9899     // Setting tabIndex makes the div focusable
9900     tabIndex: -1,
9901     role: "dialog"
9902     })
9903     .appendTo( this._appendTo() );
9904    
9905     this._on( this.uiDialog, {
9906     keydown: function( event ) {
9907     if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
9908     event.keyCode === $.ui.keyCode.ESCAPE ) {
9909     event.preventDefault();
9910     this.close( event );
9911     return;
9912     }
9913    
9914     // prevent tabbing out of dialogs
9915     if ( event.keyCode !== $.ui.keyCode.TAB ) {
9916     return;
9917     }
9918     var tabbables = this.uiDialog.find(":tabbable"),
9919     first = tabbables.filter(":first"),
9920     last = tabbables.filter(":last");
9921    
9922     if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
9923     first.focus( 1 );
9924     event.preventDefault();
9925     } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
9926     last.focus( 1 );
9927     event.preventDefault();
9928     }
9929     },
9930     mousedown: function( event ) {
9931     if ( this._moveToTop( event ) ) {
9932     this._focusTabbable();
9933     }
9934     }
9935     });
9936    
9937     // We assume that any existing aria-describedby attribute means
9938     // that the dialog content is marked up properly
9939     // otherwise we brute force the content as the description
9940     if ( !this.element.find("[aria-describedby]").length ) {
9941     this.uiDialog.attr({
9942     "aria-describedby": this.element.uniqueId().attr("id")
9943     });
9944     }
9945     },
9946    
9947     _createTitlebar: function() {
9948     var uiDialogTitle;
9949    
9950     this.uiDialogTitlebar = $("<div>")
9951     .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
9952     .prependTo( this.uiDialog );
9953     this._on( this.uiDialogTitlebar, {
9954     mousedown: function( event ) {
9955     // Don't prevent click on close button (#8838)
9956     // Focusing a dialog that is partially scrolled out of view
9957     // causes the browser to scroll it into view, preventing the click event
9958     if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
9959     // Dialog isn't getting focus when dragging (#8063)
9960     this.uiDialog.focus();
9961     }
9962     }
9963     });
9964    
9965     this.uiDialogTitlebarClose = $("<button></button>")
9966     .button({
9967     label: this.options.closeText,
9968     icons: {
9969     primary: "ui-icon-closethick"
9970     },
9971     text: false
9972     })
9973     .addClass("ui-dialog-titlebar-close")
9974     .appendTo( this.uiDialogTitlebar );
9975     this._on( this.uiDialogTitlebarClose, {
9976     click: function( event ) {
9977     event.preventDefault();
9978     this.close( event );
9979     }
9980     });
9981    
9982     uiDialogTitle = $("<span>")
9983     .uniqueId()
9984     .addClass("ui-dialog-title")
9985     .prependTo( this.uiDialogTitlebar );
9986     this._title( uiDialogTitle );
9987    
9988     this.uiDialog.attr({
9989     "aria-labelledby": uiDialogTitle.attr("id")
9990     });
9991     },
9992    
9993     _title: function( title ) {
9994     if ( !this.options.title ) {
9995     title.html("&#160;");
9996     }
9997     title.text( this.options.title );
9998     },
9999    
10000     _createButtonPane: function() {
10001     this.uiDialogButtonPane = $("<div>")
10002     .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
10003    
10004     this.uiButtonSet = $("<div>")
10005     .addClass("ui-dialog-buttonset")
10006     .appendTo( this.uiDialogButtonPane );
10007    
10008     this._createButtons();
10009     },
10010    
10011     _createButtons: function() {
10012     var that = this,
10013     buttons = this.options.buttons;
10014    
10015     // if we already have a button pane, remove it
10016     this.uiDialogButtonPane.remove();
10017     this.uiButtonSet.empty();
10018    
10019     if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
10020     this.uiDialog.removeClass("ui-dialog-buttons");
10021     return;
10022     }
10023    
10024     $.each( buttons, function( name, props ) {
10025     var click, buttonOptions;
10026     props = $.isFunction( props ) ?
10027     { click: props, text: name } :
10028     props;
10029     // Default to a non-submitting button
10030     props = $.extend( { type: "button" }, props );
10031     // Change the context for the click callback to be the main element
10032     click = props.click;
10033     props.click = function() {
10034     click.apply( that.element[0], arguments );
10035     };
10036     buttonOptions = {
10037     icons: props.icons,
10038     text: props.showText
10039     };
10040     delete props.icons;
10041     delete props.showText;
10042     $( "<button></button>", props )
10043     .button( buttonOptions )
10044     .appendTo( that.uiButtonSet );
10045     });
10046     this.uiDialog.addClass("ui-dialog-buttons");
10047     this.uiDialogButtonPane.appendTo( this.uiDialog );
10048     },
10049    
10050     _makeDraggable: function() {
10051     var that = this,
10052     options = this.options;
10053    
10054     function filteredUi( ui ) {
10055     return {
10056     position: ui.position,
10057     offset: ui.offset
10058     };
10059     }
10060    
10061     this.uiDialog.draggable({
10062     cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
10063     handle: ".ui-dialog-titlebar",
10064     containment: "document",
10065     start: function( event, ui ) {
10066     $( this ).addClass("ui-dialog-dragging");
10067     that._blockFrames();
10068     that._trigger( "dragStart", event, filteredUi( ui ) );
10069     },
10070     drag: function( event, ui ) {
10071     that._trigger( "drag", event, filteredUi( ui ) );
10072     },
10073     stop: function( event, ui ) {
10074     options.position = [
10075     ui.position.left - that.document.scrollLeft(),
10076     ui.position.top - that.document.scrollTop()
10077     ];
10078     $( this ).removeClass("ui-dialog-dragging");
10079     that._unblockFrames();
10080     that._trigger( "dragStop", event, filteredUi( ui ) );
10081     }
10082     });
10083     },
10084    
10085     _makeResizable: function() {
10086     var that = this,
10087     options = this.options,
10088     handles = options.resizable,
10089     // .ui-resizable has position: relative defined in the stylesheet
10090     // but dialogs have to use absolute or fixed positioning
10091     position = this.uiDialog.css("position"),
10092     resizeHandles = typeof handles === "string" ?
10093     handles :
10094     "n,e,s,w,se,sw,ne,nw";
10095    
10096     function filteredUi( ui ) {
10097     return {
10098     originalPosition: ui.originalPosition,
10099     originalSize: ui.originalSize,
10100     position: ui.position,
10101     size: ui.size
10102     };
10103     }
10104    
10105     this.uiDialog.resizable({
10106     cancel: ".ui-dialog-content",
10107     containment: "document",
10108     alsoResize: this.element,
10109     maxWidth: options.maxWidth,
10110     maxHeight: options.maxHeight,
10111     minWidth: options.minWidth,
10112     minHeight: this._minHeight(),
10113     handles: resizeHandles,
10114     start: function( event, ui ) {
10115     $( this ).addClass("ui-dialog-resizing");
10116     that._blockFrames();
10117     that._trigger( "resizeStart", event, filteredUi( ui ) );
10118     },
10119     resize: function( event, ui ) {
10120     that._trigger( "resize", event, filteredUi( ui ) );
10121     },
10122     stop: function( event, ui ) {
10123     options.height = $( this ).height();
10124     options.width = $( this ).width();
10125     $( this ).removeClass("ui-dialog-resizing");
10126     that._unblockFrames();
10127     that._trigger( "resizeStop", event, filteredUi( ui ) );
10128     }
10129     })
10130     .css( "position", position );
10131     },
10132    
10133     _minHeight: function() {
10134     var options = this.options;
10135    
10136     return options.height === "auto" ?
10137     options.minHeight :
10138     Math.min( options.minHeight, options.height );
10139     },
10140    
10141     _position: function() {
10142     // Need to show the dialog to get the actual offset in the position plugin
10143     var isVisible = this.uiDialog.is(":visible");
10144     if ( !isVisible ) {
10145     this.uiDialog.show();
10146     }
10147     this.uiDialog.position( this.options.position );
10148     if ( !isVisible ) {
10149     this.uiDialog.hide();
10150     }
10151     },
10152    
10153     _setOptions: function( options ) {
10154     var that = this,
10155     resize = false,
10156     resizableOptions = {};
10157    
10158     $.each( options, function( key, value ) {
10159     that._setOption( key, value );
10160    
10161     if ( key in sizeRelatedOptions ) {
10162     resize = true;
10163     }
10164     if ( key in resizableRelatedOptions ) {
10165     resizableOptions[ key ] = value;
10166     }
10167     });
10168    
10169     if ( resize ) {
10170     this._size();
10171     this._position();
10172     }
10173     if ( this.uiDialog.is(":data(ui-resizable)") ) {
10174     this.uiDialog.resizable( "option", resizableOptions );
10175     }
10176     },
10177    
10178     _setOption: function( key, value ) {
10179     /*jshint maxcomplexity:15*/
10180     var isDraggable, isResizable,
10181     uiDialog = this.uiDialog;
10182    
10183     if ( key === "dialogClass" ) {
10184     uiDialog
10185     .removeClass( this.options.dialogClass )
10186     .addClass( value );
10187     }
10188    
10189     if ( key === "disabled" ) {
10190     return;
10191     }
10192    
10193     this._super( key, value );
10194    
10195     if ( key === "appendTo" ) {
10196     this.uiDialog.appendTo( this._appendTo() );
10197     }
10198    
10199     if ( key === "buttons" ) {
10200     this._createButtons();
10201     }
10202    
10203     if ( key === "closeText" ) {
10204     this.uiDialogTitlebarClose.button({
10205     // Ensure that we always pass a string
10206     label: "" + value
10207     });
10208     }
10209    
10210     if ( key === "draggable" ) {
10211     isDraggable = uiDialog.is(":data(ui-draggable)");
10212     if ( isDraggable && !value ) {
10213     uiDialog.draggable("destroy");
10214     }
10215    
10216     if ( !isDraggable && value ) {
10217     this._makeDraggable();
10218     }
10219     }
10220    
10221     if ( key === "position" ) {
10222     this._position();
10223     }
10224    
10225     if ( key === "resizable" ) {
10226     // currently resizable, becoming non-resizable
10227     isResizable = uiDialog.is(":data(ui-resizable)");
10228     if ( isResizable && !value ) {
10229     uiDialog.resizable("destroy");
10230     }
10231    
10232     // currently resizable, changing handles
10233     if ( isResizable && typeof value === "string" ) {
10234     uiDialog.resizable( "option", "handles", value );
10235     }
10236    
10237     // currently non-resizable, becoming resizable
10238     if ( !isResizable && value !== false ) {
10239     this._makeResizable();
10240     }
10241     }
10242    
10243     if ( key === "title" ) {
10244     this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
10245     }
10246     },
10247    
10248     _size: function() {
10249     // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
10250     // divs will both have width and height set, so we need to reset them
10251     var nonContentHeight, minContentHeight, maxContentHeight,
10252     options = this.options;
10253    
10254     // Reset content sizing
10255     this.element.show().css({
10256     width: "auto",
10257     minHeight: 0,
10258     maxHeight: "none",
10259     height: 0
10260     });
10261    
10262     if ( options.minWidth > options.width ) {
10263     options.width = options.minWidth;
10264     }
10265    
10266     // reset wrapper sizing
10267     // determine the height of all the non-content elements
10268     nonContentHeight = this.uiDialog.css({
10269     height: "auto",
10270     width: options.width
10271     })
10272     .outerHeight();
10273     minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
10274     maxContentHeight = typeof options.maxHeight === "number" ?
10275     Math.max( 0, options.maxHeight - nonContentHeight ) :
10276     "none";
10277    
10278     if ( options.height === "auto" ) {
10279     this.element.css({
10280     minHeight: minContentHeight,
10281     maxHeight: maxContentHeight,
10282     height: "auto"
10283     });
10284     } else {
10285     this.element.height( Math.max( 0, options.height - nonContentHeight ) );
10286     }
10287    
10288     if (this.uiDialog.is(":data(ui-resizable)") ) {
10289     this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
10290     }
10291     },
10292    
10293     _blockFrames: function() {
10294     this.iframeBlocks = this.document.find( "iframe" ).map(function() {
10295     var iframe = $( this );
10296    
10297     return $( "<div>" )
10298     .css({
10299     position: "absolute",
10300     width: iframe.outerWidth(),
10301     height: iframe.outerHeight()
10302     })
10303     .appendTo( iframe.parent() )
10304     .offset( iframe.offset() )[0];
10305     });
10306     },
10307    
10308     _unblockFrames: function() {
10309     if ( this.iframeBlocks ) {
10310     this.iframeBlocks.remove();
10311     delete this.iframeBlocks;
10312     }
10313     },
10314    
10315     _allowInteraction: function( event ) {
10316     if ( $( event.target ).closest(".ui-dialog").length ) {
10317     return true;
10318     }
10319    
10320     // TODO: Remove hack when datepicker implements
10321     // the .ui-front logic (#8989)
10322     return !!$( event.target ).closest(".ui-datepicker").length;
10323     },
10324    
10325     _createOverlay: function() {
10326     if ( !this.options.modal ) {
10327     return;
10328     }
10329    
10330     var that = this,
10331     widgetFullName = this.widgetFullName;
10332     if ( !$.ui.dialog.overlayInstances ) {
10333     // Prevent use of anchors and inputs.
10334     // We use a delay in case the overlay is created from an
10335     // event that we're going to be cancelling. (#2804)
10336     this._delay(function() {
10337     // Handle .dialog().dialog("close") (#4065)
10338     if ( $.ui.dialog.overlayInstances ) {
10339     this.document.bind( "focusin.dialog", function( event ) {
10340     if ( !that._allowInteraction( event ) ) {
10341     event.preventDefault();
10342     $(".ui-dialog:visible:last .ui-dialog-content")
10343     .data( widgetFullName )._focusTabbable();
10344     }
10345     });
10346     }
10347     });
10348     }
10349    
10350     this.overlay = $("<div>")
10351     .addClass("ui-widget-overlay ui-front")
10352     .appendTo( this._appendTo() );
10353     this._on( this.overlay, {
10354     mousedown: "_keepFocus"
10355     });
10356     $.ui.dialog.overlayInstances++;
10357     },
10358    
10359     _destroyOverlay: function() {
10360     if ( !this.options.modal ) {
10361     return;
10362     }
10363    
10364     if ( this.overlay ) {
10365     $.ui.dialog.overlayInstances--;
10366    
10367     if ( !$.ui.dialog.overlayInstances ) {
10368     this.document.unbind( "focusin.dialog" );
10369     }
10370     this.overlay.remove();
10371     this.overlay = null;
10372     }
10373     }
10374     });
10375    
10376     $.ui.dialog.overlayInstances = 0;
10377    
10378     // DEPRECATED
10379     if ( $.uiBackCompat !== false ) {
10380     // position option with array notation
10381     // just override with old implementation
10382     $.widget( "ui.dialog", $.ui.dialog, {
10383     _position: function() {
10384     var position = this.options.position,
10385     myAt = [],
10386     offset = [ 0, 0 ],
10387     isVisible;
10388    
10389     if ( position ) {
10390     if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
10391     myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
10392     if ( myAt.length === 1 ) {
10393     myAt[1] = myAt[0];
10394     }
10395    
10396     $.each( [ "left", "top" ], function( i, offsetPosition ) {
10397     if ( +myAt[ i ] === myAt[ i ] ) {
10398     offset[ i ] = myAt[ i ];
10399     myAt[ i ] = offsetPosition;
10400     }
10401     });
10402    
10403     position = {
10404     my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
10405     myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
10406     at: myAt.join(" ")
10407     };
10408     }
10409    
10410     position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
10411     } else {
10412     position = $.ui.dialog.prototype.options.position;
10413     }
10414    
10415     // need to show the dialog to get the actual offset in the position plugin
10416     isVisible = this.uiDialog.is(":visible");
10417     if ( !isVisible ) {
10418     this.uiDialog.show();
10419     }
10420     this.uiDialog.position( position );
10421     if ( !isVisible ) {
10422     this.uiDialog.hide();
10423     }
10424     }
10425     });
10426     }
10427    
10428     }( jQuery ) );
10429    
10430     (function( $, undefined ) {
10431    
10432     var rvertical = /up|down|vertical/,
10433     rpositivemotion = /up|left|vertical|horizontal/;
10434    
10435     $.effects.effect.blind = function( o, done ) {
10436     // Create element
10437     var el = $( this ),
10438     props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10439     mode = $.effects.setMode( el, o.mode || "hide" ),
10440     direction = o.direction || "up",
10441     vertical = rvertical.test( direction ),
10442     ref = vertical ? "height" : "width",
10443     ref2 = vertical ? "top" : "left",
10444     motion = rpositivemotion.test( direction ),
10445     animation = {},
10446     show = mode === "show",
10447     wrapper, distance, margin;
10448    
10449     // if already wrapped, the wrapper's properties are my property. #6245
10450     if ( el.parent().is( ".ui-effects-wrapper" ) ) {
10451     $.effects.save( el.parent(), props );
10452     } else {
10453     $.effects.save( el, props );
10454     }
10455     el.show();
10456     wrapper = $.effects.createWrapper( el ).css({
10457     overflow: "hidden"
10458     });
10459    
10460     distance = wrapper[ ref ]();
10461     margin = parseFloat( wrapper.css( ref2 ) ) || 0;
10462    
10463     animation[ ref ] = show ? distance : 0;
10464     if ( !motion ) {
10465     el
10466     .css( vertical ? "bottom" : "right", 0 )
10467     .css( vertical ? "top" : "left", "auto" )
10468     .css({ position: "absolute" });
10469    
10470     animation[ ref2 ] = show ? margin : distance + margin;
10471     }
10472    
10473     // start at 0 if we are showing
10474     if ( show ) {
10475     wrapper.css( ref, 0 );
10476     if ( ! motion ) {
10477     wrapper.css( ref2, margin + distance );
10478     }
10479     }
10480    
10481     // Animate
10482     wrapper.animate( animation, {
10483     duration: o.duration,
10484     easing: o.easing,
10485     queue: false,
10486     complete: function() {
10487     if ( mode === "hide" ) {
10488     el.hide();
10489     }
10490     $.effects.restore( el, props );
10491     $.effects.removeWrapper( el );
10492     done();
10493     }
10494     });
10495    
10496     };
10497    
10498     })(jQuery);
10499    
10500     (function( $, undefined ) {
10501    
10502     $.effects.effect.bounce = function( o, done ) {
10503     var el = $( this ),
10504     props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10505    
10506     // defaults:
10507     mode = $.effects.setMode( el, o.mode || "effect" ),
10508     hide = mode === "hide",
10509     show = mode === "show",
10510     direction = o.direction || "up",
10511     distance = o.distance,
10512     times = o.times || 5,
10513    
10514     // number of internal animations
10515     anims = times * 2 + ( show || hide ? 1 : 0 ),
10516     speed = o.duration / anims,
10517     easing = o.easing,
10518    
10519     // utility:
10520     ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10521     motion = ( direction === "up" || direction === "left" ),
10522     i,
10523     upAnim,
10524     downAnim,
10525    
10526     // we will need to re-assemble the queue to stack our animations in place
10527     queue = el.queue(),
10528     queuelen = queue.length;
10529    
10530     // Avoid touching opacity to prevent clearType and PNG issues in IE
10531     if ( show || hide ) {
10532     props.push( "opacity" );
10533     }
10534    
10535     $.effects.save( el, props );
10536     el.show();
10537     $.effects.createWrapper( el ); // Create Wrapper
10538    
10539     // default distance for the BIGGEST bounce is the outer Distance / 3
10540     if ( !distance ) {
10541     distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
10542     }
10543    
10544     if ( show ) {
10545     downAnim = { opacity: 1 };
10546     downAnim[ ref ] = 0;
10547    
10548     // if we are showing, force opacity 0 and set the initial position
10549     // then do the "first" animation
10550     el.css( "opacity", 0 )
10551     .css( ref, motion ? -distance * 2 : distance * 2 )
10552     .animate( downAnim, speed, easing );
10553     }
10554    
10555     // start at the smallest distance if we are hiding
10556     if ( hide ) {
10557     distance = distance / Math.pow( 2, times - 1 );
10558     }
10559    
10560     downAnim = {};
10561     downAnim[ ref ] = 0;
10562     // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10563     for ( i = 0; i < times; i++ ) {
10564     upAnim = {};
10565     upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10566    
10567     el.animate( upAnim, speed, easing )
10568     .animate( downAnim, speed, easing );
10569    
10570     distance = hide ? distance * 2 : distance / 2;
10571     }
10572    
10573     // Last Bounce when Hiding
10574     if ( hide ) {
10575     upAnim = { opacity: 0 };
10576     upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10577    
10578     el.animate( upAnim, speed, easing );
10579     }
10580    
10581     el.queue(function() {
10582     if ( hide ) {
10583     el.hide();
10584     }
10585     $.effects.restore( el, props );
10586     $.effects.removeWrapper( el );
10587     done();
10588     });
10589    
10590     // inject all the animations we just queued to be first in line (after "inprogress")
10591     if ( queuelen > 1) {
10592     queue.splice.apply( queue,
10593     [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10594     }
10595     el.dequeue();
10596    
10597     };
10598    
10599     })(jQuery);
10600    
10601     (function( $, undefined ) {
10602    
10603     $.effects.effect.clip = function( o, done ) {
10604     // Create element
10605     var el = $( this ),
10606     props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10607     mode = $.effects.setMode( el, o.mode || "hide" ),
10608     show = mode === "show",
10609     direction = o.direction || "vertical",
10610     vert = direction === "vertical",
10611     size = vert ? "height" : "width",
10612     position = vert ? "top" : "left",
10613     animation = {},
10614     wrapper, animate, distance;
10615    
10616     // Save & Show
10617     $.effects.save( el, props );
10618     el.show();
10619    
10620     // Create Wrapper
10621     wrapper = $.effects.createWrapper( el ).css({
10622     overflow: "hidden"
10623     });
10624     animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
10625     distance = animate[ size ]();
10626    
10627     // Shift
10628     if ( show ) {
10629     animate.css( size, 0 );
10630     animate.css( position, distance / 2 );
10631     }
10632    
10633     // Create Animation Object:
10634     animation[ size ] = show ? distance : 0;
10635     animation[ position ] = show ? 0 : distance / 2;
10636    
10637     // Animate
10638     animate.animate( animation, {
10639     queue: false,
10640     duration: o.duration,
10641     easing: o.easing,
10642     complete: function() {
10643     if ( !show ) {
10644     el.hide();
10645     }
10646     $.effects.restore( el, props );
10647     $.effects.removeWrapper( el );
10648     done();
10649     }
10650     });
10651    
10652     };
10653    
10654     })(jQuery);
10655    
10656     (function( $, undefined ) {
10657    
10658     $.effects.effect.drop = function( o, done ) {
10659    
10660     var el = $( this ),
10661     props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
10662     mode = $.effects.setMode( el, o.mode || "hide" ),
10663     show = mode === "show",
10664     direction = o.direction || "left",
10665     ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10666     motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
10667     animation = {
10668     opacity: show ? 1 : 0
10669     },
10670     distance;
10671    
10672     // Adjust
10673     $.effects.save( el, props );
10674     el.show();
10675     $.effects.createWrapper( el );
10676    
10677     distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]( true ) / 2;
10678    
10679     if ( show ) {
10680     el
10681     .css( "opacity", 0 )
10682     .css( ref, motion === "pos" ? -distance : distance );
10683     }
10684    
10685     // Animation
10686     animation[ ref ] = ( show ?
10687     ( motion === "pos" ? "+=" : "-=" ) :
10688     ( motion === "pos" ? "-=" : "+=" ) ) +
10689     distance;
10690    
10691     // Animate
10692     el.animate( animation, {
10693     queue: false,
10694     duration: o.duration,
10695     easing: o.easing,
10696     complete: function() {
10697     if ( mode === "hide" ) {
10698     el.hide();
10699     }
10700     $.effects.restore( el, props );
10701     $.effects.removeWrapper( el );
10702     done();
10703     }
10704     });
10705     };
10706    
10707     })(jQuery);
10708    
10709     (function( $, undefined ) {
10710    
10711     $.effects.effect.explode = function( o, done ) {
10712    
10713     var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
10714     cells = rows,
10715     el = $( this ),
10716     mode = $.effects.setMode( el, o.mode || "hide" ),
10717     show = mode === "show",
10718    
10719     // show and then visibility:hidden the element before calculating offset
10720     offset = el.show().css( "visibility", "hidden" ).offset(),
10721    
10722     // width and height of a piece
10723     width = Math.ceil( el.outerWidth() / cells ),
10724     height = Math.ceil( el.outerHeight() / rows ),
10725     pieces = [],
10726    
10727     // loop
10728     i, j, left, top, mx, my;
10729    
10730     // children animate complete:
10731     function childComplete() {
10732     pieces.push( this );
10733     if ( pieces.length === rows * cells ) {
10734     animComplete();
10735     }
10736     }
10737    
10738     // clone the element for each row and cell.
10739     for( i = 0; i < rows ; i++ ) { // ===>
10740     top = offset.top + i * height;
10741     my = i - ( rows - 1 ) / 2 ;
10742    
10743     for( j = 0; j < cells ; j++ ) { // |||
10744     left = offset.left + j * width;
10745     mx = j - ( cells - 1 ) / 2 ;
10746    
10747     // Create a clone of the now hidden main element that will be absolute positioned
10748     // within a wrapper div off the -left and -top equal to size of our pieces
10749     el
10750     .clone()
10751     .appendTo( "body" )
10752     .wrap( "<div></div>" )
10753     .css({
10754     position: "absolute",
10755     visibility: "visible",
10756     left: -j * width,
10757     top: -i * height
10758     })
10759    
10760     // select the wrapper - make it overflow: hidden and absolute positioned based on
10761     // where the original was located +left and +top equal to the size of pieces
10762     .parent()
10763     .addClass( "ui-effects-explode" )
10764     .css({
10765     position: "absolute",
10766     overflow: "hidden",
10767     width: width,
10768     height: height,
10769     left: left + ( show ? mx * width : 0 ),
10770     top: top + ( show ? my * height : 0 ),
10771     opacity: show ? 0 : 1
10772     }).animate({
10773     left: left + ( show ? 0 : mx * width ),
10774     top: top + ( show ? 0 : my * height ),
10775     opacity: show ? 1 : 0
10776     }, o.duration || 500, o.easing, childComplete );
10777     }
10778     }
10779    
10780     function animComplete() {
10781     el.css({
10782     visibility: "visible"
10783     });
10784     $( pieces ).remove();
10785     if ( !show ) {
10786     el.hide();
10787     }
10788     done();
10789     }
10790     };
10791    
10792     })(jQuery);
10793    
10794     (function( $, undefined ) {
10795    
10796     $.effects.effect.fade = function( o, done ) {
10797     var el = $( this ),
10798     mode = $.effects.setMode( el, o.mode || "toggle" );
10799    
10800     el.animate({
10801     opacity: mode
10802     }, {
10803     queue: false,
10804     duration: o.duration,
10805     easing: o.easing,
10806     complete: done
10807     });
10808     };
10809    
10810     })( jQuery );
10811    
10812     (function( $, undefined ) {
10813    
10814     $.effects.effect.fold = function( o, done ) {
10815    
10816     // Create element
10817     var el = $( this ),
10818     props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10819     mode = $.effects.setMode( el, o.mode || "hide" ),
10820     show = mode === "show",
10821     hide = mode === "hide",
10822     size = o.size || 15,
10823     percent = /([0-9]+)%/.exec( size ),
10824     horizFirst = !!o.horizFirst,
10825     widthFirst = show !== horizFirst,
10826     ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
10827     duration = o.duration / 2,
10828     wrapper, distance,
10829     animation1 = {},
10830     animation2 = {};
10831    
10832     $.effects.save( el, props );
10833     el.show();
10834    
10835     // Create Wrapper
10836     wrapper = $.effects.createWrapper( el ).css({
10837     overflow: "hidden"
10838     });
10839     distance = widthFirst ?
10840     [ wrapper.width(), wrapper.height() ] :
10841     [ wrapper.height(), wrapper.width() ];
10842    
10843     if ( percent ) {
10844     size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
10845     }
10846     if ( show ) {
10847     wrapper.css( horizFirst ? {
10848     height: 0,
10849     width: size
10850     } : {
10851     height: size,
10852     width: 0
10853     });
10854     }
10855    
10856     // Animation
10857     animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
10858     animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
10859    
10860     // Animate
10861     wrapper
10862     .animate( animation1, duration, o.easing )
10863     .animate( animation2, duration, o.easing, function() {
10864     if ( hide ) {
10865     el.hide();
10866     }
10867     $.effects.restore( el, props );
10868     $.effects.removeWrapper( el );
10869     done();
10870     });
10871    
10872     };
10873    
10874     })(jQuery);
10875    
10876     (function( $, undefined ) {
10877    
10878     $.effects.effect.highlight = function( o, done ) {
10879     var elem = $( this ),
10880     props = [ "backgroundImage", "backgroundColor", "opacity" ],
10881     mode = $.effects.setMode( elem, o.mode || "show" ),
10882     animation = {
10883     backgroundColor: elem.css( "backgroundColor" )
10884     };
10885    
10886     if (mode === "hide") {
10887     animation.opacity = 0;
10888     }
10889    
10890     $.effects.save( elem, props );
10891    
10892     elem
10893     .show()
10894     .css({
10895     backgroundImage: "none",
10896     backgroundColor: o.color || "#ffff99"
10897     })
10898     .animate( animation, {
10899     queue: false,
10900     duration: o.duration,
10901     easing: o.easing,
10902     complete: function() {
10903     if ( mode === "hide" ) {
10904     elem.hide();
10905     }
10906     $.effects.restore( elem, props );
10907     done();
10908     }
10909     });
10910     };
10911    
10912     })(jQuery);
10913    
10914     (function( $, undefined ) {
10915    
10916     $.effects.effect.pulsate = function( o, done ) {
10917     var elem = $( this ),
10918     mode = $.effects.setMode( elem, o.mode || "show" ),
10919     show = mode === "show",
10920     hide = mode === "hide",
10921     showhide = ( show || mode === "hide" ),
10922    
10923     // showing or hiding leaves of the "last" animation
10924     anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
10925     duration = o.duration / anims,
10926     animateTo = 0,
10927     queue = elem.queue(),
10928     queuelen = queue.length,
10929     i;
10930    
10931     if ( show || !elem.is(":visible")) {
10932     elem.css( "opacity", 0 ).show();
10933     animateTo = 1;
10934     }
10935    
10936     // anims - 1 opacity "toggles"
10937     for ( i = 1; i < anims; i++ ) {
10938     elem.animate({
10939     opacity: animateTo
10940     }, duration, o.easing );
10941     animateTo = 1 - animateTo;
10942     }
10943    
10944     elem.animate({
10945     opacity: animateTo
10946     }, duration, o.easing);
10947    
10948     elem.queue(function() {
10949     if ( hide ) {
10950     elem.hide();
10951     }
10952     done();
10953     });
10954    
10955     // We just queued up "anims" animations, we need to put them next in the queue
10956     if ( queuelen > 1 ) {
10957     queue.splice.apply( queue,
10958     [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10959     }
10960     elem.dequeue();
10961     };
10962    
10963     })(jQuery);
10964    
10965     (function( $, undefined ) {
10966    
10967     $.effects.effect.puff = function( o, done ) {
10968     var elem = $( this ),
10969     mode = $.effects.setMode( elem, o.mode || "hide" ),
10970     hide = mode === "hide",
10971     percent = parseInt( o.percent, 10 ) || 150,
10972     factor = percent / 100,
10973     original = {
10974     height: elem.height(),
10975     width: elem.width(),
10976     outerHeight: elem.outerHeight(),
10977     outerWidth: elem.outerWidth()
10978     };
10979    
10980     $.extend( o, {
10981     effect: "scale",
10982     queue: false,
10983     fade: true,
10984     mode: mode,
10985     complete: done,
10986     percent: hide ? percent : 100,
10987     from: hide ?
10988     original :
10989     {
10990     height: original.height * factor,
10991     width: original.width * factor,
10992     outerHeight: original.outerHeight * factor,
10993     outerWidth: original.outerWidth * factor
10994     }
10995     });
10996    
10997     elem.effect( o );
10998     };
10999    
11000     $.effects.effect.scale = function( o, done ) {
11001    
11002     // Create element
11003     var el = $( this ),
11004     options = $.extend( true, {}, o ),
11005     mode = $.effects.setMode( el, o.mode || "effect" ),
11006     percent = parseInt( o.percent, 10 ) ||
11007     ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
11008     direction = o.direction || "both",
11009     origin = o.origin,
11010     original = {
11011     height: el.height(),
11012     width: el.width(),
11013     outerHeight: el.outerHeight(),
11014     outerWidth: el.outerWidth()
11015     },
11016     factor = {
11017     y: direction !== "horizontal" ? (percent / 100) : 1,
11018     x: direction !== "vertical" ? (percent / 100) : 1
11019     };
11020    
11021     // We are going to pass this effect to the size effect:
11022     options.effect = "size";
11023     options.queue = false;
11024     options.complete = done;
11025    
11026     // Set default origin and restore for show/hide
11027     if ( mode !== "effect" ) {
11028     options.origin = origin || ["middle","center"];
11029     options.restore = true;
11030     }
11031    
11032     options.from = o.from || ( mode === "show" ? {
11033     height: 0,
11034     width: 0,
11035     outerHeight: 0,
11036     outerWidth: 0
11037     } : original );
11038     options.to = {
11039     height: original.height * factor.y,
11040     width: original.width * factor.x,
11041     outerHeight: original.outerHeight * factor.y,
11042     outerWidth: original.outerWidth * factor.x
11043     };
11044    
11045     // Fade option to support puff
11046     if ( options.fade ) {
11047     if ( mode === "show" ) {
11048     options.from.opacity = 0;
11049     options.to.opacity = 1;
11050     }
11051     if ( mode === "hide" ) {
11052     options.from.opacity = 1;
11053     options.to.opacity = 0;
11054     }
11055     }
11056    
11057     // Animate
11058     el.effect( options );
11059    
11060     };
11061    
11062     $.effects.effect.size = function( o, done ) {
11063    
11064     // Create element
11065     var original, baseline, factor,
11066     el = $( this ),
11067     props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11068    
11069     // Always restore
11070     props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
11071    
11072     // Copy for children
11073     props2 = [ "width", "height", "overflow" ],
11074     cProps = [ "fontSize" ],
11075     vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
11076     hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
11077    
11078     // Set options
11079     mode = $.effects.setMode( el, o.mode || "effect" ),
11080     restore = o.restore || mode !== "effect",
11081     scale = o.scale || "both",
11082     origin = o.origin || [ "middle", "center" ],
11083     position = el.css( "position" ),
11084     props = restore ? props0 : props1,
11085     zero = {
11086     height: 0,
11087     width: 0,
11088     outerHeight: 0,
11089     outerWidth: 0
11090     };
11091    
11092     if ( mode === "show" ) {
11093     el.show();
11094     }
11095     original = {
11096     height: el.height(),
11097     width: el.width(),
11098     outerHeight: el.outerHeight(),
11099     outerWidth: el.outerWidth()
11100     };
11101    
11102     if ( o.mode === "toggle" && mode === "show" ) {
11103     el.from = o.to || zero;
11104     el.to = o.from || original;
11105     } else {
11106     el.from = o.from || ( mode === "show" ? zero : original );
11107     el.to = o.to || ( mode === "hide" ? zero : original );
11108     }
11109    
11110     // Set scaling factor
11111     factor = {
11112     from: {
11113     y: el.from.height / original.height,
11114     x: el.from.width / original.width
11115     },
11116     to: {
11117     y: el.to.height / original.height,
11118     x: el.to.width / original.width
11119     }
11120     };
11121    
11122     // Scale the css box
11123     if ( scale === "box" || scale === "both" ) {
11124    
11125     // Vertical props scaling
11126     if ( factor.from.y !== factor.to.y ) {
11127     props = props.concat( vProps );
11128     el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
11129     el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
11130     }
11131    
11132     // Horizontal props scaling
11133     if ( factor.from.x !== factor.to.x ) {
11134     props = props.concat( hProps );
11135     el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
11136     el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
11137     }
11138     }
11139    
11140     // Scale the content
11141     if ( scale === "content" || scale === "both" ) {
11142    
11143     // Vertical props scaling
11144     if ( factor.from.y !== factor.to.y ) {
11145     props = props.concat( cProps ).concat( props2 );
11146     el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
11147     el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
11148     }
11149     }
11150    
11151     $.effects.save( el, props );
11152     el.show();
11153     $.effects.createWrapper( el );
11154     el.css( "overflow", "hidden" ).css( el.from );
11155    
11156     // Adjust
11157     if (origin) { // Calculate baseline shifts
11158     baseline = $.effects.getBaseline( origin, original );
11159     el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
11160     el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
11161     el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
11162     el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
11163     }
11164     el.css( el.from ); // set top & left
11165    
11166     // Animate
11167     if ( scale === "content" || scale === "both" ) { // Scale the children
11168    
11169     // Add margins/font-size
11170     vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
11171     hProps = hProps.concat([ "marginLeft", "marginRight" ]);
11172     props2 = props0.concat(vProps).concat(hProps);
11173    
11174     el.find( "*[width]" ).each( function(){
11175     var child = $( this ),
11176     c_original = {
11177     height: child.height(),
11178     width: child.width(),
11179     outerHeight: child.outerHeight(),
11180     outerWidth: child.outerWidth()
11181     };
11182     if (restore) {
11183     $.effects.save(child, props2);
11184     }
11185    
11186     child.from = {
11187     height: c_original.height * factor.from.y,
11188     width: c_original.width * factor.from.x,
11189     outerHeight: c_original.outerHeight * factor.from.y,
11190     outerWidth: c_original.outerWidth * factor.from.x
11191     };
11192     child.to = {
11193     height: c_original.height * factor.to.y,
11194     width: c_original.width * factor.to.x,
11195     outerHeight: c_original.height * factor.to.y,
11196     outerWidth: c_original.width * factor.to.x
11197     };
11198    
11199     // Vertical props scaling
11200     if ( factor.from.y !== factor.to.y ) {
11201     child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
11202     child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
11203     }
11204    
11205     // Horizontal props scaling
11206     if ( factor.from.x !== factor.to.x ) {
11207     child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
11208     child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
11209     }
11210    
11211     // Animate children
11212     child.css( child.from );
11213     child.animate( child.to, o.duration, o.easing, function() {
11214    
11215     // Restore children
11216     if ( restore ) {
11217     $.effects.restore( child, props2 );
11218     }
11219     });
11220     });
11221     }
11222    
11223     // Animate
11224     el.animate( el.to, {
11225     queue: false,
11226     duration: o.duration,
11227     easing: o.easing,
11228     complete: function() {
11229     if ( el.to.opacity === 0 ) {
11230     el.css( "opacity", el.from.opacity );
11231     }
11232     if( mode === "hide" ) {
11233     el.hide();
11234     }
11235     $.effects.restore( el, props );
11236     if ( !restore ) {
11237    
11238     // we need to calculate our new positioning based on the scaling
11239     if ( position === "static" ) {
11240     el.css({
11241     position: "relative",
11242     top: el.to.top,
11243     left: el.to.left
11244     });
11245     } else {
11246     $.each([ "top", "left" ], function( idx, pos ) {
11247     el.css( pos, function( _, str ) {
11248     var val = parseInt( str, 10 ),
11249     toRef = idx ? el.to.left : el.to.top;
11250    
11251     // if original was "auto", recalculate the new value from wrapper
11252     if ( str === "auto" ) {
11253     return toRef + "px";
11254     }
11255    
11256     return val + toRef + "px";
11257     });
11258     });
11259     }
11260     }
11261    
11262     $.effects.removeWrapper( el );
11263     done();
11264     }
11265     });
11266    
11267     };
11268    
11269     })(jQuery);
11270    
11271     (function( $, undefined ) {
11272    
11273     $.effects.effect.shake = function( o, done ) {
11274    
11275     var el = $( this ),
11276     props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11277     mode = $.effects.setMode( el, o.mode || "effect" ),
11278     direction = o.direction || "left",
11279     distance = o.distance || 20,
11280     times = o.times || 3,
11281     anims = times * 2 + 1,
11282     speed = Math.round(o.duration/anims),
11283     ref = (direction === "up" || direction === "down") ? "top" : "left",
11284     positiveMotion = (direction === "up" || direction === "left"),
11285     animation = {},
11286     animation1 = {},
11287     animation2 = {},
11288     i,
11289    
11290     // we will need to re-assemble the queue to stack our animations in place
11291     queue = el.queue(),
11292     queuelen = queue.length;
11293    
11294     $.effects.save( el, props );
11295     el.show();
11296     $.effects.createWrapper( el );
11297    
11298     // Animation
11299     animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
11300     animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
11301     animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
11302    
11303     // Animate
11304     el.animate( animation, speed, o.easing );
11305    
11306     // Shakes
11307     for ( i = 1; i < times; i++ ) {
11308     el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
11309     }
11310     el
11311     .animate( animation1, speed, o.easing )
11312     .animate( animation, speed / 2, o.easing )
11313     .queue(function() {
11314     if ( mode === "hide" ) {
11315     el.hide();
11316     }
11317     $.effects.restore( el, props );
11318     $.effects.removeWrapper( el );
11319     done();
11320     });
11321    
11322     // inject all the animations we just queued to be first in line (after "inprogress")
11323     if ( queuelen > 1) {
11324     queue.splice.apply( queue,
11325     [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11326     }
11327     el.dequeue();
11328    
11329     };
11330    
11331     })(jQuery);
11332    
11333     (function( $, undefined ) {
11334    
11335     $.effects.effect.slide = function( o, done ) {
11336    
11337     // Create element
11338     var el = $( this ),
11339     props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
11340     mode = $.effects.setMode( el, o.mode || "show" ),
11341     show = mode === "show",
11342     direction = o.direction || "left",
11343     ref = (direction === "up" || direction === "down") ? "top" : "left",
11344     positiveMotion = (direction === "up" || direction === "left"),
11345     distance,
11346     animation = {};
11347    
11348     // Adjust
11349     $.effects.save( el, props );
11350     el.show();
11351     distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
11352    
11353     $.effects.createWrapper( el ).css({
11354     overflow: "hidden"
11355     });
11356    
11357     if ( show ) {
11358     el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
11359     }
11360    
11361     // Animation
11362     animation[ ref ] = ( show ?
11363     ( positiveMotion ? "+=" : "-=") :
11364     ( positiveMotion ? "-=" : "+=")) +
11365     distance;
11366    
11367     // Animate
11368     el.animate( animation, {
11369     queue: false,
11370     duration: o.duration,
11371     easing: o.easing,
11372     complete: function() {
11373     if ( mode === "hide" ) {
11374     el.hide();
11375     }
11376     $.effects.restore( el, props );
11377     $.effects.removeWrapper( el );
11378     done();
11379     }
11380     });
11381     };
11382    
11383     })(jQuery);
11384    
11385     (function( $, undefined ) {
11386    
11387     $.effects.effect.transfer = function( o, done ) {
11388     var elem = $( this ),
11389     target = $( o.to ),
11390     targetFixed = target.css( "position" ) === "fixed",
11391     body = $("body"),
11392     fixTop = targetFixed ? body.scrollTop() : 0,
11393     fixLeft = targetFixed ? body.scrollLeft() : 0,
11394     endPosition = target.offset(),
11395     animation = {
11396     top: endPosition.top - fixTop ,
11397     left: endPosition.left - fixLeft ,
11398     height: target.innerHeight(),
11399     width: target.innerWidth()
11400     },
11401     startPosition = elem.offset(),
11402     transfer = $( "<div class='ui-effects-transfer'></div>" )
11403     .appendTo( document.body )
11404     .addClass( o.className )
11405     .css({
11406     top: startPosition.top - fixTop ,
11407     left: startPosition.left - fixLeft ,
11408     height: elem.innerHeight(),
11409     width: elem.innerWidth(),
11410     position: targetFixed ? "fixed" : "absolute"
11411     })
11412     .animate( animation, o.duration, o.easing, function() {
11413     transfer.remove();
11414     done();
11415     });
11416     };
11417    
11418     })(jQuery);
11419    
11420     (function( $, undefined ) {
11421    
11422     $.widget( "ui.menu", {
11423     version: "1.10.3",
11424     defaultElement: "<ul>",
11425     delay: 300,
11426     options: {
11427     icons: {
11428     submenu: "ui-icon-carat-1-e"
11429     },
11430     menus: "ul",
11431     position: {
11432     my: "left top",
11433     at: "right top"
11434     },
11435     role: "menu",
11436    
11437     // callbacks
11438     blur: null,
11439     focus: null,
11440     select: null
11441     },
11442    
11443     _create: function() {
11444     this.activeMenu = this.element;
11445     // flag used to prevent firing of the click handler
11446     // as the event bubbles up through nested menus
11447     this.mouseHandled = false;
11448     this.element
11449     .uniqueId()
11450     .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
11451     .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
11452     .attr({
11453     role: this.options.role,
11454     tabIndex: 0
11455     })
11456     // need to catch all clicks on disabled menu
11457     // not possible through _on
11458     .bind( "click" + this.eventNamespace, $.proxy(function( event ) {
11459     if ( this.options.disabled ) {
11460     event.preventDefault();
11461     }
11462     }, this ));
11463    
11464     if ( this.options.disabled ) {
11465     this.element
11466     .addClass( "ui-state-disabled" )
11467     .attr( "aria-disabled", "true" );
11468     }
11469    
11470     this._on({
11471     // Prevent focus from sticking to links inside menu after clicking
11472     // them (focus should always stay on UL during navigation).
11473     "mousedown .ui-menu-item > a": function( event ) {
11474     event.preventDefault();
11475     },
11476     "click .ui-state-disabled > a": function( event ) {
11477     event.preventDefault();
11478     },
11479     "click .ui-menu-item:has(a)": function( event ) {
11480     var target = $( event.target ).closest( ".ui-menu-item" );
11481     if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
11482     this.mouseHandled = true;
11483    
11484     this.select( event );
11485     // Open submenu on click
11486     if ( target.has( ".ui-menu" ).length ) {
11487     this.expand( event );
11488     } else if ( !this.element.is( ":focus" ) ) {
11489     // Redirect focus to the menu
11490     this.element.trigger( "focus", [ true ] );
11491    
11492     // If the active item is on the top level, let it stay active.
11493     // Otherwise, blur the active item since it is no longer visible.
11494     if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
11495     clearTimeout( this.timer );
11496     }
11497     }
11498     }
11499     },
11500     "mouseenter .ui-menu-item": function( event ) {
11501     var target = $( event.currentTarget );
11502     // Remove ui-state-active class from siblings of the newly focused menu item
11503     // to avoid a jump caused by adjacent elements both having a class with a border
11504     target.siblings().children( ".ui-state-active" ).removeClass( "ui-state-active" );
11505     this.focus( event, target );
11506     },
11507     mouseleave: "collapseAll",
11508     "mouseleave .ui-menu": "collapseAll",
11509     focus: function( event, keepActiveItem ) {
11510     // If there's already an active item, keep it active
11511     // If not, activate the first item
11512     var item = this.active || this.element.children( ".ui-menu-item" ).eq( 0 );
11513    
11514     if ( !keepActiveItem ) {
11515     this.focus( event, item );
11516     }
11517     },
11518     blur: function( event ) {
11519     this._delay(function() {
11520     if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
11521     this.collapseAll( event );
11522     }
11523     });
11524     },
11525     keydown: "_keydown"
11526     });
11527    
11528     this.refresh();
11529    
11530     // Clicks outside of a menu collapse any open menus
11531     this._on( this.document, {
11532     click: function( event ) {
11533     if ( !$( event.target ).closest( ".ui-menu" ).length ) {
11534     this.collapseAll( event );
11535     }
11536    
11537     // Reset the mouseHandled flag
11538     this.mouseHandled = false;
11539     }
11540     });
11541     },
11542    
11543     _destroy: function() {
11544     // Destroy (sub)menus
11545     this.element
11546     .removeAttr( "aria-activedescendant" )
11547     .find( ".ui-menu" ).addBack()
11548     .removeClass( "ui-menu ui-widget ui-widget-content ui-corner-all ui-menu-icons" )
11549     .removeAttr( "role" )
11550     .removeAttr( "tabIndex" )
11551     .removeAttr( "aria-labelledby" )
11552     .removeAttr( "aria-expanded" )
11553     .removeAttr( "aria-hidden" )
11554     .removeAttr( "aria-disabled" )
11555     .removeUniqueId()
11556     .show();
11557    
11558     // Destroy menu items
11559     this.element.find( ".ui-menu-item" )
11560     .removeClass( "ui-menu-item" )
11561     .removeAttr( "role" )
11562     .removeAttr( "aria-disabled" )
11563     .children( "a" )
11564     .removeUniqueId()
11565     .removeClass( "ui-corner-all ui-state-hover" )
11566     .removeAttr( "tabIndex" )
11567     .removeAttr( "role" )
11568     .removeAttr( "aria-haspopup" )
11569     .children().each( function() {
11570     var elem = $( this );
11571     if ( elem.data( "ui-menu-submenu-carat" ) ) {
11572     elem.remove();
11573     }
11574     });
11575    
11576     // Destroy menu dividers
11577     this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
11578     },
11579    
11580     _keydown: function( event ) {
11581     /*jshint maxcomplexity:20*/
11582     var match, prev, character, skip, regex,
11583     preventDefault = true;
11584    
11585     function escape( value ) {
11586     return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
11587     }
11588    
11589     switch ( event.keyCode ) {
11590     case $.ui.keyCode.PAGE_UP:
11591     this.previousPage( event );
11592     break;
11593     case $.ui.keyCode.PAGE_DOWN:
11594     this.nextPage( event );
11595     break;
11596     case $.ui.keyCode.HOME:
11597     this._move( "first", "first", event );
11598     break;
11599     case $.ui.keyCode.END:
11600     this._move( "last", "last", event );
11601     break;
11602     case $.ui.keyCode.UP:
11603     this.previous( event );
11604     break;
11605     case $.ui.keyCode.DOWN:
11606     this.next( event );
11607     break;
11608     case $.ui.keyCode.LEFT:
11609     this.collapse( event );
11610     break;
11611     case $.ui.keyCode.RIGHT:
11612     if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
11613     this.expand( event );
11614     }
11615     break;
11616     case $.ui.keyCode.ENTER:
11617     case $.ui.keyCode.SPACE:
11618     this._activate( event );
11619     break;
11620     case $.ui.keyCode.ESCAPE:
11621     this.collapse( event );
11622     break;
11623     default:
11624     preventDefault = false;
11625     prev = this.previousFilter || "";
11626     character = String.fromCharCode( event.keyCode );
11627     skip = false;
11628    
11629     clearTimeout( this.filterTimer );
11630    
11631     if ( character === prev ) {
11632     skip = true;
11633     } else {
11634     character = prev + character;
11635     }
11636    
11637     regex = new RegExp( "^" + escape( character ), "i" );
11638     match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
11639     return regex.test( $( this ).children( "a" ).text() );
11640     });
11641     match = skip && match.index( this.active.next() ) !== -1 ?
11642     this.active.nextAll( ".ui-menu-item" ) :
11643     match;
11644    
11645     // If no matches on the current filter, reset to the last character pressed
11646     // to move down the menu to the first item that starts with that character
11647     if ( !match.length ) {
11648     character = String.fromCharCode( event.keyCode );
11649     regex = new RegExp( "^" + escape( character ), "i" );
11650     match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
11651     return regex.test( $( this ).children( "a" ).text() );
11652     });
11653     }
11654    
11655     if ( match.length ) {
11656     this.focus( event, match );
11657     if ( match.length > 1 ) {
11658     this.previousFilter = character;
11659     this.filterTimer = this._delay(function() {
11660     delete this.previousFilter;
11661     }, 1000 );
11662     } else {
11663     delete this.previousFilter;
11664     }
11665     } else {
11666     delete this.previousFilter;
11667     }
11668     }
11669    
11670     if ( preventDefault ) {
11671     event.preventDefault();
11672     }
11673     },
11674    
11675     _activate: function( event ) {
11676     if ( !this.active.is( ".ui-state-disabled" ) ) {
11677     if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
11678     this.expand( event );
11679     } else {
11680     this.select( event );
11681     }
11682     }
11683     },
11684    
11685     refresh: function() {
11686     var menus,
11687     icon = this.options.icons.submenu,
11688     submenus = this.element.find( this.options.menus );
11689    
11690     // Initialize nested menus
11691     submenus.filter( ":not(.ui-menu)" )
11692     .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
11693     .hide()
11694     .attr({
11695     role: this.options.role,
11696     "aria-hidden": "true",
11697     "aria-expanded": "false"
11698     })
11699     .each(function() {
11700     var menu = $( this ),
11701     item = menu.prev( "a" ),
11702     submenuCarat = $( "<span>" )
11703     .addClass( "ui-menu-icon ui-icon " + icon )
11704     .data( "ui-menu-submenu-carat", true );
11705    
11706     item
11707     .attr( "aria-haspopup", "true" )
11708     .prepend( submenuCarat );
11709     menu.attr( "aria-labelledby", item.attr( "id" ) );
11710     });
11711    
11712     menus = submenus.add( this.element );
11713    
11714     // Don't refresh list items that are already adapted
11715     menus.children( ":not(.ui-menu-item):has(a)" )
11716     .addClass( "ui-menu-item" )
11717     .attr( "role", "presentation" )
11718     .children( "a" )
11719     .uniqueId()
11720     .addClass( "ui-corner-all" )
11721     .attr({
11722     tabIndex: -1,
11723     role: this._itemRole()
11724     });
11725    
11726     // Initialize unlinked menu-items containing spaces and/or dashes only as dividers
11727     menus.children( ":not(.ui-menu-item)" ).each(function() {
11728     var item = $( this );
11729     // hyphen, em dash, en dash
11730     if ( !/[^\-\u2014\u2013\s]/.test( item.text() ) ) {
11731     item.addClass( "ui-widget-content ui-menu-divider" );
11732     }
11733     });
11734    
11735     // Add aria-disabled attribute to any disabled menu item
11736     menus.children( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
11737    
11738     // If the active item has been removed, blur the menu
11739     if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
11740     this.blur();
11741     }
11742     },
11743    
11744     _itemRole: function() {
11745     return {
11746     menu: "menuitem",
11747     listbox: "option"
11748     }[ this.options.role ];
11749     },
11750    
11751     _setOption: function( key, value ) {
11752     if ( key === "icons" ) {
11753     this.element.find( ".ui-menu-icon" )
11754     .removeClass( this.options.icons.submenu )
11755     .addClass( value.submenu );
11756     }
11757     this._super( key, value );
11758     },
11759    
11760     focus: function( event, item ) {
11761     var nested, focused;
11762     this.blur( event, event && event.type === "focus" );
11763    
11764     this._scrollIntoView( item );
11765    
11766     this.active = item.first();
11767     focused = this.active.children( "a" ).addClass( "ui-state-focus" );
11768     // Only update aria-activedescendant if there's a role
11769     // otherwise we assume focus is managed elsewhere
11770     if ( this.options.role ) {
11771     this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
11772     }
11773    
11774     // Highlight active parent menu item, if any
11775     this.active
11776     .parent()
11777     .closest( ".ui-menu-item" )
11778     .children( "a:first" )
11779     .addClass( "ui-state-active" );
11780    
11781     if ( event && event.type === "keydown" ) {
11782     this._close();
11783     } else {
11784     this.timer = this._delay(function() {
11785     this._close();
11786     }, this.delay );
11787     }
11788    
11789     nested = item.children( ".ui-menu" );
11790     if ( nested.length && ( /^mouse/.test( event.type ) ) ) {
11791     this._startOpening(nested);
11792     }
11793     this.activeMenu = item.parent();
11794    
11795     this._trigger( "focus", event, { item: item } );
11796     },
11797    
11798     _scrollIntoView: function( item ) {
11799     var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
11800     if ( this._hasScroll() ) {
11801     borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
11802     paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
11803     offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
11804     scroll = this.activeMenu.scrollTop();
11805     elementHeight = this.activeMenu.height();
11806     itemHeight = item.height();
11807    
11808     if ( offset < 0 ) {
11809     this.activeMenu.scrollTop( scroll + offset );
11810     } else if ( offset + itemHeight > elementHeight ) {
11811     this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
11812     }
11813     }
11814     },
11815    
11816     blur: function( event, fromFocus ) {
11817     if ( !fromFocus ) {
11818     clearTimeout( this.timer );
11819     }
11820    
11821     if ( !this.active ) {
11822     return;
11823     }
11824    
11825     this.active.children( "a" ).removeClass( "ui-state-focus" );
11826     this.active = null;
11827    
11828     this._trigger( "blur", event, { item: this.active } );
11829     },
11830    
11831     _startOpening: function( submenu ) {
11832     clearTimeout( this.timer );
11833    
11834     // Don't open if already open fixes a Firefox bug that caused a .5 pixel
11835     // shift in the submenu position when mousing over the carat icon
11836     if ( submenu.attr( "aria-hidden" ) !== "true" ) {
11837     return;
11838     }
11839    
11840     this.timer = this._delay(function() {
11841     this._close();
11842     this._open( submenu );
11843     }, this.delay );
11844     },
11845    
11846     _open: function( submenu ) {
11847     var position = $.extend({
11848     of: this.active
11849     }, this.options.position );
11850    
11851     clearTimeout( this.timer );
11852     this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
11853     .hide()
11854     .attr( "aria-hidden", "true" );
11855    
11856     submenu
11857     .show()
11858     .removeAttr( "aria-hidden" )
11859     .attr( "aria-expanded", "true" )
11860     .position( position );
11861     },
11862    
11863     collapseAll: function( event, all ) {
11864     clearTimeout( this.timer );
11865     this.timer = this._delay(function() {
11866     // If we were passed an event, look for the submenu that contains the event
11867     var currentMenu = all ? this.element :
11868     $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
11869    
11870     // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
11871     if ( !currentMenu.length ) {
11872     currentMenu = this.element;
11873     }
11874    
11875     this._close( currentMenu );
11876    
11877     this.blur( event );
11878     this.activeMenu = currentMenu;
11879     }, this.delay );
11880     },
11881    
11882     // With no arguments, closes the currently active menu - if nothing is active
11883     // it closes all menus. If passed an argument, it will search for menus BELOW
11884     _close: function( startMenu ) {
11885     if ( !startMenu ) {
11886     startMenu = this.active ? this.active.parent() : this.element;
11887     }
11888    
11889     startMenu
11890     .find( ".ui-menu" )
11891     .hide()
11892     .attr( "aria-hidden", "true" )
11893     .attr( "aria-expanded", "false" )
11894     .end()
11895     .find( "a.ui-state-active" )
11896     .removeClass( "ui-state-active" );
11897     },
11898    
11899     collapse: function( event ) {
11900     var newItem = this.active &&
11901     this.active.parent().closest( ".ui-menu-item", this.element );
11902     if ( newItem && newItem.length ) {
11903     this._close();
11904     this.focus( event, newItem );
11905     }
11906     },
11907    
11908     expand: function( event ) {
11909     var newItem = this.active &&
11910     this.active
11911     .children( ".ui-menu " )
11912     .children( ".ui-menu-item" )
11913     .first();
11914    
11915     if ( newItem && newItem.length ) {
11916     this._open( newItem.parent() );
11917    
11918     // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
11919     this._delay(function() {
11920     this.focus( event, newItem );
11921     });
11922     }
11923     },
11924    
11925     next: function( event ) {
11926     this._move( "next", "first", event );
11927     },
11928    
11929     previous: function( event ) {
11930     this._move( "prev", "last", event );
11931     },
11932    
11933     isFirstItem: function() {
11934     return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
11935     },
11936    
11937     isLastItem: function() {
11938     return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
11939     },
11940    
11941     _move: function( direction, filter, event ) {
11942     var next;
11943     if ( this.active ) {
11944     if ( direction === "first" || direction === "last" ) {
11945     next = this.active
11946     [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
11947     .eq( -1 );
11948     } else {
11949     next = this.active
11950     [ direction + "All" ]( ".ui-menu-item" )
11951     .eq( 0 );
11952     }
11953     }
11954     if ( !next || !next.length || !this.active ) {
11955     next = this.activeMenu.children( ".ui-menu-item" )[ filter ]();
11956     }
11957    
11958     this.focus( event, next );
11959     },
11960    
11961     nextPage: function( event ) {
11962     var item, base, height;
11963    
11964     if ( !this.active ) {
11965     this.next( event );
11966     return;
11967     }
11968     if ( this.isLastItem() ) {
11969     return;
11970     }
11971     if ( this._hasScroll() ) {
11972     base = this.active.offset().top;
11973     height = this.element.height();
11974     this.active.nextAll( ".ui-menu-item" ).each(function() {
11975     item = $( this );
11976     return item.offset().top - base - height < 0;
11977     });
11978    
11979     this.focus( event, item );
11980     } else {
11981     this.focus( event, this.activeMenu.children( ".ui-menu-item" )
11982     [ !this.active ? "first" : "last" ]() );
11983     }
11984     },
11985    
11986     previousPage: function( event ) {
11987     var item, base, height;
11988     if ( !this.active ) {
11989     this.next( event );
11990     return;
11991     }
11992     if ( this.isFirstItem() ) {
11993     return;
11994     }
11995     if ( this._hasScroll() ) {
11996     base = this.active.offset().top;
11997     height = this.element.height();
11998     this.active.prevAll( ".ui-menu-item" ).each(function() {
11999     item = $( this );
12000     return item.offset().top - base + height > 0;
12001     });
12002    
12003     this.focus( event, item );
12004     } else {
12005     this.focus( event, this.activeMenu.children( ".ui-menu-item" ).first() );
12006     }
12007     },
12008    
12009     _hasScroll: function() {
12010     return this.element.outerHeight() < this.element.prop( "scrollHeight" );
12011     },
12012    
12013     select: function( event ) {
12014     // TODO: It should never be possible to not have an active item at this
12015     // point, but the tests don't trigger mouseenter before click.
12016     this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
12017     var ui = { item: this.active };
12018     if ( !this.active.has( ".ui-menu" ).length ) {
12019     this.collapseAll( event, true );
12020     }
12021     this._trigger( "select", event, ui );
12022     }
12023     });
12024    
12025     }( jQuery ));
12026    
12027     (function( $, undefined ) {
12028    
12029     $.ui = $.ui || {};
12030    
12031     var cachedScrollbarWidth,
12032     max = Math.max,
12033     abs = Math.abs,
12034     round = Math.round,
12035     rhorizontal = /left|center|right/,
12036     rvertical = /top|center|bottom/,
12037     roffset = /[\+\-]\d+(\.[\d]+)?%?/,
12038     rposition = /^\w+/,
12039     rpercent = /%$/,
12040     _position = $.fn.position;
12041    
12042     function getOffsets( offsets, width, height ) {
12043     return [
12044     parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
12045     parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
12046     ];
12047     }
12048    
12049     function parseCss( element, property ) {
12050     return parseInt( $.css( element, property ), 10 ) || 0;
12051     }
12052    
12053     function getDimensions( elem ) {
12054     var raw = elem[0];
12055     if ( raw.nodeType === 9 ) {
12056     return {
12057     width: elem.width(),
12058     height: elem.height(),
12059     offset: { top: 0, left: 0 }
12060     };
12061     }
12062     if ( $.isWindow( raw ) ) {
12063     return {
12064     width: elem.width(),
12065     height: elem.height(),
12066     offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
12067     };
12068     }
12069     if ( raw.preventDefault ) {
12070     return {
12071     width: 0,
12072     height: 0,
12073     offset: { top: raw.pageY, left: raw.pageX }
12074     };
12075     }
12076     return {
12077     width: elem.outerWidth(),
12078     height: elem.outerHeight(),
12079     offset: elem.offset()
12080     };
12081     }
12082    
12083     $.position = {
12084     scrollbarWidth: function() {
12085     if ( cachedScrollbarWidth !== undefined ) {
12086     return cachedScrollbarWidth;
12087     }
12088     var w1, w2,
12089     div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
12090     innerDiv = div.children()[0];
12091    
12092     $( "body" ).append( div );
12093     w1 = innerDiv.offsetWidth;
12094     div.css( "overflow", "scroll" );
12095    
12096     w2 = innerDiv.offsetWidth;
12097    
12098     if ( w1 === w2 ) {
12099     w2 = div[0].clientWidth;
12100     }
12101    
12102     div.remove();
12103    
12104     return (cachedScrollbarWidth = w1 - w2);
12105     },
12106     getScrollInfo: function( within ) {
12107     var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
12108     overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
12109     hasOverflowX = overflowX === "scroll" ||
12110     ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
12111     hasOverflowY = overflowY === "scroll" ||
12112     ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
12113     return {
12114     width: hasOverflowY ? $.position.scrollbarWidth() : 0,
12115     height: hasOverflowX ? $.position.scrollbarWidth() : 0
12116     };
12117     },
12118     getWithinInfo: function( element ) {
12119     var withinElement = $( element || window ),
12120     isWindow = $.isWindow( withinElement[0] );
12121     return {
12122     element: withinElement,
12123     isWindow: isWindow,
12124     offset: withinElement.offset() || { left: 0, top: 0 },
12125     scrollLeft: withinElement.scrollLeft(),
12126     scrollTop: withinElement.scrollTop(),
12127     width: isWindow ? withinElement.width() : withinElement.outerWidth(),
12128     height: isWindow ? withinElement.height() : withinElement.outerHeight()
12129     };
12130     }
12131     };
12132    
12133     $.fn.position = function( options ) {
12134     if ( !options || !options.of ) {
12135     return _position.apply( this, arguments );
12136     }
12137    
12138     // make a copy, we don't want to modify arguments
12139     options = $.extend( {}, options );
12140    
12141     var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
12142     target = $( options.of ),
12143     within = $.position.getWithinInfo( options.within ),
12144     scrollInfo = $.position.getScrollInfo( within ),
12145     collision = ( options.collision || "flip" ).split( " " ),
12146     offsets = {};
12147    
12148     dimensions = getDimensions( target );
12149     if ( target[0].preventDefault ) {
12150     // force left top to allow flipping
12151     options.at = "left top";
12152     }
12153     targetWidth = dimensions.width;
12154     targetHeight = dimensions.height;
12155     targetOffset = dimensions.offset;
12156     // clone to reuse original targetOffset later
12157     basePosition = $.extend( {}, targetOffset );
12158    
12159     // force my and at to have valid horizontal and vertical positions
12160     // if a value is missing or invalid, it will be converted to center
12161     $.each( [ "my", "at" ], function() {
12162     var pos = ( options[ this ] || "" ).split( " " ),
12163     horizontalOffset,
12164     verticalOffset;
12165    
12166     if ( pos.length === 1) {
12167     pos = rhorizontal.test( pos[ 0 ] ) ?
12168     pos.concat( [ "center" ] ) :
12169     rvertical.test( pos[ 0 ] ) ?
12170     [ "center" ].concat( pos ) :
12171     [ "center", "center" ];
12172     }
12173     pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
12174     pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
12175    
12176     // calculate offsets
12177     horizontalOffset = roffset.exec( pos[ 0 ] );
12178     verticalOffset = roffset.exec( pos[ 1 ] );
12179     offsets[ this ] = [
12180     horizontalOffset ? horizontalOffset[ 0 ] : 0,
12181     verticalOffset ? verticalOffset[ 0 ] : 0
12182     ];
12183    
12184     // reduce to just the positions without the offsets
12185     options[ this ] = [
12186     rposition.exec( pos[ 0 ] )[ 0 ],
12187     rposition.exec( pos[ 1 ] )[ 0 ]
12188     ];
12189     });
12190    
12191     // normalize collision option
12192     if ( collision.length === 1 ) {
12193     collision[ 1 ] = collision[ 0 ];
12194     }
12195    
12196     if ( options.at[ 0 ] === "right" ) {
12197     basePosition.left += targetWidth;
12198     } else if ( options.at[ 0 ] === "center" ) {
12199     basePosition.left += targetWidth / 2;
12200     }
12201    
12202     if ( options.at[ 1 ] === "bottom" ) {
12203     basePosition.top += targetHeight;
12204     } else if ( options.at[ 1 ] === "center" ) {
12205     basePosition.top += targetHeight / 2;
12206     }
12207    
12208     atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
12209     basePosition.left += atOffset[ 0 ];
12210     basePosition.top += atOffset[ 1 ];
12211    
12212     return this.each(function() {
12213     var collisionPosition, using,
12214     elem = $( this ),
12215     elemWidth = elem.outerWidth(),
12216     elemHeight = elem.outerHeight(),
12217     marginLeft = parseCss( this, "marginLeft" ),
12218     marginTop = parseCss( this, "marginTop" ),
12219     collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
12220     collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
12221     position = $.extend( {}, basePosition ),
12222     myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
12223    
12224     if ( options.my[ 0 ] === "right" ) {
12225     position.left -= elemWidth;
12226     } else if ( options.my[ 0 ] === "center" ) {
12227     position.left -= elemWidth / 2;
12228     }
12229    
12230     if ( options.my[ 1 ] === "bottom" ) {
12231     position.top -= elemHeight;
12232     } else if ( options.my[ 1 ] === "center" ) {
12233     position.top -= elemHeight / 2;
12234     }
12235    
12236     position.left += myOffset[ 0 ];
12237     position.top += myOffset[ 1 ];
12238    
12239     // if the browser doesn't support fractions, then round for consistent results
12240     if ( !$.support.offsetFractions ) {
12241     position.left = round( position.left );
12242     position.top = round( position.top );
12243     }
12244    
12245     collisionPosition = {
12246     marginLeft: marginLeft,
12247     marginTop: marginTop
12248     };
12249    
12250     $.each( [ "left", "top" ], function( i, dir ) {
12251     if ( $.ui.position[ collision[ i ] ] ) {
12252     $.ui.position[ collision[ i ] ][ dir ]( position, {
12253     targetWidth: targetWidth,
12254     targetHeight: targetHeight,
12255     elemWidth: elemWidth,
12256     elemHeight: elemHeight,
12257     collisionPosition: collisionPosition,
12258     collisionWidth: collisionWidth,
12259     collisionHeight: collisionHeight,
12260     offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
12261     my: options.my,
12262     at: options.at,
12263     within: within,
12264     elem : elem
12265     });
12266     }
12267     });
12268    
12269     if ( options.using ) {
12270     // adds feedback as second argument to using callback, if present
12271     using = function( props ) {
12272     var left = targetOffset.left - position.left,
12273     right = left + targetWidth - elemWidth,
12274     top = targetOffset.top - position.top,
12275     bottom = top + targetHeight - elemHeight,
12276     feedback = {
12277     target: {
12278     element: target,
12279     left: targetOffset.left,
12280     top: targetOffset.top,
12281     width: targetWidth,
12282     height: targetHeight
12283     },
12284     element: {
12285     element: elem,
12286     left: position.left,
12287     top: position.top,
12288     width: elemWidth,
12289     height: elemHeight
12290     },
12291     horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
12292     vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
12293     };
12294     if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
12295     feedback.horizontal = "center";
12296     }
12297     if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
12298     feedback.vertical = "middle";
12299     }
12300     if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
12301     feedback.important = "horizontal";
12302     } else {
12303     feedback.important = "vertical";
12304     }
12305     options.using.call( this, props, feedback );
12306     };
12307     }
12308    
12309     elem.offset( $.extend( position, { using: using } ) );
12310     });
12311     };
12312    
12313     $.ui.position = {
12314     fit: {
12315     left: function( position, data ) {
12316     var within = data.within,
12317     withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
12318     outerWidth = within.width,
12319     collisionPosLeft = position.left - data.collisionPosition.marginLeft,
12320     overLeft = withinOffset - collisionPosLeft,
12321     overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
12322     newOverRight;
12323    
12324     // element is wider than within
12325     if ( data.collisionWidth > outerWidth ) {
12326     // element is initially over the left side of within
12327     if ( overLeft > 0 && overRight <= 0 ) {
12328     newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
12329     position.left += overLeft - newOverRight;
12330     // element is initially over right side of within
12331     } else if ( overRight > 0 && overLeft <= 0 ) {
12332     position.left = withinOffset;
12333     // element is initially over both left and right sides of within
12334     } else {
12335     if ( overLeft > overRight ) {
12336     position.left = withinOffset + outerWidth - data.collisionWidth;
12337     } else {
12338     position.left = withinOffset;
12339     }
12340     }
12341     // too far left -> align with left edge
12342     } else if ( overLeft > 0 ) {
12343     position.left += overLeft;
12344     // too far right -> align with right edge
12345     } else if ( overRight > 0 ) {
12346     position.left -= overRight;
12347     // adjust based on position and margin
12348     } else {
12349     position.left = max( position.left - collisionPosLeft, position.left );
12350     }
12351     },
12352     top: function( position, data ) {
12353     var within = data.within,
12354     withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
12355     outerHeight = data.within.height,
12356     collisionPosTop = position.top - data.collisionPosition.marginTop,
12357     overTop = withinOffset - collisionPosTop,
12358     overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
12359     newOverBottom;
12360    
12361     // element is taller than within
12362     if ( data.collisionHeight > outerHeight ) {
12363     // element is initially over the top of within
12364     if ( overTop > 0 && overBottom <= 0 ) {
12365     newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
12366     position.top += overTop - newOverBottom;
12367     // element is initially over bottom of within
12368     } else if ( overBottom > 0 && overTop <= 0 ) {
12369     position.top = withinOffset;
12370     // element is initially over both top and bottom of within
12371     } else {
12372     if ( overTop > overBottom ) {
12373     position.top = withinOffset + outerHeight - data.collisionHeight;
12374     } else {
12375     position.top = withinOffset;
12376     }
12377     }
12378     // too far up -> align with top
12379     } else if ( overTop > 0 ) {
12380     position.top += overTop;
12381     // too far down -> align with bottom edge
12382     } else if ( overBottom > 0 ) {
12383     position.top -= overBottom;
12384     // adjust based on position and margin
12385     } else {
12386     position.top = max( position.top - collisionPosTop, position.top );
12387     }
12388     }
12389     },
12390     flip: {
12391     left: function( position, data ) {
12392     var within = data.within,
12393     withinOffset = within.offset.left + within.scrollLeft,
12394     outerWidth = within.width,
12395     offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
12396     collisionPosLeft = position.left - data.collisionPosition.marginLeft,
12397     overLeft = collisionPosLeft - offsetLeft,
12398     overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
12399     myOffset = data.my[ 0 ] === "left" ?
12400     -data.elemWidth :
12401     data.my[ 0 ] === "right" ?
12402     data.elemWidth :
12403     0,
12404     atOffset = data.at[ 0 ] === "left" ?
12405     data.targetWidth :
12406     data.at[ 0 ] === "right" ?
12407     -data.targetWidth :
12408     0,
12409     offset = -2 * data.offset[ 0 ],
12410     newOverRight,
12411     newOverLeft;
12412    
12413     if ( overLeft < 0 ) {
12414     newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
12415     if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
12416     position.left += myOffset + atOffset + offset;
12417     }
12418     }
12419     else if ( overRight > 0 ) {
12420     newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
12421     if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
12422     position.left += myOffset + atOffset + offset;
12423     }
12424     }
12425     },
12426     top: function( position, data ) {
12427     var within = data.within,
12428     withinOffset = within.offset.top + within.scrollTop,
12429     outerHeight = within.height,
12430     offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
12431     collisionPosTop = position.top - data.collisionPosition.marginTop,
12432     overTop = collisionPosTop - offsetTop,
12433     overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
12434     top = data.my[ 1 ] === "top",
12435     myOffset = top ?
12436     -data.elemHeight :
12437     data.my[ 1 ] === "bottom" ?
12438     data.elemHeight :
12439     0,
12440     atOffset = data.at[ 1 ] === "top" ?
12441     data.targetHeight :
12442     data.at[ 1 ] === "bottom" ?
12443     -data.targetHeight :
12444     0,
12445     offset = -2 * data.offset[ 1 ],
12446     newOverTop,
12447     newOverBottom;
12448     if ( overTop < 0 ) {
12449     newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
12450     if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
12451     position.top += myOffset + atOffset + offset;
12452     }
12453     }
12454     else if ( overBottom > 0 ) {
12455     newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
12456     if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
12457     position.top += myOffset + atOffset + offset;
12458     }
12459     }
12460     }
12461     },
12462     flipfit: {
12463     left: function() {
12464     $.ui.position.flip.left.apply( this, arguments );
12465     $.ui.position.fit.left.apply( this, arguments );
12466     },
12467     top: function() {
12468     $.ui.position.flip.top.apply( this, arguments );
12469     $.ui.position.fit.top.apply( this, arguments );
12470     }
12471     }
12472     };
12473    
12474     // fraction support test
12475     (function () {
12476     var testElement, testElementParent, testElementStyle, offsetLeft, i,
12477     body = document.getElementsByTagName( "body" )[ 0 ],
12478     div = document.createElement( "div" );
12479    
12480     //Create a "fake body" for testing based on method used in jQuery.support
12481     testElement = document.createElement( body ? "div" : "body" );
12482     testElementStyle = {
12483     visibility: "hidden",
12484     width: 0,
12485     height: 0,
12486     border: 0,
12487     margin: 0,
12488     background: "none"
12489     };
12490     if ( body ) {
12491     $.extend( testElementStyle, {
12492     position: "absolute",
12493     left: "-1000px",
12494     top: "-1000px"
12495     });
12496     }
12497     for ( i in testElementStyle ) {
12498     testElement.style[ i ] = testElementStyle[ i ];
12499     }
12500     testElement.appendChild( div );
12501     testElementParent = body || document.documentElement;
12502     testElementParent.insertBefore( testElement, testElementParent.firstChild );
12503    
12504     div.style.cssText = "position: absolute; left: 10.7432222px;";
12505    
12506     offsetLeft = $( div ).offset().left;
12507     $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
12508    
12509     testElement.innerHTML = "";
12510     testElementParent.removeChild( testElement );
12511     })();
12512    
12513     }( jQuery ) );
12514    
12515     (function( $, undefined ) {
12516    
12517     $.widget( "ui.progressbar", {
12518     version: "1.10.3",
12519     options: {
12520     max: 100,
12521     value: 0,
12522    
12523     change: null,
12524     complete: null
12525     },
12526    
12527     min: 0,
12528    
12529     _create: function() {
12530     // Constrain initial value
12531     this.oldValue = this.options.value = this._constrainedValue();
12532    
12533     this.element
12534     .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
12535     .attr({
12536     // Only set static values, aria-valuenow and aria-valuemax are
12537     // set inside _refreshValue()
12538     role: "progressbar",
12539     "aria-valuemin": this.min
12540     });
12541    
12542     this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
12543     .appendTo( this.element );
12544    
12545     this._refreshValue();
12546     },
12547    
12548     _destroy: function() {
12549     this.element
12550     .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
12551     .removeAttr( "role" )
12552     .removeAttr( "aria-valuemin" )
12553     .removeAttr( "aria-valuemax" )
12554     .removeAttr( "aria-valuenow" );
12555    
12556     this.valueDiv.remove();
12557     },
12558    
12559     value: function( newValue ) {
12560     if ( newValue === undefined ) {
12561     return this.options.value;
12562     }
12563    
12564     this.options.value = this._constrainedValue( newValue );
12565     this._refreshValue();
12566     },
12567    
12568     _constrainedValue: function( newValue ) {
12569     if ( newValue === undefined ) {
12570     newValue = this.options.value;
12571     }
12572    
12573     this.indeterminate = newValue === false;
12574    
12575     // sanitize value
12576     if ( typeof newValue !== "number" ) {
12577     newValue = 0;
12578     }
12579    
12580     return this.indeterminate ? false :
12581     Math.min( this.options.max, Math.max( this.min, newValue ) );
12582     },
12583    
12584     _setOptions: function( options ) {
12585     // Ensure "value" option is set after other values (like max)
12586     var value = options.value;
12587     delete options.value;
12588    
12589     this._super( options );
12590    
12591     this.options.value = this._constrainedValue( value );
12592     this._refreshValue();
12593     },
12594    
12595     _setOption: function( key, value ) {
12596     if ( key === "max" ) {
12597     // Don't allow a max less than min
12598     value = Math.max( this.min, value );
12599     }
12600    
12601     this._super( key, value );
12602     },
12603    
12604     _percentage: function() {
12605     return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
12606     },
12607    
12608     _refreshValue: function() {
12609     var value = this.options.value,
12610     percentage = this._percentage();
12611    
12612     this.valueDiv
12613     .toggle( this.indeterminate || value > this.min )
12614     .toggleClass( "ui-corner-right", value === this.options.max )
12615     .width( percentage.toFixed(0) + "%" );
12616    
12617     this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
12618    
12619     if ( this.indeterminate ) {
12620     this.element.removeAttr( "aria-valuenow" );
12621     if ( !this.overlayDiv ) {
12622     this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
12623     }
12624     } else {
12625     this.element.attr({
12626     "aria-valuemax": this.options.max,
12627     "aria-valuenow": value
12628     });
12629     if ( this.overlayDiv ) {
12630     this.overlayDiv.remove();
12631     this.overlayDiv = null;
12632     }
12633     }
12634    
12635     if ( this.oldValue !== value ) {
12636     this.oldValue = value;
12637     this._trigger( "change" );
12638     }
12639     if ( value === this.options.max ) {
12640     this._trigger( "complete" );
12641     }
12642     }
12643     });
12644    
12645     })( jQuery );
12646    
12647     (function( $, undefined ) {
12648    
12649     // number of pages in a slider
12650     // (how many times can you page up/down to go through the whole range)
12651     var numPages = 5;
12652    
12653     $.widget( "ui.slider", $.ui.mouse, {
12654     version: "1.10.3",
12655     widgetEventPrefix: "slide",
12656    
12657     options: {
12658     animate: false,
12659     distance: 0,
12660     max: 100,
12661     min: 0,
12662     orientation: "horizontal",
12663     range: false,
12664     step: 1,
12665     value: 0,
12666     values: null,
12667    
12668     // callbacks
12669     change: null,
12670     slide: null,
12671     start: null,
12672     stop: null
12673     },
12674    
12675     _create: function() {
12676     this._keySliding = false;
12677     this._mouseSliding = false;
12678     this._animateOff = true;
12679     this._handleIndex = null;
12680     this._detectOrientation();
12681     this._mouseInit();
12682    
12683     this.element
12684     .addClass( "ui-slider" +
12685     " ui-slider-" + this.orientation +
12686     " ui-widget" +
12687     " ui-widget-content" +
12688     " ui-corner-all");
12689    
12690     this._refresh();
12691     this._setOption( "disabled", this.options.disabled );
12692    
12693     this._animateOff = false;
12694     },
12695    
12696     _refresh: function() {
12697     this._createRange();
12698     this._createHandles();
12699     this._setupEvents();
12700     this._refreshValue();
12701     },
12702    
12703     _createHandles: function() {
12704     var i, handleCount,
12705     options = this.options,
12706     existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12707     handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
12708     handles = [];
12709    
12710     handleCount = ( options.values && options.values.length ) || 1;
12711    
12712     if ( existingHandles.length > handleCount ) {
12713     existingHandles.slice( handleCount ).remove();
12714     existingHandles = existingHandles.slice( 0, handleCount );
12715     }
12716    
12717     for ( i = existingHandles.length; i < handleCount; i++ ) {
12718     handles.push( handle );
12719     }
12720    
12721     this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
12722    
12723     this.handle = this.handles.eq( 0 );
12724    
12725     this.handles.each(function( i ) {
12726     $( this ).data( "ui-slider-handle-index", i );
12727     });
12728     },
12729    
12730     _createRange: function() {
12731     var options = this.options,
12732     classes = "";
12733    
12734     if ( options.range ) {
12735     if ( options.range === true ) {
12736     if ( !options.values ) {
12737     options.values = [ this._valueMin(), this._valueMin() ];
12738     } else if ( options.values.length && options.values.length !== 2 ) {
12739     options.values = [ options.values[0], options.values[0] ];
12740     } else if ( $.isArray( options.values ) ) {
12741     options.values = options.values.slice(0);
12742     }
12743     }
12744    
12745     if ( !this.range || !this.range.length ) {
12746     this.range = $( "<div></div>" )
12747     .appendTo( this.element );
12748    
12749     classes = "ui-slider-range" +
12750     // note: this isn't the most fittingly semantic framework class for this element,
12751     // but worked best visually with a variety of themes
12752     " ui-widget-header ui-corner-all";
12753     } else {
12754     this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
12755     // Handle range switching from true to min/max
12756     .css({
12757     "left": "",
12758     "bottom": ""
12759     });
12760     }
12761    
12762     this.range.addClass( classes +
12763     ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12764     } else {
12765     this.range = $([]);
12766     }
12767     },
12768    
12769     _setupEvents: function() {
12770     var elements = this.handles.add( this.range ).filter( "a" );
12771     this._off( elements );
12772     this._on( elements, this._handleEvents );
12773     this._hoverable( elements );
12774     this._focusable( elements );
12775     },
12776    
12777     _destroy: function() {
12778     this.handles.remove();
12779     this.range.remove();
12780    
12781     this.element
12782     .removeClass( "ui-slider" +
12783     " ui-slider-horizontal" +
12784     " ui-slider-vertical" +
12785     " ui-widget" +
12786     " ui-widget-content" +
12787     " ui-corner-all" );
12788    
12789     this._mouseDestroy();
12790     },
12791    
12792     _mouseCapture: function( event ) {
12793     var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
12794     that = this,
12795     o = this.options;
12796    
12797     if ( o.disabled ) {
12798     return false;
12799     }
12800    
12801     this.elementSize = {
12802     width: this.element.outerWidth(),
12803     height: this.element.outerHeight()
12804     };
12805     this.elementOffset = this.element.offset();
12806    
12807     position = { x: event.pageX, y: event.pageY };
12808     normValue = this._normValueFromMouse( position );
12809     distance = this._valueMax() - this._valueMin() + 1;
12810     this.handles.each(function( i ) {
12811     var thisDistance = Math.abs( normValue - that.values(i) );
12812     if (( distance > thisDistance ) ||
12813     ( distance === thisDistance &&
12814     (i === that._lastChangedValue || that.values(i) === o.min ))) {
12815     distance = thisDistance;
12816     closestHandle = $( this );
12817     index = i;
12818     }
12819     });
12820    
12821     allowed = this._start( event, index );
12822     if ( allowed === false ) {
12823     return false;
12824     }
12825     this._mouseSliding = true;
12826    
12827     this._handleIndex = index;
12828    
12829     closestHandle
12830     .addClass( "ui-state-active" )
12831     .focus();
12832    
12833     offset = closestHandle.offset();
12834     mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
12835     this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
12836     left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
12837     top: event.pageY - offset.top -
12838     ( closestHandle.height() / 2 ) -
12839     ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
12840     ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
12841     ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
12842     };
12843    
12844     if ( !this.handles.hasClass( "ui-state-hover" ) ) {
12845     this._slide( event, index, normValue );
12846     }
12847     this._animateOff = true;
12848     return true;
12849     },
12850    
12851     _mouseStart: function() {
12852     return true;
12853     },
12854    
12855     _mouseDrag: function( event ) {
12856     var position = { x: event.pageX, y: event.pageY },
12857     normValue = this._normValueFromMouse( position );
12858    
12859     this._slide( event, this._handleIndex, normValue );
12860    
12861     return false;
12862     },
12863    
12864     _mouseStop: function( event ) {
12865     this.handles.removeClass( "ui-state-active" );
12866     this._mouseSliding = false;
12867    
12868     this._stop( event, this._handleIndex );
12869     this._change( event, this._handleIndex );
12870    
12871     this._handleIndex = null;
12872     this._clickOffset = null;
12873     this._animateOff = false;
12874    
12875     return false;
12876     },
12877    
12878     _detectOrientation: function() {
12879     this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
12880     },
12881    
12882     _normValueFromMouse: function( position ) {
12883     var pixelTotal,
12884     pixelMouse,
12885     percentMouse,
12886     valueTotal,
12887     valueMouse;
12888    
12889     if ( this.orientation === "horizontal" ) {
12890     pixelTotal = this.elementSize.width;
12891     pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
12892     } else {
12893     pixelTotal = this.elementSize.height;
12894     pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
12895     }
12896    
12897     percentMouse = ( pixelMouse / pixelTotal );
12898     if ( percentMouse > 1 ) {
12899     percentMouse = 1;
12900     }
12901     if ( percentMouse < 0 ) {
12902     percentMouse = 0;
12903     }
12904     if ( this.orientation === "vertical" ) {
12905     percentMouse = 1 - percentMouse;
12906     }
12907    
12908     valueTotal = this._valueMax() - this._valueMin();
12909     valueMouse = this._valueMin() + percentMouse * valueTotal;
12910    
12911     return this._trimAlignValue( valueMouse );
12912     },
12913    
12914     _start: function( event, index ) {
12915     var uiHash = {
12916     handle: this.handles[ index ],
12917     value: this.value()
12918     };
12919     if ( this.options.values && this.options.values.length ) {
12920     uiHash.value = this.values( index );
12921     uiHash.values = this.values();
12922     }
12923     return this._trigger( "start", event, uiHash );
12924     },
12925    
12926     _slide: function( event, index, newVal ) {
12927     var otherVal,
12928     newValues,
12929     allowed;
12930    
12931     if ( this.options.values && this.options.values.length ) {
12932     otherVal = this.values( index ? 0 : 1 );
12933    
12934     if ( ( this.options.values.length === 2 && this.options.range === true ) &&
12935     ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
12936     ) {
12937     newVal = otherVal;
12938     }
12939    
12940     if ( newVal !== this.values( index ) ) {
12941     newValues = this.values();
12942     newValues[ index ] = newVal;
12943     // A slide can be canceled by returning false from the slide callback
12944     allowed = this._trigger( "slide", event, {
12945     handle: this.handles[ index ],
12946     value: newVal,
12947     values: newValues
12948     } );
12949     otherVal = this.values( index ? 0 : 1 );
12950     if ( allowed !== false ) {
12951     this.values( index, newVal, true );
12952     }
12953     }
12954     } else {
12955     if ( newVal !== this.value() ) {
12956     // A slide can be canceled by returning false from the slide callback
12957     allowed = this._trigger( "slide", event, {
12958     handle: this.handles[ index ],
12959     value: newVal
12960     } );
12961     if ( allowed !== false ) {
12962     this.value( newVal );
12963     }
12964     }
12965     }
12966     },
12967    
12968     _stop: function( event, index ) {
12969     var uiHash = {
12970     handle: this.handles[ index ],
12971     value: this.value()
12972     };
12973     if ( this.options.values && this.options.values.length ) {
12974     uiHash.value = this.values( index );
12975     uiHash.values = this.values();
12976     }
12977    
12978     this._trigger( "stop", event, uiHash );
12979     },
12980    
12981     _change: function( event, index ) {
12982     if ( !this._keySliding && !this._mouseSliding ) {
12983     var uiHash = {
12984     handle: this.handles[ index ],
12985     value: this.value()
12986     };
12987     if ( this.options.values && this.options.values.length ) {
12988     uiHash.value = this.values( index );
12989     uiHash.values = this.values();
12990     }
12991    
12992     //store the last changed value index for reference when handles overlap
12993     this._lastChangedValue = index;
12994    
12995     this._trigger( "change", event, uiHash );
12996     }
12997     },
12998    
12999     value: function( newValue ) {
13000     if ( arguments.length ) {
13001     this.options.value = this._trimAlignValue( newValue );
13002     this._refreshValue();
13003     this._change( null, 0 );
13004     return;
13005     }
13006    
13007     return this._value();
13008     },
13009    
13010     values: function( index, newValue ) {
13011     var vals,
13012     newValues,
13013     i;
13014    
13015     if ( arguments.length > 1 ) {
13016     this.options.values[ index ] = this._trimAlignValue( newValue );
13017     this._refreshValue();
13018     this._change( null, index );
13019     return;
13020     }
13021    
13022     if ( arguments.length ) {
13023     if ( $.isArray( arguments[ 0 ] ) ) {
13024     vals = this.options.values;
13025     newValues = arguments[ 0 ];
13026     for ( i = 0; i < vals.length; i += 1 ) {
13027     vals[ i ] = this._trimAlignValue( newValues[ i ] );
13028     this._change( null, i );
13029     }
13030     this._refreshValue();
13031     } else {
13032     if ( this.options.values && this.options.values.length ) {
13033     return this._values( index );
13034     } else {
13035     return this.value();
13036     }
13037     }
13038     } else {
13039     return this._values();
13040     }
13041     },
13042    
13043     _setOption: function( key, value ) {
13044     var i,
13045     valsLength = 0;
13046    
13047     if ( key === "range" && this.options.range === true ) {
13048     if ( value === "min" ) {
13049     this.options.value = this._values( 0 );
13050     this.options.values = null;
13051     } else if ( value === "max" ) {
13052     this.options.value = this._values( this.options.values.length-1 );
13053     this.options.values = null;
13054     }
13055     }
13056    
13057     if ( $.isArray( this.options.values ) ) {
13058     valsLength = this.options.values.length;
13059     }
13060    
13061     $.Widget.prototype._setOption.apply( this, arguments );
13062    
13063     switch ( key ) {
13064     case "orientation":
13065     this._detectOrientation();
13066     this.element
13067     .removeClass( "ui-slider-horizontal ui-slider-vertical" )
13068     .addClass( "ui-slider-" + this.orientation );
13069     this._refreshValue();
13070     break;
13071     case "value":
13072     this._animateOff = true;
13073     this._refreshValue();
13074     this._change( null, 0 );
13075     this._animateOff = false;
13076     break;
13077     case "values":
13078     this._animateOff = true;
13079     this._refreshValue();
13080     for ( i = 0; i < valsLength; i += 1 ) {
13081     this._change( null, i );
13082     }
13083     this._animateOff = false;
13084     break;
13085     case "min":
13086     case "max":
13087     this._animateOff = true;
13088     this._refreshValue();
13089     this._animateOff = false;
13090     break;
13091     case "range":
13092     this._animateOff = true;
13093     this._refresh();
13094     this._animateOff = false;
13095     break;
13096     }
13097     },
13098    
13099     //internal value getter
13100     // _value() returns value trimmed by min and max, aligned by step
13101     _value: function() {
13102     var val = this.options.value;
13103     val = this._trimAlignValue( val );
13104    
13105     return val;
13106     },
13107    
13108     //internal values getter
13109     // _values() returns array of values trimmed by min and max, aligned by step
13110     // _values( index ) returns single value trimmed by min and max, aligned by step
13111     _values: function( index ) {
13112     var val,
13113     vals,
13114     i;
13115    
13116     if ( arguments.length ) {
13117     val = this.options.values[ index ];
13118     val = this._trimAlignValue( val );
13119    
13120     return val;
13121     } else if ( this.options.values && this.options.values.length ) {
13122     // .slice() creates a copy of the array
13123     // this copy gets trimmed by min and max and then returned
13124     vals = this.options.values.slice();
13125     for ( i = 0; i < vals.length; i+= 1) {
13126     vals[ i ] = this._trimAlignValue( vals[ i ] );
13127     }
13128    
13129     return vals;
13130     } else {
13131     return [];
13132     }
13133     },
13134    
13135     // returns the step-aligned value that val is closest to, between (inclusive) min and max
13136     _trimAlignValue: function( val ) {
13137     if ( val <= this._valueMin() ) {
13138     return this._valueMin();
13139     }
13140     if ( val >= this._valueMax() ) {
13141     return this._valueMax();
13142     }
13143     var step = ( this.options.step > 0 ) ? this.options.step : 1,
13144     valModStep = (val - this._valueMin()) % step,
13145     alignValue = val - valModStep;
13146    
13147     if ( Math.abs(valModStep) * 2 >= step ) {
13148     alignValue += ( valModStep > 0 ) ? step : ( -step );
13149     }
13150    
13151     // Since JavaScript has problems with large floats, round
13152     // the final value to 5 digits after the decimal point (see #4124)
13153     return parseFloat( alignValue.toFixed(5) );
13154     },
13155    
13156     _valueMin: function() {
13157     return this.options.min;
13158     },
13159    
13160     _valueMax: function() {
13161     return this.options.max;
13162     },
13163    
13164     _refreshValue: function() {
13165     var lastValPercent, valPercent, value, valueMin, valueMax,
13166     oRange = this.options.range,
13167     o = this.options,
13168     that = this,
13169     animate = ( !this._animateOff ) ? o.animate : false,
13170     _set = {};
13171    
13172     if ( this.options.values && this.options.values.length ) {
13173     this.handles.each(function( i ) {
13174     valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13175     _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13176     $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13177     if ( that.options.range === true ) {
13178     if ( that.orientation === "horizontal" ) {
13179     if ( i === 0 ) {
13180     that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13181     }
13182     if ( i === 1 ) {
13183     that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13184     }
13185     } else {
13186     if ( i === 0 ) {
13187     that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13188     }
13189     if ( i === 1 ) {
13190     that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13191     }
13192     }
13193     }
13194     lastValPercent = valPercent;
13195     });
13196     } else {
13197     value = this.value();
13198     valueMin = this._valueMin();
13199     valueMax = this._valueMax();
13200     valPercent = ( valueMax !== valueMin ) ?
13201     ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
13202     0;
13203     _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13204     this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13205    
13206     if ( oRange === "min" && this.orientation === "horizontal" ) {
13207     this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13208     }
13209     if ( oRange === "max" && this.orientation === "horizontal" ) {
13210     this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13211     }
13212     if ( oRange === "min" && this.orientation === "vertical" ) {
13213     this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13214     }
13215     if ( oRange === "max" && this.orientation === "vertical" ) {
13216     this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13217     }
13218     }
13219     },
13220    
13221     _handleEvents: {
13222     keydown: function( event ) {
13223     /*jshint maxcomplexity:25*/
13224     var allowed, curVal, newVal, step,
13225     index = $( event.target ).data( "ui-slider-handle-index" );
13226    
13227     switch ( event.keyCode ) {
13228     case $.ui.keyCode.HOME:
13229     case $.ui.keyCode.END:
13230     case $.ui.keyCode.PAGE_UP:
13231     case $.ui.keyCode.PAGE_DOWN:
13232     case $.ui.keyCode.UP:
13233     case $.ui.keyCode.RIGHT:
13234     case $.ui.keyCode.DOWN:
13235     case $.ui.keyCode.LEFT:
13236     event.preventDefault();
13237     if ( !this._keySliding ) {
13238     this._keySliding = true;
13239     $( event.target ).addClass( "ui-state-active" );
13240     allowed = this._start( event, index );
13241     if ( allowed === false ) {
13242     return;
13243     }
13244     }
13245     break;
13246     }
13247    
13248     step = this.options.step;
13249     if ( this.options.values && this.options.values.length ) {
13250     curVal = newVal = this.values( index );
13251     } else {
13252     curVal = newVal = this.value();
13253     }
13254    
13255     switch ( event.keyCode ) {
13256     case $.ui.keyCode.HOME:
13257     newVal = this._valueMin();
13258     break;
13259     case $.ui.keyCode.END:
13260     newVal = this._valueMax();
13261     break;
13262     case $.ui.keyCode.PAGE_UP:
13263     newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
13264     break;
13265     case $.ui.keyCode.PAGE_DOWN:
13266     newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
13267     break;
13268     case $.ui.keyCode.UP:
13269     case $.ui.keyCode.RIGHT:
13270     if ( curVal === this._valueMax() ) {
13271     return;
13272     }
13273     newVal = this._trimAlignValue( curVal + step );
13274     break;
13275     case $.ui.keyCode.DOWN:
13276     case $.ui.keyCode.LEFT:
13277     if ( curVal === this._valueMin() ) {
13278     return;
13279     }
13280     newVal = this._trimAlignValue( curVal - step );
13281     break;
13282     }
13283    
13284     this._slide( event, index, newVal );
13285     },
13286     click: function( event ) {
13287     event.preventDefault();
13288     },
13289     keyup: function( event ) {
13290     var index = $( event.target ).data( "ui-slider-handle-index" );
13291    
13292     if ( this._keySliding ) {
13293     this._keySliding = false;
13294     this._stop( event, index );
13295     this._change( event, index );
13296     $( event.target ).removeClass( "ui-state-active" );
13297     }
13298     }
13299     }
13300    
13301     });
13302    
13303     }(jQuery));
13304    
13305     (function( $ ) {
13306    
13307     function modifier( fn ) {
13308     return function() {
13309     var previous = this.element.val();
13310     fn.apply( this, arguments );
13311     this._refresh();
13312     if ( previous !== this.element.val() ) {
13313     this._trigger( "change" );
13314     }
13315     };
13316     }
13317    
13318     $.widget( "ui.spinner", {
13319     version: "1.10.3",
13320     defaultElement: "<input>",
13321     widgetEventPrefix: "spin",
13322     options: {
13323     culture: null,
13324     icons: {
13325     down: "ui-icon-triangle-1-s",
13326     up: "ui-icon-triangle-1-n"
13327     },
13328     incremental: true,
13329     max: null,
13330     min: null,
13331     numberFormat: null,
13332     page: 10,
13333     step: 1,
13334    
13335     change: null,
13336     spin: null,
13337     start: null,
13338     stop: null
13339     },
13340    
13341     _create: function() {
13342     // handle string values that need to be parsed
13343     this._setOption( "max", this.options.max );
13344     this._setOption( "min", this.options.min );
13345     this._setOption( "step", this.options.step );
13346    
13347     // format the value, but don't constrain
13348     this._value( this.element.val(), true );
13349    
13350     this._draw();
13351     this._on( this._events );
13352     this._refresh();
13353    
13354     // turning off autocomplete prevents the browser from remembering the
13355     // value when navigating through history, so we re-enable autocomplete
13356     // if the page is unloaded before the widget is destroyed. #7790
13357     this._on( this.window, {
13358     beforeunload: function() {
13359     this.element.removeAttr( "autocomplete" );
13360     }
13361     });
13362     },
13363    
13364     _getCreateOptions: function() {
13365     var options = {},
13366     element = this.element;
13367    
13368     $.each( [ "min", "max", "step" ], function( i, option ) {
13369     var value = element.attr( option );
13370     if ( value !== undefined && value.length ) {
13371     options[ option ] = value;
13372     }
13373     });
13374    
13375     return options;
13376     },
13377    
13378     _events: {
13379     keydown: function( event ) {
13380     if ( this._start( event ) && this._keydown( event ) ) {
13381     event.preventDefault();
13382     }
13383     },
13384     keyup: "_stop",
13385     focus: function() {
13386     this.previous = this.element.val();
13387     },
13388     blur: function( event ) {
13389     if ( this.cancelBlur ) {
13390     delete this.cancelBlur;
13391     return;
13392     }
13393    
13394     this._stop();
13395     this._refresh();
13396     if ( this.previous !== this.element.val() ) {
13397     this._trigger( "change", event );
13398     }
13399     },
13400     mousewheel: function( event, delta ) {
13401     if ( !delta ) {
13402     return;
13403     }
13404     if ( !this.spinning && !this._start( event ) ) {
13405     return false;
13406     }
13407    
13408     this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
13409     clearTimeout( this.mousewheelTimer );
13410     this.mousewheelTimer = this._delay(function() {
13411     if ( this.spinning ) {
13412     this._stop( event );
13413     }
13414     }, 100 );
13415     event.preventDefault();
13416     },
13417     "mousedown .ui-spinner-button": function( event ) {
13418     var previous;
13419    
13420     // We never want the buttons to have focus; whenever the user is
13421     // interacting with the spinner, the focus should be on the input.
13422     // If the input is focused then this.previous is properly set from
13423     // when the input first received focus. If the input is not focused
13424     // then we need to set this.previous based on the value before spinning.
13425     previous = this.element[0] === this.document[0].activeElement ?
13426     this.previous : this.element.val();
13427     function checkFocus() {
13428     var isActive = this.element[0] === this.document[0].activeElement;
13429     if ( !isActive ) {
13430     this.element.focus();
13431     this.previous = previous;
13432     // support: IE
13433     // IE sets focus asynchronously, so we need to check if focus
13434     // moved off of the input because the user clicked on the button.
13435     this._delay(function() {
13436     this.previous = previous;
13437     });
13438     }
13439     }
13440    
13441     // ensure focus is on (or stays on) the text field
13442     event.preventDefault();
13443     checkFocus.call( this );
13444    
13445     // support: IE
13446     // IE doesn't prevent moving focus even with event.preventDefault()
13447     // so we set a flag to know when we should ignore the blur event
13448     // and check (again) if focus moved off of the input.
13449     this.cancelBlur = true;
13450     this._delay(function() {
13451     delete this.cancelBlur;
13452     checkFocus.call( this );
13453     });
13454    
13455     if ( this._start( event ) === false ) {
13456     return;
13457     }
13458    
13459     this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
13460     },
13461     "mouseup .ui-spinner-button": "_stop",
13462     "mouseenter .ui-spinner-button": function( event ) {
13463     // button will add ui-state-active if mouse was down while mouseleave and kept down
13464     if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
13465     return;
13466     }
13467    
13468     if ( this._start( event ) === false ) {
13469     return false;
13470     }
13471     this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
13472     },
13473     // TODO: do we really want to consider this a stop?
13474     // shouldn't we just stop the repeater and wait until mouseup before
13475     // we trigger the stop event?
13476     "mouseleave .ui-spinner-button": "_stop"
13477     },
13478    
13479     _draw: function() {
13480     var uiSpinner = this.uiSpinner = this.element
13481     .addClass( "ui-spinner-input" )
13482     .attr( "autocomplete", "off" )
13483     .wrap( this._uiSpinnerHtml() )
13484     .parent()
13485     // add buttons
13486     .append( this._buttonHtml() );
13487    
13488     this.element.attr( "role", "spinbutton" );
13489    
13490     // button bindings
13491     this.buttons = uiSpinner.find( ".ui-spinner-button" )
13492     .attr( "tabIndex", -1 )
13493     .button()
13494     .removeClass( "ui-corner-all" );
13495    
13496     // IE 6 doesn't understand height: 50% for the buttons
13497     // unless the wrapper has an explicit height
13498     if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
13499     uiSpinner.height() > 0 ) {
13500     uiSpinner.height( uiSpinner.height() );
13501     }
13502    
13503     // disable spinner if element was already disabled
13504     if ( this.options.disabled ) {
13505     this.disable();
13506     }
13507     },
13508    
13509     _keydown: function( event ) {
13510     var options = this.options,
13511     keyCode = $.ui.keyCode;
13512    
13513     switch ( event.keyCode ) {
13514     case keyCode.UP:
13515     this._repeat( null, 1, event );
13516     return true;
13517     case keyCode.DOWN:
13518     this._repeat( null, -1, event );
13519     return true;
13520     case keyCode.PAGE_UP:
13521     this._repeat( null, options.page, event );
13522     return true;
13523     case keyCode.PAGE_DOWN:
13524     this._repeat( null, -options.page, event );
13525     return true;
13526     }
13527    
13528     return false;
13529     },
13530    
13531     _uiSpinnerHtml: function() {
13532     return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
13533     },
13534    
13535     _buttonHtml: function() {
13536     return "" +
13537     "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
13538     "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
13539     "</a>" +
13540     "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
13541     "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
13542     "</a>";
13543     },
13544    
13545     _start: function( event ) {
13546     if ( !this.spinning && this._trigger( "start", event ) === false ) {
13547     return false;
13548     }
13549    
13550     if ( !this.counter ) {
13551     this.counter = 1;
13552     }
13553     this.spinning = true;
13554     return true;
13555     },
13556    
13557     _repeat: function( i, steps, event ) {
13558     i = i || 500;
13559    
13560     clearTimeout( this.timer );
13561     this.timer = this._delay(function() {
13562     this._repeat( 40, steps, event );
13563     }, i );
13564    
13565     this._spin( steps * this.options.step, event );
13566     },
13567    
13568     _spin: function( step, event ) {
13569     var value = this.value() || 0;
13570    
13571     if ( !this.counter ) {
13572     this.counter = 1;
13573     }
13574    
13575     value = this._adjustValue( value + step * this._increment( this.counter ) );
13576    
13577     if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
13578     this._value( value );
13579     this.counter++;
13580     }
13581     },
13582    
13583     _increment: function( i ) {
13584     var incremental = this.options.incremental;
13585    
13586     if ( incremental ) {
13587     return $.isFunction( incremental ) ?
13588     incremental( i ) :
13589     Math.floor( i*i*i/50000 - i*i/500 + 17*i/200 + 1 );
13590     }
13591    
13592     return 1;
13593     },
13594    
13595     _precision: function() {
13596     var precision = this._precisionOf( this.options.step );
13597     if ( this.options.min !== null ) {
13598     precision = Math.max( precision, this._precisionOf( this.options.min ) );
13599     }
13600     return precision;
13601     },
13602    
13603     _precisionOf: function( num ) {
13604     var str = num.toString(),
13605     decimal = str.indexOf( "." );
13606     return decimal === -1 ? 0 : str.length - decimal - 1;
13607     },
13608    
13609     _adjustValue: function( value ) {
13610     var base, aboveMin,
13611     options = this.options;
13612    
13613     // make sure we're at a valid step
13614     // - find out where we are relative to the base (min or 0)
13615     base = options.min !== null ? options.min : 0;
13616     aboveMin = value - base;
13617     // - round to the nearest step
13618     aboveMin = Math.round(aboveMin / options.step) * options.step;
13619     // - rounding is based on 0, so adjust back to our base
13620     value = base + aboveMin;
13621    
13622     // fix precision from bad JS floating point math
13623     value = parseFloat( value.toFixed( this._precision() ) );
13624    
13625     // clamp the value
13626     if ( options.max !== null && value > options.max) {
13627     return options.max;
13628     }
13629     if ( options.min !== null && value < options.min ) {
13630     return options.min;
13631     }
13632    
13633     return value;
13634     },
13635    
13636     _stop: function( event ) {
13637     if ( !this.spinning ) {
13638     return;
13639     }
13640    
13641     clearTimeout( this.timer );
13642     clearTimeout( this.mousewheelTimer );
13643     this.counter = 0;
13644     this.spinning = false;
13645     this._trigger( "stop", event );
13646     },
13647    
13648     _setOption: function( key, value ) {
13649     if ( key === "culture" || key === "numberFormat" ) {
13650     var prevValue = this._parse( this.element.val() );
13651     this.options[ key ] = value;
13652     this.element.val( this._format( prevValue ) );
13653     return;
13654     }
13655    
13656     if ( key === "max" || key === "min" || key === "step" ) {
13657     if ( typeof value === "string" ) {
13658     value = this._parse( value );
13659     }
13660     }
13661     if ( key === "icons" ) {
13662     this.buttons.first().find( ".ui-icon" )
13663     .removeClass( this.options.icons.up )
13664     .addClass( value.up );
13665     this.buttons.last().find( ".ui-icon" )
13666     .removeClass( this.options.icons.down )
13667     .addClass( value.down );
13668     }
13669    
13670     this._super( key, value );
13671    
13672     if ( key === "disabled" ) {
13673     if ( value ) {
13674     this.element.prop( "disabled", true );
13675     this.buttons.button( "disable" );
13676     } else {
13677     this.element.prop( "disabled", false );
13678     this.buttons.button( "enable" );
13679     }
13680     }
13681     },
13682    
13683     _setOptions: modifier(function( options ) {
13684     this._super( options );
13685     this._value( this.element.val() );
13686     }),
13687    
13688     _parse: function( val ) {
13689     if ( typeof val === "string" && val !== "" ) {
13690     val = window.Globalize && this.options.numberFormat ?
13691     Globalize.parseFloat( val, 10, this.options.culture ) : +val;
13692     }
13693     return val === "" || isNaN( val ) ? null : val;
13694     },
13695    
13696     _format: function( value ) {
13697     if ( value === "" ) {
13698     return "";
13699     }
13700     return window.Globalize && this.options.numberFormat ?
13701     Globalize.format( value, this.options.numberFormat, this.options.culture ) :
13702     value;
13703     },
13704    
13705     _refresh: function() {
13706     this.element.attr({
13707     "aria-valuemin": this.options.min,
13708     "aria-valuemax": this.options.max,
13709     // TODO: what should we do with values that can't be parsed?
13710     "aria-valuenow": this._parse( this.element.val() )
13711     });
13712     },
13713    
13714     // update the value without triggering change
13715     _value: function( value, allowAny ) {
13716     var parsed;
13717     if ( value !== "" ) {
13718     parsed = this._parse( value );
13719     if ( parsed !== null ) {
13720     if ( !allowAny ) {
13721     parsed = this._adjustValue( parsed );
13722     }
13723     value = this._format( parsed );
13724     }
13725     }
13726     this.element.val( value );
13727     this._refresh();
13728     },
13729    
13730     _destroy: function() {
13731     this.element
13732     .removeClass( "ui-spinner-input" )
13733     .prop( "disabled", false )
13734     .removeAttr( "autocomplete" )
13735     .removeAttr( "role" )
13736     .removeAttr( "aria-valuemin" )
13737     .removeAttr( "aria-valuemax" )
13738     .removeAttr( "aria-valuenow" );
13739     this.uiSpinner.replaceWith( this.element );
13740     },
13741    
13742     stepUp: modifier(function( steps ) {
13743     this._stepUp( steps );
13744     }),
13745     _stepUp: function( steps ) {
13746     if ( this._start() ) {
13747     this._spin( (steps || 1) * this.options.step );
13748     this._stop();
13749     }
13750     },
13751    
13752     stepDown: modifier(function( steps ) {
13753     this._stepDown( steps );
13754     }),
13755     _stepDown: function( steps ) {
13756     if ( this._start() ) {
13757     this._spin( (steps || 1) * -this.options.step );
13758     this._stop();
13759     }
13760     },
13761    
13762     pageUp: modifier(function( pages ) {
13763     this._stepUp( (pages || 1) * this.options.page );
13764     }),
13765    
13766     pageDown: modifier(function( pages ) {
13767     this._stepDown( (pages || 1) * this.options.page );
13768     }),
13769    
13770     value: function( newVal ) {
13771     if ( !arguments.length ) {
13772     return this._parse( this.element.val() );
13773     }
13774     modifier( this._value ).call( this, newVal );
13775     },
13776    
13777     widget: function() {
13778     return this.uiSpinner;
13779     }
13780     });
13781    
13782     }( jQuery ) );
13783    
13784     (function( $, undefined ) {
13785    
13786     var tabId = 0,
13787     rhash = /#.*$/;
13788    
13789     function getNextTabId() {
13790     return ++tabId;
13791     }
13792    
13793     function isLocal( anchor ) {
13794     return anchor.hash.length > 1 &&
13795     decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
13796     decodeURIComponent( location.href.replace( rhash, "" ) );
13797     }
13798    
13799     $.widget( "ui.tabs", {
13800     version: "1.10.3",
13801     delay: 300,
13802     options: {
13803     active: null,
13804     collapsible: false,
13805     event: "click",
13806     heightStyle: "content",
13807     hide: null,
13808     show: null,
13809    
13810     // callbacks
13811     activate: null,
13812     beforeActivate: null,
13813     beforeLoad: null,
13814     load: null
13815     },
13816    
13817     _create: function() {
13818     var that = this,
13819     options = this.options;
13820    
13821     this.running = false;
13822    
13823     this.element
13824     .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
13825     .toggleClass( "ui-tabs-collapsible", options.collapsible )
13826     // Prevent users from focusing disabled tabs via click
13827     .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
13828     if ( $( this ).is( ".ui-state-disabled" ) ) {
13829     event.preventDefault();
13830     }
13831     })
13832     // support: IE <9
13833     // Preventing the default action in mousedown doesn't prevent IE
13834     // from focusing the element, so if the anchor gets focused, blur.
13835     // We don't have to worry about focusing the previously focused
13836     // element since clicking on a non-focusable element should focus
13837     // the body anyway.
13838     .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
13839     if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
13840     this.blur();
13841     }
13842     });
13843    
13844     this._processTabs();
13845     options.active = this._initialActive();
13846    
13847     // Take disabling tabs via class attribute from HTML
13848     // into account and update option properly.
13849     if ( $.isArray( options.disabled ) ) {
13850     options.disabled = $.unique( options.disabled.concat(
13851     $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
13852     return that.tabs.index( li );
13853     })
13854     ) ).sort();
13855     }
13856    
13857     // check for length avoids error when initializing empty list
13858     if ( this.options.active !== false && this.anchors.length ) {
13859     this.active = this._findActive( options.active );
13860     } else {
13861     this.active = $();
13862     }
13863    
13864     this._refresh();
13865    
13866     if ( this.active.length ) {
13867     this.load( options.active );
13868     }
13869     },
13870    
13871     _initialActive: function() {
13872     var active = this.options.active,
13873     collapsible = this.options.collapsible,
13874     locationHash = location.hash.substring( 1 );
13875    
13876     if ( active === null ) {
13877     // check the fragment identifier in the URL
13878     if ( locationHash ) {
13879     this.tabs.each(function( i, tab ) {
13880     if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
13881     active = i;
13882     return false;
13883     }
13884     });
13885     }
13886    
13887     // check for a tab marked active via a class
13888     if ( active === null ) {
13889     active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
13890     }
13891    
13892     // no active tab, set to false
13893     if ( active === null || active === -1 ) {
13894     active = this.tabs.length ? 0 : false;
13895     }
13896     }
13897    
13898     // handle numbers: negative, out of range
13899     if ( active !== false ) {
13900     active = this.tabs.index( this.tabs.eq( active ) );
13901     if ( active === -1 ) {
13902     active = collapsible ? false : 0;
13903     }
13904     }
13905    
13906     // don't allow collapsible: false and active: false
13907     if ( !collapsible && active === false && this.anchors.length ) {
13908     active = 0;
13909     }
13910    
13911     return active;
13912     },
13913    
13914     _getCreateEventData: function() {
13915     return {
13916     tab: this.active,
13917     panel: !this.active.length ? $() : this._getPanelForTab( this.active )
13918     };
13919     },
13920    
13921     _tabKeydown: function( event ) {
13922     /*jshint maxcomplexity:15*/
13923     var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
13924     selectedIndex = this.tabs.index( focusedTab ),
13925     goingForward = true;
13926    
13927     if ( this._handlePageNav( event ) ) {
13928     return;
13929     }
13930    
13931     switch ( event.keyCode ) {
13932     case $.ui.keyCode.RIGHT:
13933     case $.ui.keyCode.DOWN:
13934     selectedIndex++;
13935     break;
13936     case $.ui.keyCode.UP:
13937     case $.ui.keyCode.LEFT:
13938     goingForward = false;
13939     selectedIndex--;
13940     break;
13941     case $.ui.keyCode.END:
13942     selectedIndex = this.anchors.length - 1;
13943     break;
13944     case $.ui.keyCode.HOME:
13945     selectedIndex = 0;
13946     break;
13947     case $.ui.keyCode.SPACE:
13948     // Activate only, no collapsing
13949     event.preventDefault();
13950     clearTimeout( this.activating );
13951     this._activate( selectedIndex );
13952     return;
13953     case $.ui.keyCode.ENTER:
13954     // Toggle (cancel delayed activation, allow collapsing)
13955     event.preventDefault();
13956     clearTimeout( this.activating );
13957     // Determine if we should collapse or activate
13958     this._activate( selectedIndex === this.options.active ? false : selectedIndex );
13959     return;
13960     default:
13961     return;
13962     }
13963    
13964     // Focus the appropriate tab, based on which key was pressed
13965     event.preventDefault();
13966     clearTimeout( this.activating );
13967     selectedIndex = this._focusNextTab( selectedIndex, goingForward );
13968    
13969     // Navigating with control key will prevent automatic activation
13970     if ( !event.ctrlKey ) {
13971     // Update aria-selected immediately so that AT think the tab is already selected.
13972     // Otherwise AT may confuse the user by stating that they need to activate the tab,
13973     // but the tab will already be activated by the time the announcement finishes.
13974     focusedTab.attr( "aria-selected", "false" );
13975     this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
13976    
13977     this.activating = this._delay(function() {
13978     this.option( "active", selectedIndex );
13979     }, this.delay );
13980     }
13981     },
13982    
13983     _panelKeydown: function( event ) {
13984     if ( this._handlePageNav( event ) ) {
13985     return;
13986     }
13987    
13988     // Ctrl+up moves focus to the current tab
13989     if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
13990     event.preventDefault();
13991     this.active.focus();
13992     }
13993     },
13994    
13995     // Alt+page up/down moves focus to the previous/next tab (and activates)
13996     _handlePageNav: function( event ) {
13997     if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
13998     this._activate( this._focusNextTab( this.options.active - 1, false ) );
13999     return true;
14000     }
14001     if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
14002     this._activate( this._focusNextTab( this.options.active + 1, true ) );
14003     return true;
14004     }
14005     },
14006    
14007     _findNextTab: function( index, goingForward ) {
14008     var lastTabIndex = this.tabs.length - 1;
14009    
14010     function constrain() {
14011     if ( index > lastTabIndex ) {
14012     index = 0;
14013     }
14014     if ( index < 0 ) {
14015     index = lastTabIndex;
14016     }
14017     return index;
14018     }
14019    
14020     while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
14021     index = goingForward ? index + 1 : index - 1;
14022     }
14023    
14024     return index;
14025     },
14026    
14027     _focusNextTab: function( index, goingForward ) {
14028     index = this._findNextTab( index, goingForward );
14029     this.tabs.eq( index ).focus();
14030     return index;
14031     },
14032    
14033     _setOption: function( key, value ) {
14034     if ( key === "active" ) {
14035     // _activate() will handle invalid values and update this.options
14036     this._activate( value );
14037     return;
14038     }
14039    
14040     if ( key === "disabled" ) {
14041     // don't use the widget factory's disabled handling
14042     this._setupDisabled( value );
14043     return;
14044     }
14045    
14046     this._super( key, value);
14047    
14048     if ( key === "collapsible" ) {
14049     this.element.toggleClass( "ui-tabs-collapsible", value );
14050     // Setting collapsible: false while collapsed; open first panel
14051     if ( !value && this.options.active === false ) {
14052     this._activate( 0 );
14053     }
14054     }
14055    
14056     if ( key === "event" ) {
14057     this._setupEvents( value );
14058     }
14059    
14060     if ( key === "heightStyle" ) {
14061     this._setupHeightStyle( value );
14062     }
14063     },
14064    
14065     _tabId: function( tab ) {
14066     return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
14067     },
14068    
14069     _sanitizeSelector: function( hash ) {
14070     return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
14071     },
14072    
14073     refresh: function() {
14074     var options = this.options,
14075     lis = this.tablist.children( ":has(a[href])" );
14076    
14077     // get disabled tabs from class attribute from HTML
14078     // this will get converted to a boolean if needed in _refresh()
14079     options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
14080     return lis.index( tab );
14081     });
14082    
14083     this._processTabs();
14084    
14085     // was collapsed or no tabs
14086     if ( options.active === false || !this.anchors.length ) {
14087     options.active = false;
14088     this.active = $();
14089     // was active, but active tab is gone
14090     } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
14091     // all remaining tabs are disabled
14092     if ( this.tabs.length === options.disabled.length ) {
14093     options.active = false;
14094     this.active = $();
14095     // activate previous tab
14096     } else {
14097     this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
14098     }
14099     // was active, active tab still exists
14100     } else {
14101     // make sure active index is correct
14102     options.active = this.tabs.index( this.active );
14103     }
14104    
14105     this._refresh();
14106     },
14107    
14108     _refresh: function() {
14109     this._setupDisabled( this.options.disabled );
14110     this._setupEvents( this.options.event );
14111     this._setupHeightStyle( this.options.heightStyle );
14112    
14113     this.tabs.not( this.active ).attr({
14114     "aria-selected": "false",
14115     tabIndex: -1
14116     });
14117     this.panels.not( this._getPanelForTab( this.active ) )
14118     .hide()
14119     .attr({
14120     "aria-expanded": "false",
14121     "aria-hidden": "true"
14122     });
14123    
14124     // Make sure one tab is in the tab order
14125     if ( !this.active.length ) {
14126     this.tabs.eq( 0 ).attr( "tabIndex", 0 );
14127     } else {
14128     this.active
14129     .addClass( "ui-tabs-active ui-state-active" )
14130     .attr({
14131     "aria-selected": "true",
14132     tabIndex: 0
14133     });
14134     this._getPanelForTab( this.active )
14135     .show()
14136     .attr({
14137     "aria-expanded": "true",
14138     "aria-hidden": "false"
14139     });
14140     }
14141     },
14142    
14143     _processTabs: function() {
14144     var that = this;
14145    
14146     this.tablist = this._getList()
14147     .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14148     .attr( "role", "tablist" );
14149    
14150     this.tabs = this.tablist.find( "> li:has(a[href])" )
14151     .addClass( "ui-state-default ui-corner-top" )
14152     .attr({
14153     role: "tab",
14154     tabIndex: -1
14155     });
14156    
14157     this.anchors = this.tabs.map(function() {
14158     return $( "a", this )[ 0 ];
14159     })
14160     .addClass( "ui-tabs-anchor" )
14161     .attr({
14162     role: "presentation",
14163     tabIndex: -1
14164     });
14165    
14166     this.panels = $();
14167    
14168     this.anchors.each(function( i, anchor ) {
14169     var selector, panel, panelId,
14170     anchorId = $( anchor ).uniqueId().attr( "id" ),
14171     tab = $( anchor ).closest( "li" ),
14172     originalAriaControls = tab.attr( "aria-controls" );
14173    
14174     // inline tab
14175     if ( isLocal( anchor ) ) {
14176     selector = anchor.hash;
14177     panel = that.element.find( that._sanitizeSelector( selector ) );
14178     // remote tab
14179     } else {
14180     panelId = that._tabId( tab );
14181     selector = "#" + panelId;
14182     panel = that.element.find( selector );
14183     if ( !panel.length ) {
14184     panel = that._createPanel( panelId );
14185     panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
14186     }
14187     panel.attr( "aria-live", "polite" );
14188     }
14189    
14190     if ( panel.length) {
14191     that.panels = that.panels.add( panel );
14192     }
14193     if ( originalAriaControls ) {
14194     tab.data( "ui-tabs-aria-controls", originalAriaControls );
14195     }
14196     tab.attr({
14197     "aria-controls": selector.substring( 1 ),
14198     "aria-labelledby": anchorId
14199     });
14200     panel.attr( "aria-labelledby", anchorId );
14201     });
14202    
14203     this.panels
14204     .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
14205     .attr( "role", "tabpanel" );
14206     },
14207    
14208     // allow overriding how to find the list for rare usage scenarios (#7715)
14209     _getList: function() {
14210     return this.element.find( "ol,ul" ).eq( 0 );
14211     },
14212    
14213     _createPanel: function( id ) {
14214     return $( "<div>" )
14215     .attr( "id", id )
14216     .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
14217     .data( "ui-tabs-destroy", true );
14218     },
14219    
14220     _setupDisabled: function( disabled ) {
14221     if ( $.isArray( disabled ) ) {
14222     if ( !disabled.length ) {
14223     disabled = false;
14224     } else if ( disabled.length === this.anchors.length ) {
14225     disabled = true;
14226     }
14227     }
14228    
14229     // disable tabs
14230     for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
14231     if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
14232     $( li )
14233     .addClass( "ui-state-disabled" )
14234     .attr( "aria-disabled", "true" );
14235     } else {
14236     $( li )
14237     .removeClass( "ui-state-disabled" )
14238     .removeAttr( "aria-disabled" );
14239     }
14240     }
14241    
14242     this.options.disabled = disabled;
14243     },
14244    
14245     _setupEvents: function( event ) {
14246     var events = {
14247     click: function( event ) {
14248     event.preventDefault();
14249     }
14250     };
14251     if ( event ) {
14252     $.each( event.split(" "), function( index, eventName ) {
14253     events[ eventName ] = "_eventHandler";
14254     });
14255     }
14256    
14257     this._off( this.anchors.add( this.tabs ).add( this.panels ) );
14258     this._on( this.anchors, events );
14259     this._on( this.tabs, { keydown: "_tabKeydown" } );
14260     this._on( this.panels, { keydown: "_panelKeydown" } );
14261    
14262     this._focusable( this.tabs );
14263     this._hoverable( this.tabs );
14264     },
14265    
14266     _setupHeightStyle: function( heightStyle ) {
14267     var maxHeight,
14268     parent = this.element.parent();
14269    
14270     if ( heightStyle === "fill" ) {
14271     maxHeight = parent.height();
14272     maxHeight -= this.element.outerHeight() - this.element.height();
14273    
14274     this.element.siblings( ":visible" ).each(function() {
14275     var elem = $( this ),
14276     position = elem.css( "position" );
14277    
14278     if ( position === "absolute" || position === "fixed" ) {
14279     return;
14280     }
14281     maxHeight -= elem.outerHeight( true );
14282     });
14283    
14284     this.element.children().not( this.panels ).each(function() {
14285     maxHeight -= $( this ).outerHeight( true );
14286     });
14287    
14288     this.panels.each(function() {
14289     $( this ).height( Math.max( 0, maxHeight -
14290     $( this ).innerHeight() + $( this ).height() ) );
14291     })
14292     .css( "overflow", "auto" );
14293     } else if ( heightStyle === "auto" ) {
14294     maxHeight = 0;
14295     this.panels.each(function() {
14296     maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
14297     }).height( maxHeight );
14298     }
14299     },
14300    
14301     _eventHandler: function( event ) {
14302     var options = this.options,
14303     active = this.active,
14304     anchor = $( event.currentTarget ),
14305     tab = anchor.closest( "li" ),
14306     clickedIsActive = tab[ 0 ] === active[ 0 ],
14307     collapsing = clickedIsActive && options.collapsible,
14308     toShow = collapsing ? $() : this._getPanelForTab( tab ),
14309     toHide = !active.length ? $() : this._getPanelForTab( active ),
14310     eventData = {
14311     oldTab: active,
14312     oldPanel: toHide,
14313     newTab: collapsing ? $() : tab,
14314     newPanel: toShow
14315     };
14316    
14317     event.preventDefault();
14318    
14319     if ( tab.hasClass( "ui-state-disabled" ) ||
14320     // tab is already loading
14321     tab.hasClass( "ui-tabs-loading" ) ||
14322     // can't switch durning an animation
14323     this.running ||
14324     // click on active header, but not collapsible
14325     ( clickedIsActive && !options.collapsible ) ||
14326     // allow canceling activation
14327     ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
14328     return;
14329     }
14330    
14331     options.active = collapsing ? false : this.tabs.index( tab );
14332    
14333     this.active = clickedIsActive ? $() : tab;
14334     if ( this.xhr ) {
14335     this.xhr.abort();
14336     }
14337    
14338     if ( !toHide.length && !toShow.length ) {
14339     $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
14340     }
14341    
14342     if ( toShow.length ) {
14343     this.load( this.tabs.index( tab ), event );
14344     }
14345     this._toggle( event, eventData );
14346     },
14347    
14348     // handles show/hide for selecting tabs
14349     _toggle: function( event, eventData ) {
14350     var that = this,
14351     toShow = eventData.newPanel,
14352     toHide = eventData.oldPanel;
14353    
14354     this.running = true;
14355    
14356     function complete() {
14357     that.running = false;
14358     that._trigger( "activate", event, eventData );
14359     }
14360    
14361     function show() {
14362     eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
14363    
14364     if ( toShow.length && that.options.show ) {
14365     that._show( toShow, that.options.show, complete );
14366     } else {
14367     toShow.show();
14368     complete();
14369     }
14370     }
14371    
14372     // start out by hiding, then showing, then completing
14373     if ( toHide.length && this.options.hide ) {
14374     this._hide( toHide, this.options.hide, function() {
14375     eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
14376     show();
14377     });
14378     } else {
14379     eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
14380     toHide.hide();
14381     show();
14382     }
14383    
14384     toHide.attr({
14385     "aria-expanded": "false",
14386     "aria-hidden": "true"
14387     });
14388     eventData.oldTab.attr( "aria-selected", "false" );
14389     // If we're switching tabs, remove the old tab from the tab order.
14390     // If we're opening from collapsed state, remove the previous tab from the tab order.
14391     // If we're collapsing, then keep the collapsing tab in the tab order.
14392     if ( toShow.length && toHide.length ) {
14393     eventData.oldTab.attr( "tabIndex", -1 );
14394     } else if ( toShow.length ) {
14395     this.tabs.filter(function() {
14396     return $( this ).attr( "tabIndex" ) === 0;
14397     })
14398     .attr( "tabIndex", -1 );
14399     }
14400    
14401     toShow.attr({
14402     "aria-expanded": "true",
14403     "aria-hidden": "false"
14404     });
14405     eventData.newTab.attr({
14406     "aria-selected": "true",
14407     tabIndex: 0
14408     });
14409     },
14410    
14411     _activate: function( index ) {
14412     var anchor,
14413     active = this._findActive( index );
14414    
14415     // trying to activate the already active panel
14416     if ( active[ 0 ] === this.active[ 0 ] ) {
14417     return;
14418     }
14419    
14420     // trying to collapse, simulate a click on the current active header
14421     if ( !active.length ) {
14422     active = this.active;
14423     }
14424    
14425     anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
14426     this._eventHandler({
14427     target: anchor,
14428     currentTarget: anchor,
14429     preventDefault: $.noop
14430     });
14431     },
14432    
14433     _findActive: function( index ) {
14434     return index === false ? $() : this.tabs.eq( index );
14435     },
14436    
14437     _getIndex: function( index ) {
14438     // meta-function to give users option to provide a href string instead of a numerical index.
14439     if ( typeof index === "string" ) {
14440     index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
14441     }
14442    
14443     return index;
14444     },
14445    
14446     _destroy: function() {
14447     if ( this.xhr ) {
14448     this.xhr.abort();
14449     }
14450    
14451     this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
14452    
14453     this.tablist
14454     .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14455     .removeAttr( "role" );
14456    
14457     this.anchors
14458     .removeClass( "ui-tabs-anchor" )
14459     .removeAttr( "role" )
14460     .removeAttr( "tabIndex" )
14461     .removeUniqueId();
14462    
14463     this.tabs.add( this.panels ).each(function() {
14464     if ( $.data( this, "ui-tabs-destroy" ) ) {
14465     $( this ).remove();
14466     } else {
14467     $( this )
14468     .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
14469     "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
14470     .removeAttr( "tabIndex" )
14471     .removeAttr( "aria-live" )
14472     .removeAttr( "aria-busy" )
14473     .removeAttr( "aria-selected" )
14474     .removeAttr( "aria-labelledby" )
14475     .removeAttr( "aria-hidden" )
14476     .removeAttr( "aria-expanded" )
14477     .removeAttr( "role" );
14478     }
14479     });
14480    
14481     this.tabs.each(function() {
14482     var li = $( this ),
14483     prev = li.data( "ui-tabs-aria-controls" );
14484     if ( prev ) {
14485     li
14486     .attr( "aria-controls", prev )
14487     .removeData( "ui-tabs-aria-controls" );
14488     } else {
14489     li.removeAttr( "aria-controls" );
14490     }
14491     });
14492    
14493     this.panels.show();
14494    
14495     if ( this.options.heightStyle !== "content" ) {
14496     this.panels.css( "height", "" );
14497     }
14498     },
14499    
14500     enable: function( index ) {
14501     var disabled = this.options.disabled;
14502     if ( disabled === false ) {
14503     return;
14504     }
14505    
14506     if ( index === undefined ) {
14507     disabled = false;
14508     } else {
14509     index = this._getIndex( index );
14510     if ( $.isArray( disabled ) ) {
14511     disabled = $.map( disabled, function( num ) {
14512     return num !== index ? num : null;
14513     });
14514     } else {
14515     disabled = $.map( this.tabs, function( li, num ) {
14516     return num !== index ? num : null;
14517     });
14518     }
14519     }
14520     this._setupDisabled( disabled );
14521     },
14522    
14523     disable: function( index ) {
14524     var disabled = this.options.disabled;
14525     if ( disabled === true ) {
14526     return;
14527     }
14528    
14529     if ( index === undefined ) {
14530     disabled = true;
14531     } else {
14532     index = this._getIndex( index );
14533     if ( $.inArray( index, disabled ) !== -1 ) {
14534     return;
14535     }
14536     if ( $.isArray( disabled ) ) {
14537     disabled = $.merge( [ index ], disabled ).sort();
14538     } else {
14539     disabled = [ index ];
14540     }
14541     }
14542     this._setupDisabled( disabled );
14543     },
14544    
14545     load: function( index, event ) {
14546     index = this._getIndex( index );
14547     var that = this,
14548     tab = this.tabs.eq( index ),
14549     anchor = tab.find( ".ui-tabs-anchor" ),
14550     panel = this._getPanelForTab( tab ),
14551     eventData = {
14552     tab: tab,
14553     panel: panel
14554     };
14555    
14556     // not remote
14557     if ( isLocal( anchor[ 0 ] ) ) {
14558     return;
14559     }
14560    
14561     this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
14562    
14563     // support: jQuery <1.8
14564     // jQuery <1.8 returns false if the request is canceled in beforeSend,
14565     // but as of 1.8, $.ajax() always returns a jqXHR object.
14566     if ( this.xhr && this.xhr.statusText !== "canceled" ) {
14567     tab.addClass( "ui-tabs-loading" );
14568     panel.attr( "aria-busy", "true" );
14569    
14570     this.xhr
14571     .success(function( response ) {
14572     // support: jQuery <1.8
14573     // http://bugs.jquery.com/ticket/11778
14574     setTimeout(function() {
14575     panel.html( response );
14576     that._trigger( "load", event, eventData );
14577     }, 1 );
14578     })
14579     .complete(function( jqXHR, status ) {
14580     // support: jQuery <1.8
14581     // http://bugs.jquery.com/ticket/11778
14582     setTimeout(function() {
14583     if ( status === "abort" ) {
14584     that.panels.stop( false, true );
14585     }
14586    
14587     tab.removeClass( "ui-tabs-loading" );
14588     panel.removeAttr( "aria-busy" );
14589    
14590     if ( jqXHR === that.xhr ) {
14591     delete that.xhr;
14592     }
14593     }, 1 );
14594     });
14595     }
14596     },
14597    
14598     _ajaxSettings: function( anchor, event, eventData ) {
14599     var that = this;
14600     return {
14601     url: anchor.attr( "href" ),
14602     beforeSend: function( jqXHR, settings ) {
14603     return that._trigger( "beforeLoad", event,
14604     $.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
14605     }
14606     };
14607     },
14608    
14609     _getPanelForTab: function( tab ) {
14610     var id = $( tab ).attr( "aria-controls" );
14611     return this.element.find( this._sanitizeSelector( "#" + id ) );
14612     }
14613     });
14614    
14615     })( jQuery );
14616    
14617     (function( $ ) {
14618    
14619     var increments = 0;
14620    
14621     function addDescribedBy( elem, id ) {
14622     var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
14623     describedby.push( id );
14624     elem
14625     .data( "ui-tooltip-id", id )
14626     .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
14627     }
14628    
14629     function removeDescribedBy( elem ) {
14630     var id = elem.data( "ui-tooltip-id" ),
14631     describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
14632     index = $.inArray( id, describedby );
14633     if ( index !== -1 ) {
14634     describedby.splice( index, 1 );
14635     }
14636    
14637     elem.removeData( "ui-tooltip-id" );
14638     describedby = $.trim( describedby.join( " " ) );
14639     if ( describedby ) {
14640     elem.attr( "aria-describedby", describedby );
14641     } else {
14642     elem.removeAttr( "aria-describedby" );
14643     }
14644     }
14645    
14646     $.widget( "ui.tooltip", {
14647     version: "1.10.3",
14648     options: {
14649     content: function() {
14650     // support: IE<9, Opera in jQuery <1.7
14651     // .text() can't accept undefined, so coerce to a string
14652     var title = $( this ).attr( "title" ) || "";
14653     // Escape title, since we're going from an attribute to raw HTML
14654     return $( "<a>" ).text( title ).html();
14655     },
14656     hide: true,
14657     // Disabled elements have inconsistent behavior across browsers (#8661)
14658     items: "[title]:not([disabled])",
14659     position: {
14660     my: "left top+15",
14661     at: "left bottom",
14662     collision: "flipfit flip"
14663     },
14664     show: true,
14665     tooltipClass: null,
14666     track: false,
14667    
14668     // callbacks
14669     close: null,
14670     open: null
14671     },
14672    
14673     _create: function() {
14674     this._on({
14675     mouseover: "open",
14676     focusin: "open"
14677     });
14678    
14679     // IDs of generated tooltips, needed for destroy
14680     this.tooltips = {};
14681     // IDs of parent tooltips where we removed the title attribute
14682     this.parents = {};
14683    
14684     if ( this.options.disabled ) {
14685     this._disable();
14686     }
14687     },
14688    
14689     _setOption: function( key, value ) {
14690     var that = this;
14691    
14692     if ( key === "disabled" ) {
14693     this[ value ? "_disable" : "_enable" ]();
14694     this.options[ key ] = value;
14695     // disable element style changes
14696     return;
14697     }
14698    
14699     this._super( key, value );
14700    
14701     if ( key === "content" ) {
14702     $.each( this.tooltips, function( id, element ) {
14703     that._updateContent( element );
14704     });
14705     }
14706     },
14707    
14708     _disable: function() {
14709     var that = this;
14710    
14711     // close open tooltips
14712     $.each( this.tooltips, function( id, element ) {
14713     var event = $.Event( "blur" );
14714     event.target = event.currentTarget = element[0];
14715     that.close( event, true );
14716     });
14717    
14718     // remove title attributes to prevent native tooltips
14719     this.element.find( this.options.items ).addBack().each(function() {
14720     var element = $( this );
14721     if ( element.is( "[title]" ) ) {
14722     element
14723     .data( "ui-tooltip-title", element.attr( "title" ) )
14724     .attr( "title", "" );
14725     }
14726     });
14727     },
14728    
14729     _enable: function() {
14730     // restore title attributes
14731     this.element.find( this.options.items ).addBack().each(function() {
14732     var element = $( this );
14733     if ( element.data( "ui-tooltip-title" ) ) {
14734     element.attr( "title", element.data( "ui-tooltip-title" ) );
14735     }
14736     });
14737     },
14738    
14739     open: function( event ) {
14740     var that = this,
14741     target = $( event ? event.target : this.element )
14742     // we need closest here due to mouseover bubbling,
14743     // but always pointing at the same event target
14744     .closest( this.options.items );
14745    
14746     // No element to show a tooltip for or the tooltip is already open
14747     if ( !target.length || target.data( "ui-tooltip-id" ) ) {
14748     return;
14749     }
14750    
14751     if ( target.attr( "title" ) ) {
14752     target.data( "ui-tooltip-title", target.attr( "title" ) );
14753     }
14754    
14755     target.data( "ui-tooltip-open", true );
14756    
14757     // kill parent tooltips, custom or native, for hover
14758     if ( event && event.type === "mouseover" ) {
14759     target.parents().each(function() {
14760     var parent = $( this ),
14761     blurEvent;
14762     if ( parent.data( "ui-tooltip-open" ) ) {
14763     blurEvent = $.Event( "blur" );
14764     blurEvent.target = blurEvent.currentTarget = this;
14765     that.close( blurEvent, true );
14766     }
14767     if ( parent.attr( "title" ) ) {
14768     parent.uniqueId();
14769     that.parents[ this.id ] = {
14770     element: this,
14771     title: parent.attr( "title" )
14772     };
14773     parent.attr( "title", "" );
14774     }
14775     });
14776     }
14777    
14778     this._updateContent( target, event );
14779     },
14780    
14781     _updateContent: function( target, event ) {
14782     var content,
14783     contentOption = this.options.content,
14784     that = this,
14785     eventType = event ? event.type : null;
14786    
14787     if ( typeof contentOption === "string" ) {
14788     return this._open( event, target, contentOption );
14789     }
14790    
14791     content = contentOption.call( target[0], function( response ) {
14792     // ignore async response if tooltip was closed already
14793     if ( !target.data( "ui-tooltip-open" ) ) {
14794     return;
14795     }
14796     // IE may instantly serve a cached response for ajax requests
14797     // delay this call to _open so the other call to _open runs first
14798     that._delay(function() {
14799     // jQuery creates a special event for focusin when it doesn't
14800     // exist natively. To improve performance, the native event
14801     // object is reused and the type is changed. Therefore, we can't
14802     // rely on the type being correct after the event finished
14803     // bubbling, so we set it back to the previous value. (#8740)
14804     if ( event ) {
14805     event.type = eventType;
14806     }
14807     this._open( event, target, response );
14808     });
14809     });
14810     if ( content ) {
14811     this._open( event, target, content );
14812     }
14813     },
14814    
14815     _open: function( event, target, content ) {
14816     var tooltip, events, delayedShow,
14817     positionOption = $.extend( {}, this.options.position );
14818    
14819     if ( !content ) {
14820     return;
14821     }
14822    
14823     // Content can be updated multiple times. If the tooltip already
14824     // exists, then just update the content and bail.
14825     tooltip = this._find( target );
14826     if ( tooltip.length ) {
14827     tooltip.find( ".ui-tooltip-content" ).html( content );
14828     return;
14829     }
14830    
14831     // if we have a title, clear it to prevent the native tooltip
14832     // we have to check first to avoid defining a title if none exists
14833     // (we don't want to cause an element to start matching [title])
14834     //
14835     // We use removeAttr only for key events, to allow IE to export the correct
14836     // accessible attributes. For mouse events, set to empty string to avoid
14837     // native tooltip showing up (happens only when removing inside mouseover).
14838     if ( target.is( "[title]" ) ) {
14839     if ( event && event.type === "mouseover" ) {
14840     target.attr( "title", "" );
14841     } else {
14842     target.removeAttr( "title" );
14843     }
14844     }
14845    
14846     tooltip = this._tooltip( target );
14847     addDescribedBy( target, tooltip.attr( "id" ) );
14848     tooltip.find( ".ui-tooltip-content" ).html( content );
14849    
14850     function position( event ) {
14851     positionOption.of = event;
14852     if ( tooltip.is( ":hidden" ) ) {
14853     return;
14854     }
14855     tooltip.position( positionOption );
14856     }
14857     if ( this.options.track && event && /^mouse/.test( event.type ) ) {
14858     this._on( this.document, {
14859     mousemove: position
14860     });
14861     // trigger once to override element-relative positioning
14862     position( event );
14863     } else {
14864     tooltip.position( $.extend({
14865     of: target
14866     }, this.options.position ) );
14867     }
14868    
14869     tooltip.hide();
14870    
14871     this._show( tooltip, this.options.show );
14872     // Handle tracking tooltips that are shown with a delay (#8644). As soon
14873     // as the tooltip is visible, position the tooltip using the most recent
14874     // event.
14875     if ( this.options.show && this.options.show.delay ) {
14876     delayedShow = this.delayedShow = setInterval(function() {
14877     if ( tooltip.is( ":visible" ) ) {
14878     position( positionOption.of );
14879     clearInterval( delayedShow );
14880     }
14881     }, $.fx.interval );
14882     }
14883    
14884     this._trigger( "open", event, { tooltip: tooltip } );
14885    
14886     events = {
14887     keyup: function( event ) {
14888     if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
14889     var fakeEvent = $.Event(event);
14890     fakeEvent.currentTarget = target[0];
14891     this.close( fakeEvent, true );
14892     }
14893     },
14894     remove: function() {
14895     this._removeTooltip( tooltip );
14896     }
14897     };
14898     if ( !event || event.type === "mouseover" ) {
14899     events.mouseleave = "close";
14900     }
14901     if ( !event || event.type === "focusin" ) {
14902     events.focusout = "close";
14903     }
14904     this._on( true, target, events );
14905     },
14906    
14907     close: function( event ) {
14908     var that = this,
14909     target = $( event ? event.currentTarget : this.element ),
14910     tooltip = this._find( target );
14911    
14912     // disabling closes the tooltip, so we need to track when we're closing
14913     // to avoid an infinite loop in case the tooltip becomes disabled on close
14914     if ( this.closing ) {
14915     return;
14916     }
14917    
14918     // Clear the interval for delayed tracking tooltips
14919     clearInterval( this.delayedShow );
14920    
14921     // only set title if we had one before (see comment in _open())
14922     if ( target.data( "ui-tooltip-title" ) ) {
14923     target.attr( "title", target.data( "ui-tooltip-title" ) );
14924     }
14925    
14926     removeDescribedBy( target );
14927    
14928     tooltip.stop( true );
14929     this._hide( tooltip, this.options.hide, function() {
14930     that._removeTooltip( $( this ) );
14931     });
14932    
14933     target.removeData( "ui-tooltip-open" );
14934     this._off( target, "mouseleave focusout keyup" );
14935     // Remove 'remove' binding only on delegated targets
14936     if ( target[0] !== this.element[0] ) {
14937     this._off( target, "remove" );
14938     }
14939     this._off( this.document, "mousemove" );
14940    
14941     if ( event && event.type === "mouseleave" ) {
14942     $.each( this.parents, function( id, parent ) {
14943     $( parent.element ).attr( "title", parent.title );
14944     delete that.parents[ id ];
14945     });
14946     }
14947    
14948     this.closing = true;
14949     this._trigger( "close", event, { tooltip: tooltip } );
14950     this.closing = false;
14951     },
14952    
14953     _tooltip: function( element ) {
14954     var id = "ui-tooltip-" + increments++,
14955     tooltip = $( "<div>" )
14956     .attr({
14957     id: id,
14958     role: "tooltip"
14959     })
14960     .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
14961     ( this.options.tooltipClass || "" ) );
14962     $( "<div>" )
14963     .addClass( "ui-tooltip-content" )
14964     .appendTo( tooltip );
14965     tooltip.appendTo( this.document[0].body );
14966     this.tooltips[ id ] = element;
14967     return tooltip;
14968     },
14969    
14970     _find: function( target ) {
14971     var id = target.data( "ui-tooltip-id" );
14972     return id ? $( "#" + id ) : $();
14973     },
14974    
14975     _removeTooltip: function( tooltip ) {
14976     tooltip.remove();
14977     delete this.tooltips[ tooltip.attr( "id" ) ];
14978     },
14979    
14980     _destroy: function() {
14981     var that = this;
14982    
14983     // close open tooltips
14984     $.each( this.tooltips, function( id, element ) {
14985     // Delegate to close method to handle common cleanup
14986     var event = $.Event( "blur" );
14987     event.target = event.currentTarget = element[0];
14988     that.close( event, true );
14989    
14990     // Remove immediately; destroying an open tooltip doesn't use the
14991     // hide animation
14992     $( "#" + id ).remove();
14993    
14994     // Restore the title
14995     if ( element.data( "ui-tooltip-title" ) ) {
14996     element.attr( "title", element.data( "ui-tooltip-title" ) );
14997     element.removeData( "ui-tooltip-title" );
14998     }
14999     });
15000     }
15001     });
15002    
15003     }( jQuery ) );
  ViewVC Help
Powered by ViewVC 1.1.20