JSlip  1.0
jquery-ui.js
Go to the documentation of this file.
1 /*! jQuery UI - v1.12.1 - 2016-09-14
2 * http://jqueryui.com
3 * Includes: widget.js, position.js, data.js, disable-selection.js, effect.js, effects/effect-blind.js, effects/effect-bounce.js, effects/effect-clip.js, effects/effect-drop.js, effects/effect-explode.js, effects/effect-fade.js, effects/effect-fold.js, effects/effect-highlight.js, effects/effect-puff.js, effects/effect-pulsate.js, effects/effect-scale.js, effects/effect-shake.js, effects/effect-size.js, effects/effect-slide.js, effects/effect-transfer.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/accordion.js, widgets/autocomplete.js, widgets/button.js, widgets/checkboxradio.js, widgets/controlgroup.js, widgets/datepicker.js, widgets/dialog.js, widgets/draggable.js, widgets/droppable.js, widgets/menu.js, widgets/mouse.js, widgets/progressbar.js, widgets/resizable.js, widgets/selectable.js, widgets/selectmenu.js, widgets/slider.js, widgets/sortable.js, widgets/spinner.js, widgets/tabs.js, widgets/tooltip.js
4 * Copyright jQuery Foundation and other contributors; Licensed MIT */
5 
6 (function( factory ) {
7  if ( typeof define === "function" && define.amd ) {
8 
9  // AMD. Register as an anonymous module.
10  define([ "jquery" ], factory );
11  } else {
12 
13  // Browser globals
14  factory( jQuery );
15  }
16 }(function( $ ) {
17 
18 $.ui = $.ui || {};
19 
20 var version = $.ui.version = "1.12.1";
21 
22 
23 /*!
24  * jQuery UI Widget 1.12.1
25  * http://jqueryui.com
26  *
27  * Copyright jQuery Foundation and other contributors
28  * Released under the MIT license.
29  * http://jquery.org/license
30  */
31 
32 //>>label: Widget
33 //>>group: Core
34 //>>description: Provides a factory for creating stateful widgets with a common API.
35 //>>docs: http://api.jqueryui.com/jQuery.widget/
36 //>>demos: http://jqueryui.com/widget/
37 
38 
39 
40 var widgetUuid = 0;
41 var widgetSlice = Array.prototype.slice;
42 
43 $.cleanData = ( function( orig ) {
44  return function( elems ) {
45  var events, elem, i;
46  for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
47  try {
48 
49  // Only trigger remove when necessary to save time
50  events = $._data( elem, "events" );
51  if ( events && events.remove ) {
52  $( elem ).triggerHandler( "remove" );
53  }
54 
55  // Http://bugs.jquery.com/ticket/8235
56  } catch ( e ) {}
57  }
58  orig( elems );
59  };
60 } )( $.cleanData );
61 
62 $.widget = function( name, base, prototype ) {
63  var existingConstructor, constructor, basePrototype;
64 
65  // ProxiedPrototype allows the provided prototype to remain unmodified
66  // so that it can be used as a mixin for multiple widgets (#8876)
67  var proxiedPrototype = {};
68 
69  var namespace = name.split( "." )[ 0 ];
70  name = name.split( "." )[ 1 ];
71  var fullName = namespace + "-" + name;
72 
73  if ( !prototype ) {
74  prototype = base;
75  base = $.Widget;
76  }
77 
78  if ( $.isArray( prototype ) ) {
79  prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
80  }
81 
82  // Create selector for plugin
83  $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
84  return !!$.data( elem, fullName );
85  };
86 
87  $[ namespace ] = $[ namespace ] || {};
88  existingConstructor = $[ namespace ][ name ];
89  constructor = $[ namespace ][ name ] = function( options, element ) {
90 
91  // Allow instantiation without "new" keyword
92  if ( !this._createWidget ) {
93  return new constructor( options, element );
94  }
95 
96  // Allow instantiation without initializing for simple inheritance
97  // must use "new" keyword (the code above always passes args)
98  if ( arguments.length ) {
99  this._createWidget( options, element );
100  }
101  };
102 
103  // Extend with the existing constructor to carry over any static properties
104  $.extend( constructor, existingConstructor, {
105  version: prototype.version,
106 
107  // Copy the object used to create the prototype in case we need to
108  // redefine the widget later
109  _proto: $.extend( {}, prototype ),
110 
111  // Track widgets that inherit from this widget in case this widget is
112  // redefined after a widget inherits from it
113  _childConstructors: []
114  } );
115 
116  basePrototype = new base();
117 
118  // We need to make the options hash a property directly on the new instance
119  // otherwise we'll modify the options hash on the prototype that we're
120  // inheriting from
121  basePrototype.options = $.widget.extend( {}, basePrototype.options );
122  $.each( prototype, function( prop, value ) {
123  if ( !$.isFunction( value ) ) {
124  proxiedPrototype[ prop ] = value;
125  return;
126  }
127  proxiedPrototype[ prop ] = ( function() {
128  function _super() {
129  return base.prototype[ prop ].apply( this, arguments );
130  }
131 
132  function _superApply( args ) {
133  return base.prototype[ prop ].apply( this, args );
134  }
135 
136  return function() {
137  var __super = this._super;
138  var __superApply = this._superApply;
139  var returnValue;
140 
141  this._super = _super;
142  this._superApply = _superApply;
143 
144  returnValue = value.apply( this, arguments );
145 
146  this._super = __super;
147  this._superApply = __superApply;
148 
149  return returnValue;
150  };
151  } )();
152  } );
153  constructor.prototype = $.widget.extend( basePrototype, {
154 
155  // TODO: remove support for widgetEventPrefix
156  // always use the name + a colon as the prefix, e.g., draggable:start
157  // don't prefix for widgets that aren't DOM-based
158  widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
159  }, proxiedPrototype, {
160  constructor: constructor,
161  namespace: namespace,
162  widgetName: name,
163  widgetFullName: fullName
164  } );
165 
166  // If this widget is being redefined then we need to find all widgets that
167  // are inheriting from it and redefine all of them so that they inherit from
168  // the new version of this widget. We're essentially trying to replace one
169  // level in the prototype chain.
170  if ( existingConstructor ) {
171  $.each( existingConstructor._childConstructors, function( i, child ) {
172  var childPrototype = child.prototype;
173 
174  // Redefine the child widget using the same prototype that was
175  // originally used, but inherit from the new version of the base
176  $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
177  child._proto );
178  } );
179 
180  // Remove the list of existing child constructors from the old constructor
181  // so the old child constructors can be garbage collected
182  delete existingConstructor._childConstructors;
183  } else {
184  base._childConstructors.push( constructor );
185  }
186 
187  $.widget.bridge( name, constructor );
188 
189  return constructor;
190 };
191 
192 $.widget.extend = function( target ) {
193  var input = widgetSlice.call( arguments, 1 );
194  var inputIndex = 0;
195  var inputLength = input.length;
196  var key;
197  var value;
198 
199  for ( ; inputIndex < inputLength; inputIndex++ ) {
200  for ( key in input[ inputIndex ] ) {
201  value = input[ inputIndex ][ key ];
202  if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
203 
204  // Clone objects
205  if ( $.isPlainObject( value ) ) {
206  target[ key ] = $.isPlainObject( target[ key ] ) ?
207  $.widget.extend( {}, target[ key ], value ) :
208 
209  // Don't extend strings, arrays, etc. with objects
210  $.widget.extend( {}, value );
211 
212  // Copy everything else by reference
213  } else {
214  target[ key ] = value;
215  }
216  }
217  }
218  }
219  return target;
220 };
221 
222 $.widget.bridge = function( name, object ) {
223  var fullName = object.prototype.widgetFullName || name;
224  $.fn[ name ] = function( options ) {
225  var isMethodCall = typeof options === "string";
226  var args = widgetSlice.call( arguments, 1 );
227  var returnValue = this;
228 
229  if ( isMethodCall ) {
230 
231  // If this is an empty collection, we need to have the instance method
232  // return undefined instead of the jQuery instance
233  if ( !this.length && options === "instance" ) {
234  returnValue = undefined;
235  } else {
236  this.each( function() {
237  var methodValue;
238  var instance = $.data( this, fullName );
239 
240  if ( options === "instance" ) {
241  returnValue = instance;
242  return false;
243  }
244 
245  if ( !instance ) {
246  return $.error( "cannot call methods on " + name +
247  " prior to initialization; " +
248  "attempted to call method '" + options + "'" );
249  }
250 
251  if ( !$.isFunction( instance[ options ] ) || options.charAt( 0 ) === "_" ) {
252  return $.error( "no such method '" + options + "' for " + name +
253  " widget instance" );
254  }
255 
256  methodValue = instance[ options ].apply( instance, args );
257 
258  if ( methodValue !== instance && methodValue !== undefined ) {
259  returnValue = methodValue && methodValue.jquery ?
260  returnValue.pushStack( methodValue.get() ) :
261  methodValue;
262  return false;
263  }
264  } );
265  }
266  } else {
267 
268  // Allow multiple hashes to be passed on init
269  if ( args.length ) {
270  options = $.widget.extend.apply( null, [ options ].concat( args ) );
271  }
272 
273  this.each( function() {
274  var instance = $.data( this, fullName );
275  if ( instance ) {
276  instance.option( options || {} );
277  if ( instance._init ) {
278  instance._init();
279  }
280  } else {
281  $.data( this, fullName, new object( options, this ) );
282  }
283  } );
284  }
285 
286  return returnValue;
287  };
288 };
289 
290 $.Widget = function( /* options, element */ ) {};
291 $.Widget._childConstructors = [];
292 
293 $.Widget.prototype = {
294  widgetName: "widget",
295  widgetEventPrefix: "",
296  defaultElement: "<div>",
297 
298  options: {
299  classes: {},
300  disabled: false,
301 
302  // Callbacks
303  create: null
304  },
305 
306  _createWidget: function( options, element ) {
307  element = $( element || this.defaultElement || this )[ 0 ];
308  this.element = $( element );
309  this.uuid = widgetUuid++;
310  this.eventNamespace = "." + this.widgetName + this.uuid;
311 
312  this.bindings = $();
313  this.hoverable = $();
314  this.focusable = $();
315  this.classesElementLookup = {};
316 
317  if ( element !== this ) {
318  $.data( element, this.widgetFullName, this );
319  this._on( true, this.element, {
320  remove: function( event ) {
321  if ( event.target === element ) {
322  this.destroy();
323  }
324  }
325  } );
326  this.document = $( element.style ?
327 
328  // Element within the document
329  element.ownerDocument :
330 
331  // Element is window or document
332  element.document || element );
333  this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
334  }
335 
336  this.options = $.widget.extend( {},
337  this.options,
338  this._getCreateOptions(),
339  options );
340 
341  this._create();
342 
343  if ( this.options.disabled ) {
344  this._setOptionDisabled( this.options.disabled );
345  }
346 
347  this._trigger( "create", null, this._getCreateEventData() );
348  this._init();
349  },
350 
351  _getCreateOptions: function() {
352  return {};
353  },
354 
355  _getCreateEventData: $.noop,
356 
357  _create: $.noop,
358 
359  _init: $.noop,
360 
361  destroy: function() {
362  var that = this;
363 
364  this._destroy();
365  $.each( this.classesElementLookup, function( key, value ) {
366  that._removeClass( value, key );
367  } );
368 
369  // We can probably remove the unbind calls in 2.0
370  // all event bindings should go through this._on()
371  this.element
372  .off( this.eventNamespace )
373  .removeData( this.widgetFullName );
374  this.widget()
375  .off( this.eventNamespace )
376  .removeAttr( "aria-disabled" );
377 
378  // Clean up events and states
379  this.bindings.off( this.eventNamespace );
380  },
381 
382  _destroy: $.noop,
383 
384  widget: function() {
385  return this.element;
386  },
387 
388  option: function( key, value ) {
389  var options = key;
390  var parts;
391  var curOption;
392  var i;
393 
394  if ( arguments.length === 0 ) {
395 
396  // Don't return a reference to the internal hash
397  return $.widget.extend( {}, this.options );
398  }
399 
400  if ( typeof key === "string" ) {
401 
402  // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
403  options = {};
404  parts = key.split( "." );
405  key = parts.shift();
406  if ( parts.length ) {
407  curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
408  for ( i = 0; i < parts.length - 1; i++ ) {
409  curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
410  curOption = curOption[ parts[ i ] ];
411  }
412  key = parts.pop();
413  if ( arguments.length === 1 ) {
414  return curOption[ key ] === undefined ? null : curOption[ key ];
415  }
416  curOption[ key ] = value;
417  } else {
418  if ( arguments.length === 1 ) {
419  return this.options[ key ] === undefined ? null : this.options[ key ];
420  }
421  options[ key ] = value;
422  }
423  }
424 
425  this._setOptions( options );
426 
427  return this;
428  },
429 
430  _setOptions: function( options ) {
431  var key;
432 
433  for ( key in options ) {
434  this._setOption( key, options[ key ] );
435  }
436 
437  return this;
438  },
439 
440  _setOption: function( key, value ) {
441  if ( key === "classes" ) {
442  this._setOptionClasses( value );
443  }
444 
445  this.options[ key ] = value;
446 
447  if ( key === "disabled" ) {
448  this._setOptionDisabled( value );
449  }
450 
451  return this;
452  },
453 
454  _setOptionClasses: function( value ) {
455  var classKey, elements, currentElements;
456 
457  for ( classKey in value ) {
458  currentElements = this.classesElementLookup[ classKey ];
459  if ( value[ classKey ] === this.options.classes[ classKey ] ||
460  !currentElements ||
461  !currentElements.length ) {
462  continue;
463  }
464 
465  // We are doing this to create a new jQuery object because the _removeClass() call
466  // on the next line is going to destroy the reference to the current elements being
467  // tracked. We need to save a copy of this collection so that we can add the new classes
468  // below.
469  elements = $( currentElements.get() );
470  this._removeClass( currentElements, classKey );
471 
472  // We don't use _addClass() here, because that uses this.options.classes
473  // for generating the string of classes. We want to use the value passed in from
474  // _setOption(), this is the new value of the classes option which was passed to
475  // _setOption(). We pass this value directly to _classes().
476  elements.addClass( this._classes( {
477  element: elements,
478  keys: classKey,
479  classes: value,
480  add: true
481  } ) );
482  }
483  },
484 
485  _setOptionDisabled: function( value ) {
486  this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
487 
488  // If the widget is becoming disabled, then nothing is interactive
489  if ( value ) {
490  this._removeClass( this.hoverable, null, "ui-state-hover" );
491  this._removeClass( this.focusable, null, "ui-state-focus" );
492  }
493  },
494 
495  enable: function() {
496  return this._setOptions( { disabled: false } );
497  },
498 
499  disable: function() {
500  return this._setOptions( { disabled: true } );
501  },
502 
503  _classes: function( options ) {
504  var full = [];
505  var that = this;
506 
507  options = $.extend( {
508  element: this.element,
509  classes: this.options.classes || {}
510  }, options );
511 
512  function processClassString( classes, checkOption ) {
513  var current, i;
514  for ( i = 0; i < classes.length; i++ ) {
515  current = that.classesElementLookup[ classes[ i ] ] || $();
516  if ( options.add ) {
517  current = $( $.unique( current.get().concat( options.element.get() ) ) );
518  } else {
519  current = $( current.not( options.element ).get() );
520  }
521  that.classesElementLookup[ classes[ i ] ] = current;
522  full.push( classes[ i ] );
523  if ( checkOption && options.classes[ classes[ i ] ] ) {
524  full.push( options.classes[ classes[ i ] ] );
525  }
526  }
527  }
528 
529  this._on( options.element, {
530  "remove": "_untrackClassesElement"
531  } );
532 
533  if ( options.keys ) {
534  processClassString( options.keys.match( /\S+/g ) || [], true );
535  }
536  if ( options.extra ) {
537  processClassString( options.extra.match( /\S+/g ) || [] );
538  }
539 
540  return full.join( " " );
541  },
542 
543  _untrackClassesElement: function( event ) {
544  var that = this;
545  $.each( that.classesElementLookup, function( key, value ) {
546  if ( $.inArray( event.target, value ) !== -1 ) {
547  that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
548  }
549  } );
550  },
551 
552  _removeClass: function( element, keys, extra ) {
553  return this._toggleClass( element, keys, extra, false );
554  },
555 
556  _addClass: function( element, keys, extra ) {
557  return this._toggleClass( element, keys, extra, true );
558  },
559 
560  _toggleClass: function( element, keys, extra, add ) {
561  add = ( typeof add === "boolean" ) ? add : extra;
562  var shift = ( typeof element === "string" || element === null ),
563  options = {
564  extra: shift ? keys : extra,
565  keys: shift ? element : keys,
566  element: shift ? this.element : element,
567  add: add
568  };
569  options.element.toggleClass( this._classes( options ), add );
570  return this;
571  },
572 
573  _on: function( suppressDisabledCheck, element, handlers ) {
574  var delegateElement;
575  var instance = this;
576 
577  // No suppressDisabledCheck flag, shuffle arguments
578  if ( typeof suppressDisabledCheck !== "boolean" ) {
579  handlers = element;
580  element = suppressDisabledCheck;
581  suppressDisabledCheck = false;
582  }
583 
584  // No element argument, shuffle and use this.element
585  if ( !handlers ) {
586  handlers = element;
587  element = this.element;
588  delegateElement = this.widget();
589  } else {
590  element = delegateElement = $( element );
591  this.bindings = this.bindings.add( element );
592  }
593 
594  $.each( handlers, function( event, handler ) {
595  function handlerProxy() {
596 
597  // Allow widgets to customize the disabled handling
598  // - disabled as an array instead of boolean
599  // - disabled class as method for disabling individual parts
600  if ( !suppressDisabledCheck &&
601  ( instance.options.disabled === true ||
602  $( this ).hasClass( "ui-state-disabled" ) ) ) {
603  return;
604  }
605  return ( typeof handler === "string" ? instance[ handler ] : handler )
606  .apply( instance, arguments );
607  }
608 
609  // Copy the guid so direct unbinding works
610  if ( typeof handler !== "string" ) {
611  handlerProxy.guid = handler.guid =
612  handler.guid || handlerProxy.guid || $.guid++;
613  }
614 
615  var match = event.match( /^([\w:-]*)\s*(.*)$/ );
616  var eventName = match[ 1 ] + instance.eventNamespace;
617  var selector = match[ 2 ];
618 
619  if ( selector ) {
620  delegateElement.on( eventName, selector, handlerProxy );
621  } else {
622  element.on( eventName, handlerProxy );
623  }
624  } );
625  },
626 
627  _off: function( element, eventName ) {
628  eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
629  this.eventNamespace;
630  element.off( eventName ).off( eventName );
631 
632  // Clear the stack to avoid memory leaks (#10056)
633  this.bindings = $( this.bindings.not( element ).get() );
634  this.focusable = $( this.focusable.not( element ).get() );
635  this.hoverable = $( this.hoverable.not( element ).get() );
636  },
637 
638  _delay: function( handler, delay ) {
639  function handlerProxy() {
640  return ( typeof handler === "string" ? instance[ handler ] : handler )
641  .apply( instance, arguments );
642  }
643  var instance = this;
644  return setTimeout( handlerProxy, delay || 0 );
645  },
646 
647  _hoverable: function( element ) {
648  this.hoverable = this.hoverable.add( element );
649  this._on( element, {
650  mouseenter: function( event ) {
651  this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
652  },
653  mouseleave: function( event ) {
654  this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
655  }
656  } );
657  },
658 
659  _focusable: function( element ) {
660  this.focusable = this.focusable.add( element );
661  this._on( element, {
662  focusin: function( event ) {
663  this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
664  },
665  focusout: function( event ) {
666  this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
667  }
668  } );
669  },
670 
671  _trigger: function( type, event, data ) {
672  var prop, orig;
673  var callback = this.options[ type ];
674 
675  data = data || {};
676  event = $.Event( event );
677  event.type = ( type === this.widgetEventPrefix ?
678  type :
679  this.widgetEventPrefix + type ).toLowerCase();
680 
681  // The original event may come from any element
682  // so we need to reset the target on the new event
683  event.target = this.element[ 0 ];
684 
685  // Copy original event properties over to the new event
686  orig = event.originalEvent;
687  if ( orig ) {
688  for ( prop in orig ) {
689  if ( !( prop in event ) ) {
690  event[ prop ] = orig[ prop ];
691  }
692  }
693  }
694 
695  this.element.trigger( event, data );
696  return !( $.isFunction( callback ) &&
697  callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
698  event.isDefaultPrevented() );
699  }
700 };
701 
702 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
703  $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
704  if ( typeof options === "string" ) {
705  options = { effect: options };
706  }
707 
708  var hasOptions;
709  var effectName = !options ?
710  method :
711  options === true || typeof options === "number" ?
712  defaultEffect :
713  options.effect || defaultEffect;
714 
715  options = options || {};
716  if ( typeof options === "number" ) {
717  options = { duration: options };
718  }
719 
720  hasOptions = !$.isEmptyObject( options );
721  options.complete = callback;
722 
723  if ( options.delay ) {
724  element.delay( options.delay );
725  }
726 
727  if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
728  element[ method ]( options );
729  } else if ( effectName !== method && element[ effectName ] ) {
730  element[ effectName ]( options.duration, options.easing, callback );
731  } else {
732  element.queue( function( next ) {
733  $( this )[ method ]();
734  if ( callback ) {
735  callback.call( element[ 0 ] );
736  }
737  next();
738  } );
739  }
740  };
741 } );
742 
743 var widget = $.widget;
744 
745 
746 /*!
747  * jQuery UI Position 1.12.1
748  * http://jqueryui.com
749  *
750  * Copyright jQuery Foundation and other contributors
751  * Released under the MIT license.
752  * http://jquery.org/license
753  *
754  * http://api.jqueryui.com/position/
755  */
756 
757 //>>label: Position
758 //>>group: Core
759 //>>description: Positions elements relative to other elements.
760 //>>docs: http://api.jqueryui.com/position/
761 //>>demos: http://jqueryui.com/position/
762 
763 
764 ( function() {
765 var cachedScrollbarWidth,
766  max = Math.max,
767  abs = Math.abs,
768  rhorizontal = /left|center|right/,
769  rvertical = /top|center|bottom/,
770  roffset = /[\+\-]\d+(\.[\d]+)?%?/,
771  rposition = /^\w+/,
772  rpercent = /%$/,
773  _position = $.fn.position;
774 
775 function getOffsets( offsets, width, height ) {
776  return [
777  parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
778  parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
779  ];
780 }
781 
782 function parseCss( element, property ) {
783  return parseInt( $.css( element, property ), 10 ) || 0;
784 }
785 
786 function getDimensions( elem ) {
787  var raw = elem[ 0 ];
788  if ( raw.nodeType === 9 ) {
789  return {
790  width: elem.width(),
791  height: elem.height(),
792  offset: { top: 0, left: 0 }
793  };
794  }
795  if ( $.isWindow( raw ) ) {
796  return {
797  width: elem.width(),
798  height: elem.height(),
799  offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
800  };
801  }
802  if ( raw.preventDefault ) {
803  return {
804  width: 0,
805  height: 0,
806  offset: { top: raw.pageY, left: raw.pageX }
807  };
808  }
809  return {
810  width: elem.outerWidth(),
811  height: elem.outerHeight(),
812  offset: elem.offset()
813  };
814 }
815 
816 $.position = {
817  scrollbarWidth: function() {
818  if ( cachedScrollbarWidth !== undefined ) {
819  return cachedScrollbarWidth;
820  }
821  var w1, w2,
822  div = $( "<div " +
823  "style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'>" +
824  "<div style='height:100px;width:auto;'></div></div>" ),
825  innerDiv = div.children()[ 0 ];
826 
827  $( "body" ).append( div );
828  w1 = innerDiv.offsetWidth;
829  div.css( "overflow", "scroll" );
830 
831  w2 = innerDiv.offsetWidth;
832 
833  if ( w1 === w2 ) {
834  w2 = div[ 0 ].clientWidth;
835  }
836 
837  div.remove();
838 
839  return ( cachedScrollbarWidth = w1 - w2 );
840  },
841  getScrollInfo: function( within ) {
842  var overflowX = within.isWindow || within.isDocument ? "" :
843  within.element.css( "overflow-x" ),
844  overflowY = within.isWindow || within.isDocument ? "" :
845  within.element.css( "overflow-y" ),
846  hasOverflowX = overflowX === "scroll" ||
847  ( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),
848  hasOverflowY = overflowY === "scroll" ||
849  ( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );
850  return {
851  width: hasOverflowY ? $.position.scrollbarWidth() : 0,
852  height: hasOverflowX ? $.position.scrollbarWidth() : 0
853  };
854  },
855  getWithinInfo: function( element ) {
856  var withinElement = $( element || window ),
857  isWindow = $.isWindow( withinElement[ 0 ] ),
858  isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
859  hasOffset = !isWindow && !isDocument;
860  return {
861  element: withinElement,
862  isWindow: isWindow,
863  isDocument: isDocument,
864  offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
865  scrollLeft: withinElement.scrollLeft(),
866  scrollTop: withinElement.scrollTop(),
867  width: withinElement.outerWidth(),
868  height: withinElement.outerHeight()
869  };
870  }
871 };
872 
873 $.fn.position = function( options ) {
874  if ( !options || !options.of ) {
875  return _position.apply( this, arguments );
876  }
877 
878  // Make a copy, we don't want to modify arguments
879  options = $.extend( {}, options );
880 
881  var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
882  target = $( options.of ),
883  within = $.position.getWithinInfo( options.within ),
884  scrollInfo = $.position.getScrollInfo( within ),
885  collision = ( options.collision || "flip" ).split( " " ),
886  offsets = {};
887 
888  dimensions = getDimensions( target );
889  if ( target[ 0 ].preventDefault ) {
890 
891  // Force left top to allow flipping
892  options.at = "left top";
893  }
894  targetWidth = dimensions.width;
895  targetHeight = dimensions.height;
896  targetOffset = dimensions.offset;
897 
898  // Clone to reuse original targetOffset later
899  basePosition = $.extend( {}, targetOffset );
900 
901  // Force my and at to have valid horizontal and vertical positions
902  // if a value is missing or invalid, it will be converted to center
903  $.each( [ "my", "at" ], function() {
904  var pos = ( options[ this ] || "" ).split( " " ),
905  horizontalOffset,
906  verticalOffset;
907 
908  if ( pos.length === 1 ) {
909  pos = rhorizontal.test( pos[ 0 ] ) ?
910  pos.concat( [ "center" ] ) :
911  rvertical.test( pos[ 0 ] ) ?
912  [ "center" ].concat( pos ) :
913  [ "center", "center" ];
914  }
915  pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
916  pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
917 
918  // Calculate offsets
919  horizontalOffset = roffset.exec( pos[ 0 ] );
920  verticalOffset = roffset.exec( pos[ 1 ] );
921  offsets[ this ] = [
922  horizontalOffset ? horizontalOffset[ 0 ] : 0,
923  verticalOffset ? verticalOffset[ 0 ] : 0
924  ];
925 
926  // Reduce to just the positions without the offsets
927  options[ this ] = [
928  rposition.exec( pos[ 0 ] )[ 0 ],
929  rposition.exec( pos[ 1 ] )[ 0 ]
930  ];
931  } );
932 
933  // Normalize collision option
934  if ( collision.length === 1 ) {
935  collision[ 1 ] = collision[ 0 ];
936  }
937 
938  if ( options.at[ 0 ] === "right" ) {
939  basePosition.left += targetWidth;
940  } else if ( options.at[ 0 ] === "center" ) {
941  basePosition.left += targetWidth / 2;
942  }
943 
944  if ( options.at[ 1 ] === "bottom" ) {
945  basePosition.top += targetHeight;
946  } else if ( options.at[ 1 ] === "center" ) {
947  basePosition.top += targetHeight / 2;
948  }
949 
950  atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
951  basePosition.left += atOffset[ 0 ];
952  basePosition.top += atOffset[ 1 ];
953 
954  return this.each( function() {
955  var collisionPosition, using,
956  elem = $( this ),
957  elemWidth = elem.outerWidth(),
958  elemHeight = elem.outerHeight(),
959  marginLeft = parseCss( this, "marginLeft" ),
960  marginTop = parseCss( this, "marginTop" ),
961  collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
962  scrollInfo.width,
963  collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
964  scrollInfo.height,
965  position = $.extend( {}, basePosition ),
966  myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
967 
968  if ( options.my[ 0 ] === "right" ) {
969  position.left -= elemWidth;
970  } else if ( options.my[ 0 ] === "center" ) {
971  position.left -= elemWidth / 2;
972  }
973 
974  if ( options.my[ 1 ] === "bottom" ) {
975  position.top -= elemHeight;
976  } else if ( options.my[ 1 ] === "center" ) {
977  position.top -= elemHeight / 2;
978  }
979 
980  position.left += myOffset[ 0 ];
981  position.top += myOffset[ 1 ];
982 
983  collisionPosition = {
984  marginLeft: marginLeft,
985  marginTop: marginTop
986  };
987 
988  $.each( [ "left", "top" ], function( i, dir ) {
989  if ( $.ui.position[ collision[ i ] ] ) {
990  $.ui.position[ collision[ i ] ][ dir ]( position, {
991  targetWidth: targetWidth,
992  targetHeight: targetHeight,
993  elemWidth: elemWidth,
994  elemHeight: elemHeight,
995  collisionPosition: collisionPosition,
996  collisionWidth: collisionWidth,
997  collisionHeight: collisionHeight,
998  offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
999  my: options.my,
1000  at: options.at,
1001  within: within,
1002  elem: elem
1003  } );
1004  }
1005  } );
1006 
1007  if ( options.using ) {
1008 
1009  // Adds feedback as second argument to using callback, if present
1010  using = function( props ) {
1011  var left = targetOffset.left - position.left,
1012  right = left + targetWidth - elemWidth,
1013  top = targetOffset.top - position.top,
1014  bottom = top + targetHeight - elemHeight,
1015  feedback = {
1016  target: {
1017  element: target,
1018  left: targetOffset.left,
1019  top: targetOffset.top,
1020  width: targetWidth,
1021  height: targetHeight
1022  },
1023  element: {
1024  element: elem,
1025  left: position.left,
1026  top: position.top,
1027  width: elemWidth,
1028  height: elemHeight
1029  },
1030  horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1031  vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1032  };
1033  if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1034  feedback.horizontal = "center";
1035  }
1036  if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1037  feedback.vertical = "middle";
1038  }
1039  if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1040  feedback.important = "horizontal";
1041  } else {
1042  feedback.important = "vertical";
1043  }
1044  options.using.call( this, props, feedback );
1045  };
1046  }
1047 
1048  elem.offset( $.extend( position, { using: using } ) );
1049  } );
1050 };
1051 
1052 $.ui.position = {
1053  fit: {
1054  left: function( position, data ) {
1055  var within = data.within,
1056  withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1057  outerWidth = within.width,
1058  collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1059  overLeft = withinOffset - collisionPosLeft,
1060  overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1061  newOverRight;
1062 
1063  // Element is wider than within
1064  if ( data.collisionWidth > outerWidth ) {
1065 
1066  // Element is initially over the left side of within
1067  if ( overLeft > 0 && overRight <= 0 ) {
1068  newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
1069  withinOffset;
1070  position.left += overLeft - newOverRight;
1071 
1072  // Element is initially over right side of within
1073  } else if ( overRight > 0 && overLeft <= 0 ) {
1074  position.left = withinOffset;
1075 
1076  // Element is initially over both left and right sides of within
1077  } else {
1078  if ( overLeft > overRight ) {
1079  position.left = withinOffset + outerWidth - data.collisionWidth;
1080  } else {
1081  position.left = withinOffset;
1082  }
1083  }
1084 
1085  // Too far left -> align with left edge
1086  } else if ( overLeft > 0 ) {
1087  position.left += overLeft;
1088 
1089  // Too far right -> align with right edge
1090  } else if ( overRight > 0 ) {
1091  position.left -= overRight;
1092 
1093  // Adjust based on position and margin
1094  } else {
1095  position.left = max( position.left - collisionPosLeft, position.left );
1096  }
1097  },
1098  top: function( position, data ) {
1099  var within = data.within,
1100  withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1101  outerHeight = data.within.height,
1102  collisionPosTop = position.top - data.collisionPosition.marginTop,
1103  overTop = withinOffset - collisionPosTop,
1104  overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1105  newOverBottom;
1106 
1107  // Element is taller than within
1108  if ( data.collisionHeight > outerHeight ) {
1109 
1110  // Element is initially over the top of within
1111  if ( overTop > 0 && overBottom <= 0 ) {
1112  newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
1113  withinOffset;
1114  position.top += overTop - newOverBottom;
1115 
1116  // Element is initially over bottom of within
1117  } else if ( overBottom > 0 && overTop <= 0 ) {
1118  position.top = withinOffset;
1119 
1120  // Element is initially over both top and bottom of within
1121  } else {
1122  if ( overTop > overBottom ) {
1123  position.top = withinOffset + outerHeight - data.collisionHeight;
1124  } else {
1125  position.top = withinOffset;
1126  }
1127  }
1128 
1129  // Too far up -> align with top
1130  } else if ( overTop > 0 ) {
1131  position.top += overTop;
1132 
1133  // Too far down -> align with bottom edge
1134  } else if ( overBottom > 0 ) {
1135  position.top -= overBottom;
1136 
1137  // Adjust based on position and margin
1138  } else {
1139  position.top = max( position.top - collisionPosTop, position.top );
1140  }
1141  }
1142  },
1143  flip: {
1144  left: function( position, data ) {
1145  var within = data.within,
1146  withinOffset = within.offset.left + within.scrollLeft,
1147  outerWidth = within.width,
1148  offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1149  collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1150  overLeft = collisionPosLeft - offsetLeft,
1151  overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1152  myOffset = data.my[ 0 ] === "left" ?
1153  -data.elemWidth :
1154  data.my[ 0 ] === "right" ?
1155  data.elemWidth :
1156  0,
1157  atOffset = data.at[ 0 ] === "left" ?
1158  data.targetWidth :
1159  data.at[ 0 ] === "right" ?
1160  -data.targetWidth :
1161  0,
1162  offset = -2 * data.offset[ 0 ],
1163  newOverRight,
1164  newOverLeft;
1165 
1166  if ( overLeft < 0 ) {
1167  newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
1168  outerWidth - withinOffset;
1169  if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1170  position.left += myOffset + atOffset + offset;
1171  }
1172  } else if ( overRight > 0 ) {
1173  newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
1174  atOffset + offset - offsetLeft;
1175  if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1176  position.left += myOffset + atOffset + offset;
1177  }
1178  }
1179  },
1180  top: function( position, data ) {
1181  var within = data.within,
1182  withinOffset = within.offset.top + within.scrollTop,
1183  outerHeight = within.height,
1184  offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1185  collisionPosTop = position.top - data.collisionPosition.marginTop,
1186  overTop = collisionPosTop - offsetTop,
1187  overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1188  top = data.my[ 1 ] === "top",
1189  myOffset = top ?
1190  -data.elemHeight :
1191  data.my[ 1 ] === "bottom" ?
1192  data.elemHeight :
1193  0,
1194  atOffset = data.at[ 1 ] === "top" ?
1195  data.targetHeight :
1196  data.at[ 1 ] === "bottom" ?
1197  -data.targetHeight :
1198  0,
1199  offset = -2 * data.offset[ 1 ],
1200  newOverTop,
1201  newOverBottom;
1202  if ( overTop < 0 ) {
1203  newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
1204  outerHeight - withinOffset;
1205  if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1206  position.top += myOffset + atOffset + offset;
1207  }
1208  } else if ( overBottom > 0 ) {
1209  newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
1210  offset - offsetTop;
1211  if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1212  position.top += myOffset + atOffset + offset;
1213  }
1214  }
1215  }
1216  },
1217  flipfit: {
1218  left: function() {
1219  $.ui.position.flip.left.apply( this, arguments );
1220  $.ui.position.fit.left.apply( this, arguments );
1221  },
1222  top: function() {
1223  $.ui.position.flip.top.apply( this, arguments );
1224  $.ui.position.fit.top.apply( this, arguments );
1225  }
1226  }
1227 };
1228 
1229 } )();
1230 
1231 var position = $.ui.position;
1232 
1233 
1234 /*!
1235  * jQuery UI :data 1.12.1
1236  * http://jqueryui.com
1237  *
1238  * Copyright jQuery Foundation and other contributors
1239  * Released under the MIT license.
1240  * http://jquery.org/license
1241  */
1242 
1243 //>>label: :data Selector
1244 //>>group: Core
1245 //>>description: Selects elements which have data stored under the specified key.
1246 //>>docs: http://api.jqueryui.com/data-selector/
1247 
1248 
1249 var data = $.extend( $.expr[ ":" ], {
1250  data: $.expr.createPseudo ?
1251  $.expr.createPseudo( function( dataName ) {
1252  return function( elem ) {
1253  return !!$.data( elem, dataName );
1254  };
1255  } ) :
1256 
1257  // Support: jQuery <1.8
1258  function( elem, i, match ) {
1259  return !!$.data( elem, match[ 3 ] );
1260  }
1261 } );
1262 
1263 /*!
1264  * jQuery UI Disable Selection 1.12.1
1265  * http://jqueryui.com
1266  *
1267  * Copyright jQuery Foundation and other contributors
1268  * Released under the MIT license.
1269  * http://jquery.org/license
1270  */
1271 
1272 //>>label: disableSelection
1273 //>>group: Core
1274 //>>description: Disable selection of text content within the set of matched elements.
1275 //>>docs: http://api.jqueryui.com/disableSelection/
1276 
1277 // This file is deprecated
1278 
1279 
1280 var disableSelection = $.fn.extend( {
1281  disableSelection: ( function() {
1282  var eventType = "onselectstart" in document.createElement( "div" ) ?
1283  "selectstart" :
1284  "mousedown";
1285 
1286  return function() {
1287  return this.on( eventType + ".ui-disableSelection", function( event ) {
1288  event.preventDefault();
1289  } );
1290  };
1291  } )(),
1292 
1293  enableSelection: function() {
1294  return this.off( ".ui-disableSelection" );
1295  }
1296 } );
1297 
1298 
1299 /*!
1300  * jQuery UI Effects 1.12.1
1301  * http://jqueryui.com
1302  *
1303  * Copyright jQuery Foundation and other contributors
1304  * Released under the MIT license.
1305  * http://jquery.org/license
1306  */
1307 
1308 //>>label: Effects Core
1309 //>>group: Effects
1310 // jscs:disable maximumLineLength
1311 //>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.
1312 // jscs:enable maximumLineLength
1313 //>>docs: http://api.jqueryui.com/category/effects-core/
1314 //>>demos: http://jqueryui.com/effect/
1315 
1316 
1317 
1318 var dataSpace = "ui-effects-",
1319  dataSpaceStyle = "ui-effects-style",
1320  dataSpaceAnimated = "ui-effects-animated",
1321 
1322  // Create a local jQuery because jQuery Color relies on it and the
1323  // global may not exist with AMD and a custom build (#10199)
1324  jQuery = $;
1325 
1326 $.effects = {
1327  effect: {}
1328 };
1329 
1330 /*!
1331  * jQuery Color Animations v2.1.2
1332  * https://github.com/jquery/jquery-color
1333  *
1334  * Copyright 2014 jQuery Foundation and other contributors
1335  * Released under the MIT license.
1336  * http://jquery.org/license
1337  *
1338  * Date: Wed Jan 16 08:47:09 2013 -0600
1339  */
1340 ( function( jQuery, undefined ) {
1341 
1342  var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor " +
1343  "borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
1344 
1345  // Plusequals test for += 100 -= 100
1346  rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
1347 
1348  // A set of RE's that can match strings and generate color tuples.
1349  stringParsers = [ {
1350  re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1351  parse: function( execResult ) {
1352  return [
1353  execResult[ 1 ],
1354  execResult[ 2 ],
1355  execResult[ 3 ],
1356  execResult[ 4 ]
1357  ];
1358  }
1359  }, {
1360  re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1361  parse: function( execResult ) {
1362  return [
1363  execResult[ 1 ] * 2.55,
1364  execResult[ 2 ] * 2.55,
1365  execResult[ 3 ] * 2.55,
1366  execResult[ 4 ]
1367  ];
1368  }
1369  }, {
1370 
1371  // This regex ignores A-F because it's compared against an already lowercased string
1372  re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
1373  parse: function( execResult ) {
1374  return [
1375  parseInt( execResult[ 1 ], 16 ),
1376  parseInt( execResult[ 2 ], 16 ),
1377  parseInt( execResult[ 3 ], 16 )
1378  ];
1379  }
1380  }, {
1381 
1382  // This regex ignores A-F because it's compared against an already lowercased string
1383  re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
1384  parse: function( execResult ) {
1385  return [
1386  parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
1387  parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
1388  parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
1389  ];
1390  }
1391  }, {
1392  re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
1393  space: "hsla",
1394  parse: function( execResult ) {
1395  return [
1396  execResult[ 1 ],
1397  execResult[ 2 ] / 100,
1398  execResult[ 3 ] / 100,
1399  execResult[ 4 ]
1400  ];
1401  }
1402  } ],
1403 
1404  // JQuery.Color( )
1405  color = jQuery.Color = function( color, green, blue, alpha ) {
1406  return new jQuery.Color.fn.parse( color, green, blue, alpha );
1407  },
1408  spaces = {
1409  rgba: {
1410  props: {
1411  red: {
1412  idx: 0,
1413  type: "byte"
1414  },
1415  green: {
1416  idx: 1,
1417  type: "byte"
1418  },
1419  blue: {
1420  idx: 2,
1421  type: "byte"
1422  }
1423  }
1424  },
1425 
1426  hsla: {
1427  props: {
1428  hue: {
1429  idx: 0,
1430  type: "degrees"
1431  },
1432  saturation: {
1433  idx: 1,
1434  type: "percent"
1435  },
1436  lightness: {
1437  idx: 2,
1438  type: "percent"
1439  }
1440  }
1441  }
1442  },
1443  propTypes = {
1444  "byte": {
1445  floor: true,
1446  max: 255
1447  },
1448  "percent": {
1449  max: 1
1450  },
1451  "degrees": {
1452  mod: 360,
1453  floor: true
1454  }
1455  },
1456  support = color.support = {},
1457 
1458  // Element for support tests
1459  supportElem = jQuery( "<p>" )[ 0 ],
1460 
1461  // Colors = jQuery.Color.names
1462  colors,
1463 
1464  // Local aliases of functions called often
1465  each = jQuery.each;
1466 
1467 // Determine rgba support immediately
1468 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
1469 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
1470 
1471 // Define cache name and alpha properties
1472 // for rgba and hsla spaces
1473 each( spaces, function( spaceName, space ) {
1474  space.cache = "_" + spaceName;
1475  space.props.alpha = {
1476  idx: 3,
1477  type: "percent",
1478  def: 1
1479  };
1480 } );
1481 
1482 function clamp( value, prop, allowEmpty ) {
1483  var type = propTypes[ prop.type ] || {};
1484 
1485  if ( value == null ) {
1486  return ( allowEmpty || !prop.def ) ? null : prop.def;
1487  }
1488 
1489  // ~~ is an short way of doing floor for positive numbers
1490  value = type.floor ? ~~value : parseFloat( value );
1491 
1492  // IE will pass in empty strings as value for alpha,
1493  // which will hit this case
1494  if ( isNaN( value ) ) {
1495  return prop.def;
1496  }
1497 
1498  if ( type.mod ) {
1499 
1500  // We add mod before modding to make sure that negatives values
1501  // get converted properly: -10 -> 350
1502  return ( value + type.mod ) % type.mod;
1503  }
1504 
1505  // For now all property types without mod have min and max
1506  return 0 > value ? 0 : type.max < value ? type.max : value;
1507 }
1508 
1509 function stringParse( string ) {
1510  var inst = color(),
1511  rgba = inst._rgba = [];
1512 
1513  string = string.toLowerCase();
1514 
1515  each( stringParsers, function( i, parser ) {
1516  var parsed,
1517  match = parser.re.exec( string ),
1518  values = match && parser.parse( match ),
1519  spaceName = parser.space || "rgba";
1520 
1521  if ( values ) {
1522  parsed = inst[ spaceName ]( values );
1523 
1524  // If this was an rgba parse the assignment might happen twice
1525  // oh well....
1526  inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
1527  rgba = inst._rgba = parsed._rgba;
1528 
1529  // Exit each( stringParsers ) here because we matched
1530  return false;
1531  }
1532  } );
1533 
1534  // Found a stringParser that handled it
1535  if ( rgba.length ) {
1536 
1537  // If this came from a parsed string, force "transparent" when alpha is 0
1538  // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
1539  if ( rgba.join() === "0,0,0,0" ) {
1540  jQuery.extend( rgba, colors.transparent );
1541  }
1542  return inst;
1543  }
1544 
1545  // Named colors
1546  return colors[ string ];
1547 }
1548 
1549 color.fn = jQuery.extend( color.prototype, {
1550  parse: function( red, green, blue, alpha ) {
1551  if ( red === undefined ) {
1552  this._rgba = [ null, null, null, null ];
1553  return this;
1554  }
1555  if ( red.jquery || red.nodeType ) {
1556  red = jQuery( red ).css( green );
1557  green = undefined;
1558  }
1559 
1560  var inst = this,
1561  type = jQuery.type( red ),
1562  rgba = this._rgba = [];
1563 
1564  // More than 1 argument specified - assume ( red, green, blue, alpha )
1565  if ( green !== undefined ) {
1566  red = [ red, green, blue, alpha ];
1567  type = "array";
1568  }
1569 
1570  if ( type === "string" ) {
1571  return this.parse( stringParse( red ) || colors._default );
1572  }
1573 
1574  if ( type === "array" ) {
1575  each( spaces.rgba.props, function( key, prop ) {
1576  rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
1577  } );
1578  return this;
1579  }
1580 
1581  if ( type === "object" ) {
1582  if ( red instanceof color ) {
1583  each( spaces, function( spaceName, space ) {
1584  if ( red[ space.cache ] ) {
1585  inst[ space.cache ] = red[ space.cache ].slice();
1586  }
1587  } );
1588  } else {
1589  each( spaces, function( spaceName, space ) {
1590  var cache = space.cache;
1591  each( space.props, function( key, prop ) {
1592 
1593  // If the cache doesn't exist, and we know how to convert
1594  if ( !inst[ cache ] && space.to ) {
1595 
1596  // If the value was null, we don't need to copy it
1597  // if the key was alpha, we don't need to copy it either
1598  if ( key === "alpha" || red[ key ] == null ) {
1599  return;
1600  }
1601  inst[ cache ] = space.to( inst._rgba );
1602  }
1603 
1604  // This is the only case where we allow nulls for ALL properties.
1605  // call clamp with alwaysAllowEmpty
1606  inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
1607  } );
1608 
1609  // Everything defined but alpha?
1610  if ( inst[ cache ] &&
1611  jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
1612 
1613  // Use the default of 1
1614  inst[ cache ][ 3 ] = 1;
1615  if ( space.from ) {
1616  inst._rgba = space.from( inst[ cache ] );
1617  }
1618  }
1619  } );
1620  }
1621  return this;
1622  }
1623  },
1624  is: function( compare ) {
1625  var is = color( compare ),
1626  same = true,
1627  inst = this;
1628 
1629  each( spaces, function( _, space ) {
1630  var localCache,
1631  isCache = is[ space.cache ];
1632  if ( isCache ) {
1633  localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
1634  each( space.props, function( _, prop ) {
1635  if ( isCache[ prop.idx ] != null ) {
1636  same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
1637  return same;
1638  }
1639  } );
1640  }
1641  return same;
1642  } );
1643  return same;
1644  },
1645  _space: function() {
1646  var used = [],
1647  inst = this;
1648  each( spaces, function( spaceName, space ) {
1649  if ( inst[ space.cache ] ) {
1650  used.push( spaceName );
1651  }
1652  } );
1653  return used.pop();
1654  },
1655  transition: function( other, distance ) {
1656  var end = color( other ),
1657  spaceName = end._space(),
1658  space = spaces[ spaceName ],
1659  startColor = this.alpha() === 0 ? color( "transparent" ) : this,
1660  start = startColor[ space.cache ] || space.to( startColor._rgba ),
1661  result = start.slice();
1662 
1663  end = end[ space.cache ];
1664  each( space.props, function( key, prop ) {
1665  var index = prop.idx,
1666  startValue = start[ index ],
1667  endValue = end[ index ],
1668  type = propTypes[ prop.type ] || {};
1669 
1670  // If null, don't override start value
1671  if ( endValue === null ) {
1672  return;
1673  }
1674 
1675  // If null - use end
1676  if ( startValue === null ) {
1677  result[ index ] = endValue;
1678  } else {
1679  if ( type.mod ) {
1680  if ( endValue - startValue > type.mod / 2 ) {
1681  startValue += type.mod;
1682  } else if ( startValue - endValue > type.mod / 2 ) {
1683  startValue -= type.mod;
1684  }
1685  }
1686  result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
1687  }
1688  } );
1689  return this[ spaceName ]( result );
1690  },
1691  blend: function( opaque ) {
1692 
1693  // If we are already opaque - return ourself
1694  if ( this._rgba[ 3 ] === 1 ) {
1695  return this;
1696  }
1697 
1698  var rgb = this._rgba.slice(),
1699  a = rgb.pop(),
1700  blend = color( opaque )._rgba;
1701 
1702  return color( jQuery.map( rgb, function( v, i ) {
1703  return ( 1 - a ) * blend[ i ] + a * v;
1704  } ) );
1705  },
1706  toRgbaString: function() {
1707  var prefix = "rgba(",
1708  rgba = jQuery.map( this._rgba, function( v, i ) {
1709  return v == null ? ( i > 2 ? 1 : 0 ) : v;
1710  } );
1711 
1712  if ( rgba[ 3 ] === 1 ) {
1713  rgba.pop();
1714  prefix = "rgb(";
1715  }
1716 
1717  return prefix + rgba.join() + ")";
1718  },
1719  toHslaString: function() {
1720  var prefix = "hsla(",
1721  hsla = jQuery.map( this.hsla(), function( v, i ) {
1722  if ( v == null ) {
1723  v = i > 2 ? 1 : 0;
1724  }
1725 
1726  // Catch 1 and 2
1727  if ( i && i < 3 ) {
1728  v = Math.round( v * 100 ) + "%";
1729  }
1730  return v;
1731  } );
1732 
1733  if ( hsla[ 3 ] === 1 ) {
1734  hsla.pop();
1735  prefix = "hsl(";
1736  }
1737  return prefix + hsla.join() + ")";
1738  },
1739  toHexString: function( includeAlpha ) {
1740  var rgba = this._rgba.slice(),
1741  alpha = rgba.pop();
1742 
1743  if ( includeAlpha ) {
1744  rgba.push( ~~( alpha * 255 ) );
1745  }
1746 
1747  return "#" + jQuery.map( rgba, function( v ) {
1748 
1749  // Default to 0 when nulls exist
1750  v = ( v || 0 ).toString( 16 );
1751  return v.length === 1 ? "0" + v : v;
1752  } ).join( "" );
1753  },
1754  toString: function() {
1755  return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
1756  }
1757 } );
1758 color.fn.parse.prototype = color.fn;
1759 
1760 // Hsla conversions adapted from:
1761 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
1762 
1763 function hue2rgb( p, q, h ) {
1764  h = ( h + 1 ) % 1;
1765  if ( h * 6 < 1 ) {
1766  return p + ( q - p ) * h * 6;
1767  }
1768  if ( h * 2 < 1 ) {
1769  return q;
1770  }
1771  if ( h * 3 < 2 ) {
1772  return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
1773  }
1774  return p;
1775 }
1776 
1777 spaces.hsla.to = function( rgba ) {
1778  if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
1779  return [ null, null, null, rgba[ 3 ] ];
1780  }
1781  var r = rgba[ 0 ] / 255,
1782  g = rgba[ 1 ] / 255,
1783  b = rgba[ 2 ] / 255,
1784  a = rgba[ 3 ],
1785  max = Math.max( r, g, b ),
1786  min = Math.min( r, g, b ),
1787  diff = max - min,
1788  add = max + min,
1789  l = add * 0.5,
1790  h, s;
1791 
1792  if ( min === max ) {
1793  h = 0;
1794  } else if ( r === max ) {
1795  h = ( 60 * ( g - b ) / diff ) + 360;
1796  } else if ( g === max ) {
1797  h = ( 60 * ( b - r ) / diff ) + 120;
1798  } else {
1799  h = ( 60 * ( r - g ) / diff ) + 240;
1800  }
1801 
1802  // Chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
1803  // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
1804  if ( diff === 0 ) {
1805  s = 0;
1806  } else if ( l <= 0.5 ) {
1807  s = diff / add;
1808  } else {
1809  s = diff / ( 2 - add );
1810  }
1811  return [ Math.round( h ) % 360, s, l, a == null ? 1 : a ];
1812 };
1813 
1814 spaces.hsla.from = function( hsla ) {
1815  if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
1816  return [ null, null, null, hsla[ 3 ] ];
1817  }
1818  var h = hsla[ 0 ] / 360,
1819  s = hsla[ 1 ],
1820  l = hsla[ 2 ],
1821  a = hsla[ 3 ],
1822  q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
1823  p = 2 * l - q;
1824 
1825  return [
1826  Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
1827  Math.round( hue2rgb( p, q, h ) * 255 ),
1828  Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
1829  a
1830  ];
1831 };
1832 
1833 each( spaces, function( spaceName, space ) {
1834  var props = space.props,
1835  cache = space.cache,
1836  to = space.to,
1837  from = space.from;
1838 
1839  // Makes rgba() and hsla()
1840  color.fn[ spaceName ] = function( value ) {
1841 
1842  // Generate a cache for this space if it doesn't exist
1843  if ( to && !this[ cache ] ) {
1844  this[ cache ] = to( this._rgba );
1845  }
1846  if ( value === undefined ) {
1847  return this[ cache ].slice();
1848  }
1849 
1850  var ret,
1851  type = jQuery.type( value ),
1852  arr = ( type === "array" || type === "object" ) ? value : arguments,
1853  local = this[ cache ].slice();
1854 
1855  each( props, function( key, prop ) {
1856  var val = arr[ type === "object" ? key : prop.idx ];
1857  if ( val == null ) {
1858  val = local[ prop.idx ];
1859  }
1860  local[ prop.idx ] = clamp( val, prop );
1861  } );
1862 
1863  if ( from ) {
1864  ret = color( from( local ) );
1865  ret[ cache ] = local;
1866  return ret;
1867  } else {
1868  return color( local );
1869  }
1870  };
1871 
1872  // Makes red() green() blue() alpha() hue() saturation() lightness()
1873  each( props, function( key, prop ) {
1874 
1875  // Alpha is included in more than one space
1876  if ( color.fn[ key ] ) {
1877  return;
1878  }
1879  color.fn[ key ] = function( value ) {
1880  var vtype = jQuery.type( value ),
1881  fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
1882  local = this[ fn ](),
1883  cur = local[ prop.idx ],
1884  match;
1885 
1886  if ( vtype === "undefined" ) {
1887  return cur;
1888  }
1889 
1890  if ( vtype === "function" ) {
1891  value = value.call( this, cur );
1892  vtype = jQuery.type( value );
1893  }
1894  if ( value == null && prop.empty ) {
1895  return this;
1896  }
1897  if ( vtype === "string" ) {
1898  match = rplusequals.exec( value );
1899  if ( match ) {
1900  value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
1901  }
1902  }
1903  local[ prop.idx ] = value;
1904  return this[ fn ]( local );
1905  };
1906  } );
1907 } );
1908 
1909 // Add cssHook and .fx.step function for each named hook.
1910 // accept a space separated string of properties
1911 color.hook = function( hook ) {
1912  var hooks = hook.split( " " );
1913  each( hooks, function( i, hook ) {
1914  jQuery.cssHooks[ hook ] = {
1915  set: function( elem, value ) {
1916  var parsed, curElem,
1917  backgroundColor = "";
1918 
1919  if ( value !== "transparent" && ( jQuery.type( value ) !== "string" ||
1920  ( parsed = stringParse( value ) ) ) ) {
1921  value = color( parsed || value );
1922  if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
1923  curElem = hook === "backgroundColor" ? elem.parentNode : elem;
1924  while (
1925  ( backgroundColor === "" || backgroundColor === "transparent" ) &&
1926  curElem && curElem.style
1927  ) {
1928  try {
1929  backgroundColor = jQuery.css( curElem, "backgroundColor" );
1930  curElem = curElem.parentNode;
1931  } catch ( e ) {
1932  }
1933  }
1934 
1935  value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
1936  backgroundColor :
1937  "_default" );
1938  }
1939 
1940  value = value.toRgbaString();
1941  }
1942  try {
1943  elem.style[ hook ] = value;
1944  } catch ( e ) {
1945 
1946  // Wrapped to prevent IE from throwing errors on "invalid" values like
1947  // 'auto' or 'inherit'
1948  }
1949  }
1950  };
1951  jQuery.fx.step[ hook ] = function( fx ) {
1952  if ( !fx.colorInit ) {
1953  fx.start = color( fx.elem, hook );
1954  fx.end = color( fx.end );
1955  fx.colorInit = true;
1956  }
1957  jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
1958  };
1959  } );
1960 
1961 };
1962 
1963 color.hook( stepHooks );
1964 
1965 jQuery.cssHooks.borderColor = {
1966  expand: function( value ) {
1967  var expanded = {};
1968 
1969  each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
1970  expanded[ "border" + part + "Color" ] = value;
1971  } );
1972  return expanded;
1973  }
1974 };
1975 
1976 // Basic color names only.
1977 // Usage of any of the other color names requires adding yourself or including
1978 // jquery.color.svg-names.js.
1979 colors = jQuery.Color.names = {
1980 
1981  // 4.1. Basic color keywords
1982  aqua: "#00ffff",
1983  black: "#000000",
1984  blue: "#0000ff",
1985  fuchsia: "#ff00ff",
1986  gray: "#808080",
1987  green: "#008000",
1988  lime: "#00ff00",
1989  maroon: "#800000",
1990  navy: "#000080",
1991  olive: "#808000",
1992  purple: "#800080",
1993  red: "#ff0000",
1994  silver: "#c0c0c0",
1995  teal: "#008080",
1996  white: "#ffffff",
1997  yellow: "#ffff00",
1998 
1999  // 4.2.3. "transparent" color keyword
2000  transparent: [ null, null, null, 0 ],
2001 
2002  _default: "#ffffff"
2003 };
2004 
2005 } )( jQuery );
2006 
2007 /******************************************************************************/
2008 /****************************** CLASS ANIMATIONS ******************************/
2009 /******************************************************************************/
2010 ( function() {
2011 
2012 var classAnimationActions = [ "add", "remove", "toggle" ],
2013  shorthandStyles = {
2014  border: 1,
2015  borderBottom: 1,
2016  borderColor: 1,
2017  borderLeft: 1,
2018  borderRight: 1,
2019  borderTop: 1,
2020  borderWidth: 1,
2021  margin: 1,
2022  padding: 1
2023  };
2024 
2025 $.each(
2026  [ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ],
2027  function( _, prop ) {
2028  $.fx.step[ prop ] = function( fx ) {
2029  if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
2030  jQuery.style( fx.elem, prop, fx.end );
2031  fx.setAttr = true;
2032  }
2033  };
2034  }
2035 );
2036 
2037 function getElementStyles( elem ) {
2038  var key, len,
2039  style = elem.ownerDocument.defaultView ?
2040  elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
2041  elem.currentStyle,
2042  styles = {};
2043 
2044  if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
2045  len = style.length;
2046  while ( len-- ) {
2047  key = style[ len ];
2048  if ( typeof style[ key ] === "string" ) {
2049  styles[ $.camelCase( key ) ] = style[ key ];
2050  }
2051  }
2052 
2053  // Support: Opera, IE <9
2054  } else {
2055  for ( key in style ) {
2056  if ( typeof style[ key ] === "string" ) {
2057  styles[ key ] = style[ key ];
2058  }
2059  }
2060  }
2061 
2062  return styles;
2063 }
2064 
2065 function styleDifference( oldStyle, newStyle ) {
2066  var diff = {},
2067  name, value;
2068 
2069  for ( name in newStyle ) {
2070  value = newStyle[ name ];
2071  if ( oldStyle[ name ] !== value ) {
2072  if ( !shorthandStyles[ name ] ) {
2073  if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
2074  diff[ name ] = value;
2075  }
2076  }
2077  }
2078  }
2079 
2080  return diff;
2081 }
2082 
2083 // Support: jQuery <1.8
2084 if ( !$.fn.addBack ) {
2085  $.fn.addBack = function( selector ) {
2086  return this.add( selector == null ?
2087  this.prevObject : this.prevObject.filter( selector )
2088  );
2089  };
2090 }
2091 
2092 $.effects.animateClass = function( value, duration, easing, callback ) {
2093  var o = $.speed( duration, easing, callback );
2094 
2095  return this.queue( function() {
2096  var animated = $( this ),
2097  baseClass = animated.attr( "class" ) || "",
2098  applyClassChange,
2099  allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
2100 
2101  // Map the animated objects to store the original styles.
2102  allAnimations = allAnimations.map( function() {
2103  var el = $( this );
2104  return {
2105  el: el,
2106  start: getElementStyles( this )
2107  };
2108  } );
2109 
2110  // Apply class change
2111  applyClassChange = function() {
2112  $.each( classAnimationActions, function( i, action ) {
2113  if ( value[ action ] ) {
2114  animated[ action + "Class" ]( value[ action ] );
2115  }
2116  } );
2117  };
2118  applyClassChange();
2119 
2120  // Map all animated objects again - calculate new styles and diff
2121  allAnimations = allAnimations.map( function() {
2122  this.end = getElementStyles( this.el[ 0 ] );
2123  this.diff = styleDifference( this.start, this.end );
2124  return this;
2125  } );
2126 
2127  // Apply original class
2128  animated.attr( "class", baseClass );
2129 
2130  // Map all animated objects again - this time collecting a promise
2131  allAnimations = allAnimations.map( function() {
2132  var styleInfo = this,
2133  dfd = $.Deferred(),
2134  opts = $.extend( {}, o, {
2135  queue: false,
2136  complete: function() {
2137  dfd.resolve( styleInfo );
2138  }
2139  } );
2140 
2141  this.el.animate( this.diff, opts );
2142  return dfd.promise();
2143  } );
2144 
2145  // Once all animations have completed:
2146  $.when.apply( $, allAnimations.get() ).done( function() {
2147 
2148  // Set the final class
2149  applyClassChange();
2150 
2151  // For each animated element,
2152  // clear all css properties that were animated
2153  $.each( arguments, function() {
2154  var el = this.el;
2155  $.each( this.diff, function( key ) {
2156  el.css( key, "" );
2157  } );
2158  } );
2159 
2160  // This is guarnteed to be there if you use jQuery.speed()
2161  // it also handles dequeuing the next anim...
2162  o.complete.call( animated[ 0 ] );
2163  } );
2164  } );
2165 };
2166 
2167 $.fn.extend( {
2168  addClass: ( function( orig ) {
2169  return function( classNames, speed, easing, callback ) {
2170  return speed ?
2171  $.effects.animateClass.call( this,
2172  { add: classNames }, speed, easing, callback ) :
2173  orig.apply( this, arguments );
2174  };
2175  } )( $.fn.addClass ),
2176 
2177  removeClass: ( function( orig ) {
2178  return function( classNames, speed, easing, callback ) {
2179  return arguments.length > 1 ?
2180  $.effects.animateClass.call( this,
2181  { remove: classNames }, speed, easing, callback ) :
2182  orig.apply( this, arguments );
2183  };
2184  } )( $.fn.removeClass ),
2185 
2186  toggleClass: ( function( orig ) {
2187  return function( classNames, force, speed, easing, callback ) {
2188  if ( typeof force === "boolean" || force === undefined ) {
2189  if ( !speed ) {
2190 
2191  // Without speed parameter
2192  return orig.apply( this, arguments );
2193  } else {
2194  return $.effects.animateClass.call( this,
2195  ( force ? { add: classNames } : { remove: classNames } ),
2196  speed, easing, callback );
2197  }
2198  } else {
2199 
2200  // Without force parameter
2201  return $.effects.animateClass.call( this,
2202  { toggle: classNames }, force, speed, easing );
2203  }
2204  };
2205  } )( $.fn.toggleClass ),
2206 
2207  switchClass: function( remove, add, speed, easing, callback ) {
2208  return $.effects.animateClass.call( this, {
2209  add: add,
2210  remove: remove
2211  }, speed, easing, callback );
2212  }
2213 } );
2214 
2215 } )();
2216 
2217 /******************************************************************************/
2218 /*********************************** EFFECTS **********************************/
2219 /******************************************************************************/
2220 
2221 ( function() {
2222 
2223 if ( $.expr && $.expr.filters && $.expr.filters.animated ) {
2224  $.expr.filters.animated = ( function( orig ) {
2225  return function( elem ) {
2226  return !!$( elem ).data( dataSpaceAnimated ) || orig( elem );
2227  };
2228  } )( $.expr.filters.animated );
2229 }
2230 
2231 if ( $.uiBackCompat !== false ) {
2232  $.extend( $.effects, {
2233 
2234  // Saves a set of properties in a data storage
2235  save: function( element, set ) {
2236  var i = 0, length = set.length;
2237  for ( ; i < length; i++ ) {
2238  if ( set[ i ] !== null ) {
2239  element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
2240  }
2241  }
2242  },
2243 
2244  // Restores a set of previously saved properties from a data storage
2245  restore: function( element, set ) {
2246  var val, i = 0, length = set.length;
2247  for ( ; i < length; i++ ) {
2248  if ( set[ i ] !== null ) {
2249  val = element.data( dataSpace + set[ i ] );
2250  element.css( set[ i ], val );
2251  }
2252  }
2253  },
2254 
2255  setMode: function( el, mode ) {
2256  if ( mode === "toggle" ) {
2257  mode = el.is( ":hidden" ) ? "show" : "hide";
2258  }
2259  return mode;
2260  },
2261 
2262  // Wraps the element around a wrapper that copies position properties
2263  createWrapper: function( element ) {
2264 
2265  // If the element is already wrapped, return it
2266  if ( element.parent().is( ".ui-effects-wrapper" ) ) {
2267  return element.parent();
2268  }
2269 
2270  // Wrap the element
2271  var props = {
2272  width: element.outerWidth( true ),
2273  height: element.outerHeight( true ),
2274  "float": element.css( "float" )
2275  },
2276  wrapper = $( "<div></div>" )
2277  .addClass( "ui-effects-wrapper" )
2278  .css( {
2279  fontSize: "100%",
2280  background: "transparent",
2281  border: "none",
2282  margin: 0,
2283  padding: 0
2284  } ),
2285 
2286  // Store the size in case width/height are defined in % - Fixes #5245
2287  size = {
2288  width: element.width(),
2289  height: element.height()
2290  },
2291  active = document.activeElement;
2292 
2293  // Support: Firefox
2294  // Firefox incorrectly exposes anonymous content
2295  // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
2296  try {
2297  active.id;
2298  } catch ( e ) {
2299  active = document.body;
2300  }
2301 
2302  element.wrap( wrapper );
2303 
2304  // Fixes #7595 - Elements lose focus when wrapped.
2305  if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
2306  $( active ).trigger( "focus" );
2307  }
2308 
2309  // Hotfix for jQuery 1.4 since some change in wrap() seems to actually
2310  // lose the reference to the wrapped element
2311  wrapper = element.parent();
2312 
2313  // Transfer positioning properties to the wrapper
2314  if ( element.css( "position" ) === "static" ) {
2315  wrapper.css( { position: "relative" } );
2316  element.css( { position: "relative" } );
2317  } else {
2318  $.extend( props, {
2319  position: element.css( "position" ),
2320  zIndex: element.css( "z-index" )
2321  } );
2322  $.each( [ "top", "left", "bottom", "right" ], function( i, pos ) {
2323  props[ pos ] = element.css( pos );
2324  if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
2325  props[ pos ] = "auto";
2326  }
2327  } );
2328  element.css( {
2329  position: "relative",
2330  top: 0,
2331  left: 0,
2332  right: "auto",
2333  bottom: "auto"
2334  } );
2335  }
2336  element.css( size );
2337 
2338  return wrapper.css( props ).show();
2339  },
2340 
2341  removeWrapper: function( element ) {
2342  var active = document.activeElement;
2343 
2344  if ( element.parent().is( ".ui-effects-wrapper" ) ) {
2345  element.parent().replaceWith( element );
2346 
2347  // Fixes #7595 - Elements lose focus when wrapped.
2348  if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
2349  $( active ).trigger( "focus" );
2350  }
2351  }
2352 
2353  return element;
2354  }
2355  } );
2356 }
2357 
2358 $.extend( $.effects, {
2359  version: "1.12.1",
2360 
2361  define: function( name, mode, effect ) {
2362  if ( !effect ) {
2363  effect = mode;
2364  mode = "effect";
2365  }
2366 
2367  $.effects.effect[ name ] = effect;
2368  $.effects.effect[ name ].mode = mode;
2369 
2370  return effect;
2371  },
2372 
2373  scaledDimensions: function( element, percent, direction ) {
2374  if ( percent === 0 ) {
2375  return {
2376  height: 0,
2377  width: 0,
2378  outerHeight: 0,
2379  outerWidth: 0
2380  };
2381  }
2382 
2383  var x = direction !== "horizontal" ? ( ( percent || 100 ) / 100 ) : 1,
2384  y = direction !== "vertical" ? ( ( percent || 100 ) / 100 ) : 1;
2385 
2386  return {
2387  height: element.height() * y,
2388  width: element.width() * x,
2389  outerHeight: element.outerHeight() * y,
2390  outerWidth: element.outerWidth() * x
2391  };
2392 
2393  },
2394 
2395  clipToBox: function( animation ) {
2396  return {
2397  width: animation.clip.right - animation.clip.left,
2398  height: animation.clip.bottom - animation.clip.top,
2399  left: animation.clip.left,
2400  top: animation.clip.top
2401  };
2402  },
2403 
2404  // Injects recently queued functions to be first in line (after "inprogress")
2405  unshift: function( element, queueLength, count ) {
2406  var queue = element.queue();
2407 
2408  if ( queueLength > 1 ) {
2409  queue.splice.apply( queue,
2410  [ 1, 0 ].concat( queue.splice( queueLength, count ) ) );
2411  }
2412  element.dequeue();
2413  },
2414 
2415  saveStyle: function( element ) {
2416  element.data( dataSpaceStyle, element[ 0 ].style.cssText );
2417  },
2418 
2419  restoreStyle: function( element ) {
2420  element[ 0 ].style.cssText = element.data( dataSpaceStyle ) || "";
2421  element.removeData( dataSpaceStyle );
2422  },
2423 
2424  mode: function( element, mode ) {
2425  var hidden = element.is( ":hidden" );
2426 
2427  if ( mode === "toggle" ) {
2428  mode = hidden ? "show" : "hide";
2429  }
2430  if ( hidden ? mode === "hide" : mode === "show" ) {
2431  mode = "none";
2432  }
2433  return mode;
2434  },
2435 
2436  // Translates a [top,left] array into a baseline value
2437  getBaseline: function( origin, original ) {
2438  var y, x;
2439 
2440  switch ( origin[ 0 ] ) {
2441  case "top":
2442  y = 0;
2443  break;
2444  case "middle":
2445  y = 0.5;
2446  break;
2447  case "bottom":
2448  y = 1;
2449  break;
2450  default:
2451  y = origin[ 0 ] / original.height;
2452  }
2453 
2454  switch ( origin[ 1 ] ) {
2455  case "left":
2456  x = 0;
2457  break;
2458  case "center":
2459  x = 0.5;
2460  break;
2461  case "right":
2462  x = 1;
2463  break;
2464  default:
2465  x = origin[ 1 ] / original.width;
2466  }
2467 
2468  return {
2469  x: x,
2470  y: y
2471  };
2472  },
2473 
2474  // Creates a placeholder element so that the original element can be made absolute
2475  createPlaceholder: function( element ) {
2476  var placeholder,
2477  cssPosition = element.css( "position" ),
2478  position = element.position();
2479 
2480  // Lock in margins first to account for form elements, which
2481  // will change margin if you explicitly set height
2482  // see: http://jsfiddle.net/JZSMt/3/ https://bugs.webkit.org/show_bug.cgi?id=107380
2483  // Support: Safari
2484  element.css( {
2485  marginTop: element.css( "marginTop" ),
2486  marginBottom: element.css( "marginBottom" ),
2487  marginLeft: element.css( "marginLeft" ),
2488  marginRight: element.css( "marginRight" )
2489  } )
2490  .outerWidth( element.outerWidth() )
2491  .outerHeight( element.outerHeight() );
2492 
2493  if ( /^(static|relative)/.test( cssPosition ) ) {
2494  cssPosition = "absolute";
2495 
2496  placeholder = $( "<" + element[ 0 ].nodeName + ">" ).insertAfter( element ).css( {
2497 
2498  // Convert inline to inline block to account for inline elements
2499  // that turn to inline block based on content (like img)
2500  display: /^(inline|ruby)/.test( element.css( "display" ) ) ?
2501  "inline-block" :
2502  "block",
2503  visibility: "hidden",
2504 
2505  // Margins need to be set to account for margin collapse
2506  marginTop: element.css( "marginTop" ),
2507  marginBottom: element.css( "marginBottom" ),
2508  marginLeft: element.css( "marginLeft" ),
2509  marginRight: element.css( "marginRight" ),
2510  "float": element.css( "float" )
2511  } )
2512  .outerWidth( element.outerWidth() )
2513  .outerHeight( element.outerHeight() )
2514  .addClass( "ui-effects-placeholder" );
2515 
2516  element.data( dataSpace + "placeholder", placeholder );
2517  }
2518 
2519  element.css( {
2520  position: cssPosition,
2521  left: position.left,
2522  top: position.top
2523  } );
2524 
2525  return placeholder;
2526  },
2527 
2528  removePlaceholder: function( element ) {
2529  var dataKey = dataSpace + "placeholder",
2530  placeholder = element.data( dataKey );
2531 
2532  if ( placeholder ) {
2533  placeholder.remove();
2534  element.removeData( dataKey );
2535  }
2536  },
2537 
2538  // Removes a placeholder if it exists and restores
2539  // properties that were modified during placeholder creation
2540  cleanUp: function( element ) {
2541  $.effects.restoreStyle( element );
2542  $.effects.removePlaceholder( element );
2543  },
2544 
2545  setTransition: function( element, list, factor, value ) {
2546  value = value || {};
2547  $.each( list, function( i, x ) {
2548  var unit = element.cssUnit( x );
2549  if ( unit[ 0 ] > 0 ) {
2550  value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
2551  }
2552  } );
2553  return value;
2554  }
2555 } );
2556 
2557 // Return an effect options object for the given parameters:
2558 function _normalizeArguments( effect, options, speed, callback ) {
2559 
2560  // Allow passing all options as the first parameter
2561  if ( $.isPlainObject( effect ) ) {
2562  options = effect;
2563  effect = effect.effect;
2564  }
2565 
2566  // Convert to an object
2567  effect = { effect: effect };
2568 
2569  // Catch (effect, null, ...)
2570  if ( options == null ) {
2571  options = {};
2572  }
2573 
2574  // Catch (effect, callback)
2575  if ( $.isFunction( options ) ) {
2576  callback = options;
2577  speed = null;
2578  options = {};
2579  }
2580 
2581  // Catch (effect, speed, ?)
2582  if ( typeof options === "number" || $.fx.speeds[ options ] ) {
2583  callback = speed;
2584  speed = options;
2585  options = {};
2586  }
2587 
2588  // Catch (effect, options, callback)
2589  if ( $.isFunction( speed ) ) {
2590  callback = speed;
2591  speed = null;
2592  }
2593 
2594  // Add options to effect
2595  if ( options ) {
2596  $.extend( effect, options );
2597  }
2598 
2599  speed = speed || options.duration;
2600  effect.duration = $.fx.off ? 0 :
2601  typeof speed === "number" ? speed :
2602  speed in $.fx.speeds ? $.fx.speeds[ speed ] :
2603  $.fx.speeds._default;
2604 
2605  effect.complete = callback || options.complete;
2606 
2607  return effect;
2608 }
2609 
2610 function standardAnimationOption( option ) {
2611 
2612  // Valid standard speeds (nothing, number, named speed)
2613  if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
2614  return true;
2615  }
2616 
2617  // Invalid strings - treat as "normal" speed
2618  if ( typeof option === "string" && !$.effects.effect[ option ] ) {
2619  return true;
2620  }
2621 
2622  // Complete callback
2623  if ( $.isFunction( option ) ) {
2624  return true;
2625  }
2626 
2627  // Options hash (but not naming an effect)
2628  if ( typeof option === "object" && !option.effect ) {
2629  return true;
2630  }
2631 
2632  // Didn't match any standard API
2633  return false;
2634 }
2635 
2636 $.fn.extend( {
2637  effect: function( /* effect, options, speed, callback */ ) {
2638  var args = _normalizeArguments.apply( this, arguments ),
2639  effectMethod = $.effects.effect[ args.effect ],
2640  defaultMode = effectMethod.mode,
2641  queue = args.queue,
2642  queueName = queue || "fx",
2643  complete = args.complete,
2644  mode = args.mode,
2645  modes = [],
2646  prefilter = function( next ) {
2647  var el = $( this ),
2648  normalizedMode = $.effects.mode( el, mode ) || defaultMode;
2649 
2650  // Sentinel for duck-punching the :animated psuedo-selector
2651  el.data( dataSpaceAnimated, true );
2652 
2653  // Save effect mode for later use,
2654  // we can't just call $.effects.mode again later,
2655  // as the .show() below destroys the initial state
2656  modes.push( normalizedMode );
2657 
2658  // See $.uiBackCompat inside of run() for removal of defaultMode in 1.13
2659  if ( defaultMode && ( normalizedMode === "show" ||
2660  ( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) {
2661  el.show();
2662  }
2663 
2664  if ( !defaultMode || normalizedMode !== "none" ) {
2665  $.effects.saveStyle( el );
2666  }
2667 
2668  if ( $.isFunction( next ) ) {
2669  next();
2670  }
2671  };
2672 
2673  if ( $.fx.off || !effectMethod ) {
2674 
2675  // Delegate to the original method (e.g., .show()) if possible
2676  if ( mode ) {
2677  return this[ mode ]( args.duration, complete );
2678  } else {
2679  return this.each( function() {
2680  if ( complete ) {
2681  complete.call( this );
2682  }
2683  } );
2684  }
2685  }
2686 
2687  function run( next ) {
2688  var elem = $( this );
2689 
2690  function cleanup() {
2691  elem.removeData( dataSpaceAnimated );
2692 
2693  $.effects.cleanUp( elem );
2694 
2695  if ( args.mode === "hide" ) {
2696  elem.hide();
2697  }
2698 
2699  done();
2700  }
2701 
2702  function done() {
2703  if ( $.isFunction( complete ) ) {
2704  complete.call( elem[ 0 ] );
2705  }
2706 
2707  if ( $.isFunction( next ) ) {
2708  next();
2709  }
2710  }
2711 
2712  // Override mode option on a per element basis,
2713  // as toggle can be either show or hide depending on element state
2714  args.mode = modes.shift();
2715 
2716  if ( $.uiBackCompat !== false && !defaultMode ) {
2717  if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
2718 
2719  // Call the core method to track "olddisplay" properly
2720  elem[ mode ]();
2721  done();
2722  } else {
2723  effectMethod.call( elem[ 0 ], args, done );
2724  }
2725  } else {
2726  if ( args.mode === "none" ) {
2727 
2728  // Call the core method to track "olddisplay" properly
2729  elem[ mode ]();
2730  done();
2731  } else {
2732  effectMethod.call( elem[ 0 ], args, cleanup );
2733  }
2734  }
2735  }
2736 
2737  // Run prefilter on all elements first to ensure that
2738  // any showing or hiding happens before placeholder creation,
2739  // which ensures that any layout changes are correctly captured.
2740  return queue === false ?
2741  this.each( prefilter ).each( run ) :
2742  this.queue( queueName, prefilter ).queue( queueName, run );
2743  },
2744 
2745  show: ( function( orig ) {
2746  return function( option ) {
2747  if ( standardAnimationOption( option ) ) {
2748  return orig.apply( this, arguments );
2749  } else {
2750  var args = _normalizeArguments.apply( this, arguments );
2751  args.mode = "show";
2752  return this.effect.call( this, args );
2753  }
2754  };
2755  } )( $.fn.show ),
2756 
2757  hide: ( function( orig ) {
2758  return function( option ) {
2759  if ( standardAnimationOption( option ) ) {
2760  return orig.apply( this, arguments );
2761  } else {
2762  var args = _normalizeArguments.apply( this, arguments );
2763  args.mode = "hide";
2764  return this.effect.call( this, args );
2765  }
2766  };
2767  } )( $.fn.hide ),
2768 
2769  toggle: ( function( orig ) {
2770  return function( option ) {
2771  if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
2772  return orig.apply( this, arguments );
2773  } else {
2774  var args = _normalizeArguments.apply( this, arguments );
2775  args.mode = "toggle";
2776  return this.effect.call( this, args );
2777  }
2778  };
2779  } )( $.fn.toggle ),
2780 
2781  cssUnit: function( key ) {
2782  var style = this.css( key ),
2783  val = [];
2784 
2785  $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
2786  if ( style.indexOf( unit ) > 0 ) {
2787  val = [ parseFloat( style ), unit ];
2788  }
2789  } );
2790  return val;
2791  },
2792 
2793  cssClip: function( clipObj ) {
2794  if ( clipObj ) {
2795  return this.css( "clip", "rect(" + clipObj.top + "px " + clipObj.right + "px " +
2796  clipObj.bottom + "px " + clipObj.left + "px)" );
2797  }
2798  return parseClip( this.css( "clip" ), this );
2799  },
2800 
2801  transfer: function( options, done ) {
2802  var element = $( this ),
2803  target = $( options.to ),
2804  targetFixed = target.css( "position" ) === "fixed",
2805  body = $( "body" ),
2806  fixTop = targetFixed ? body.scrollTop() : 0,
2807  fixLeft = targetFixed ? body.scrollLeft() : 0,
2808  endPosition = target.offset(),
2809  animation = {
2810  top: endPosition.top - fixTop,
2811  left: endPosition.left - fixLeft,
2812  height: target.innerHeight(),
2813  width: target.innerWidth()
2814  },
2815  startPosition = element.offset(),
2816  transfer = $( "<div class='ui-effects-transfer'></div>" )
2817  .appendTo( "body" )
2818  .addClass( options.className )
2819  .css( {
2820  top: startPosition.top - fixTop,
2821  left: startPosition.left - fixLeft,
2822  height: element.innerHeight(),
2823  width: element.innerWidth(),
2824  position: targetFixed ? "fixed" : "absolute"
2825  } )
2826  .animate( animation, options.duration, options.easing, function() {
2827  transfer.remove();
2828  if ( $.isFunction( done ) ) {
2829  done();
2830  }
2831  } );
2832  }
2833 } );
2834 
2835 function parseClip( str, element ) {
2836  var outerWidth = element.outerWidth(),
2837  outerHeight = element.outerHeight(),
2838  clipRegex = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/,
2839  values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ];
2840 
2841  return {
2842  top: parseFloat( values[ 1 ] ) || 0,
2843  right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ),
2844  bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ),
2845  left: parseFloat( values[ 4 ] ) || 0
2846  };
2847 }
2848 
2849 $.fx.step.clip = function( fx ) {
2850  if ( !fx.clipInit ) {
2851  fx.start = $( fx.elem ).cssClip();
2852  if ( typeof fx.end === "string" ) {
2853  fx.end = parseClip( fx.end, fx.elem );
2854  }
2855  fx.clipInit = true;
2856  }
2857 
2858  $( fx.elem ).cssClip( {
2859  top: fx.pos * ( fx.end.top - fx.start.top ) + fx.start.top,
2860  right: fx.pos * ( fx.end.right - fx.start.right ) + fx.start.right,
2861  bottom: fx.pos * ( fx.end.bottom - fx.start.bottom ) + fx.start.bottom,
2862  left: fx.pos * ( fx.end.left - fx.start.left ) + fx.start.left
2863  } );
2864 };
2865 
2866 } )();
2867 
2868 /******************************************************************************/
2869 /*********************************** EASING ***********************************/
2870 /******************************************************************************/
2871 
2872 ( function() {
2873 
2874 // Based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
2875 
2876 var baseEasings = {};
2877 
2878 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
2879  baseEasings[ name ] = function( p ) {
2880  return Math.pow( p, i + 2 );
2881  };
2882 } );
2883 
2884 $.extend( baseEasings, {
2885  Sine: function( p ) {
2886  return 1 - Math.cos( p * Math.PI / 2 );
2887  },
2888  Circ: function( p ) {
2889  return 1 - Math.sqrt( 1 - p * p );
2890  },
2891  Elastic: function( p ) {
2892  return p === 0 || p === 1 ? p :
2893  -Math.pow( 2, 8 * ( p - 1 ) ) * Math.sin( ( ( p - 1 ) * 80 - 7.5 ) * Math.PI / 15 );
2894  },
2895  Back: function( p ) {
2896  return p * p * ( 3 * p - 2 );
2897  },
2898  Bounce: function( p ) {
2899  var pow2,
2900  bounce = 4;
2901 
2902  while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
2903  return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
2904  }
2905 } );
2906 
2907 $.each( baseEasings, function( name, easeIn ) {
2908  $.easing[ "easeIn" + name ] = easeIn;
2909  $.easing[ "easeOut" + name ] = function( p ) {
2910  return 1 - easeIn( 1 - p );
2911  };
2912  $.easing[ "easeInOut" + name ] = function( p ) {
2913  return p < 0.5 ?
2914  easeIn( p * 2 ) / 2 :
2915  1 - easeIn( p * -2 + 2 ) / 2;
2916  };
2917 } );
2918 
2919 } )();
2920 
2921 var effect = $.effects;
2922 
2923 
2924 /*!
2925  * jQuery UI Effects Blind 1.12.1
2926  * http://jqueryui.com
2927  *
2928  * Copyright jQuery Foundation and other contributors
2929  * Released under the MIT license.
2930  * http://jquery.org/license
2931  */
2932 
2933 //>>label: Blind Effect
2934 //>>group: Effects
2935 //>>description: Blinds the element.
2936 //>>docs: http://api.jqueryui.com/blind-effect/
2937 //>>demos: http://jqueryui.com/effect/
2938 
2939 
2940 
2941 var effectsEffectBlind = $.effects.define( "blind", "hide", function( options, done ) {
2942  var map = {
2943  up: [ "bottom", "top" ],
2944  vertical: [ "bottom", "top" ],
2945  down: [ "top", "bottom" ],
2946  left: [ "right", "left" ],
2947  horizontal: [ "right", "left" ],
2948  right: [ "left", "right" ]
2949  },
2950  element = $( this ),
2951  direction = options.direction || "up",
2952  start = element.cssClip(),
2953  animate = { clip: $.extend( {}, start ) },
2954  placeholder = $.effects.createPlaceholder( element );
2955 
2956  animate.clip[ map[ direction ][ 0 ] ] = animate.clip[ map[ direction ][ 1 ] ];
2957 
2958  if ( options.mode === "show" ) {
2959  element.cssClip( animate.clip );
2960  if ( placeholder ) {
2961  placeholder.css( $.effects.clipToBox( animate ) );
2962  }
2963 
2964  animate.clip = start;
2965  }
2966 
2967  if ( placeholder ) {
2968  placeholder.animate( $.effects.clipToBox( animate ), options.duration, options.easing );
2969  }
2970 
2971  element.animate( animate, {
2972  queue: false,
2973  duration: options.duration,
2974  easing: options.easing,
2975  complete: done
2976  } );
2977 } );
2978 
2979 
2980 /*!
2981  * jQuery UI Effects Bounce 1.12.1
2982  * http://jqueryui.com
2983  *
2984  * Copyright jQuery Foundation and other contributors
2985  * Released under the MIT license.
2986  * http://jquery.org/license
2987  */
2988 
2989 //>>label: Bounce Effect
2990 //>>group: Effects
2991 //>>description: Bounces an element horizontally or vertically n times.
2992 //>>docs: http://api.jqueryui.com/bounce-effect/
2993 //>>demos: http://jqueryui.com/effect/
2994 
2995 
2996 
2997 var effectsEffectBounce = $.effects.define( "bounce", function( options, done ) {
2998  var upAnim, downAnim, refValue,
2999  element = $( this ),
3000 
3001  // Defaults:
3002  mode = options.mode,
3003  hide = mode === "hide",
3004  show = mode === "show",
3005  direction = options.direction || "up",
3006  distance = options.distance,
3007  times = options.times || 5,
3008 
3009  // Number of internal animations
3010  anims = times * 2 + ( show || hide ? 1 : 0 ),
3011  speed = options.duration / anims,
3012  easing = options.easing,
3013 
3014  // Utility:
3015  ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3016  motion = ( direction === "up" || direction === "left" ),
3017  i = 0,
3018 
3019  queuelen = element.queue().length;
3020 
3021  $.effects.createPlaceholder( element );
3022 
3023  refValue = element.css( ref );
3024 
3025  // Default distance for the BIGGEST bounce is the outer Distance / 3
3026  if ( !distance ) {
3027  distance = element[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
3028  }
3029 
3030  if ( show ) {
3031  downAnim = { opacity: 1 };
3032  downAnim[ ref ] = refValue;
3033 
3034  // If we are showing, force opacity 0 and set the initial position
3035  // then do the "first" animation
3036  element
3037  .css( "opacity", 0 )
3038  .css( ref, motion ? -distance * 2 : distance * 2 )
3039  .animate( downAnim, speed, easing );
3040  }
3041 
3042  // Start at the smallest distance if we are hiding
3043  if ( hide ) {
3044  distance = distance / Math.pow( 2, times - 1 );
3045  }
3046 
3047  downAnim = {};
3048  downAnim[ ref ] = refValue;
3049 
3050  // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
3051  for ( ; i < times; i++ ) {
3052  upAnim = {};
3053  upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
3054 
3055  element
3056  .animate( upAnim, speed, easing )
3057  .animate( downAnim, speed, easing );
3058 
3059  distance = hide ? distance * 2 : distance / 2;
3060  }
3061 
3062  // Last Bounce when Hiding
3063  if ( hide ) {
3064  upAnim = { opacity: 0 };
3065  upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
3066 
3067  element.animate( upAnim, speed, easing );
3068  }
3069 
3070  element.queue( done );
3071 
3072  $.effects.unshift( element, queuelen, anims + 1 );
3073 } );
3074 
3075 
3076 /*!
3077  * jQuery UI Effects Clip 1.12.1
3078  * http://jqueryui.com
3079  *
3080  * Copyright jQuery Foundation and other contributors
3081  * Released under the MIT license.
3082  * http://jquery.org/license
3083  */
3084 
3085 //>>label: Clip Effect
3086 //>>group: Effects
3087 //>>description: Clips the element on and off like an old TV.
3088 //>>docs: http://api.jqueryui.com/clip-effect/
3089 //>>demos: http://jqueryui.com/effect/
3090 
3091 
3092 
3093 var effectsEffectClip = $.effects.define( "clip", "hide", function( options, done ) {
3094  var start,
3095  animate = {},
3096  element = $( this ),
3097  direction = options.direction || "vertical",
3098  both = direction === "both",
3099  horizontal = both || direction === "horizontal",
3100  vertical = both || direction === "vertical";
3101 
3102  start = element.cssClip();
3103  animate.clip = {
3104  top: vertical ? ( start.bottom - start.top ) / 2 : start.top,
3105  right: horizontal ? ( start.right - start.left ) / 2 : start.right,
3106  bottom: vertical ? ( start.bottom - start.top ) / 2 : start.bottom,
3107  left: horizontal ? ( start.right - start.left ) / 2 : start.left
3108  };
3109 
3110  $.effects.createPlaceholder( element );
3111 
3112  if ( options.mode === "show" ) {
3113  element.cssClip( animate.clip );
3114  animate.clip = start;
3115  }
3116 
3117  element.animate( animate, {
3118  queue: false,
3119  duration: options.duration,
3120  easing: options.easing,
3121  complete: done
3122  } );
3123 
3124 } );
3125 
3126 
3127 /*!
3128  * jQuery UI Effects Drop 1.12.1
3129  * http://jqueryui.com
3130  *
3131  * Copyright jQuery Foundation and other contributors
3132  * Released under the MIT license.
3133  * http://jquery.org/license
3134  */
3135 
3136 //>>label: Drop Effect
3137 //>>group: Effects
3138 //>>description: Moves an element in one direction and hides it at the same time.
3139 //>>docs: http://api.jqueryui.com/drop-effect/
3140 //>>demos: http://jqueryui.com/effect/
3141 
3142 
3143 
3144 var effectsEffectDrop = $.effects.define( "drop", "hide", function( options, done ) {
3145 
3146  var distance,
3147  element = $( this ),
3148  mode = options.mode,
3149  show = mode === "show",
3150  direction = options.direction || "left",
3151  ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3152  motion = ( direction === "up" || direction === "left" ) ? "-=" : "+=",
3153  oppositeMotion = ( motion === "+=" ) ? "-=" : "+=",
3154  animation = {
3155  opacity: 0
3156  };
3157 
3158  $.effects.createPlaceholder( element );
3159 
3160  distance = options.distance ||
3161  element[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
3162 
3163  animation[ ref ] = motion + distance;
3164 
3165  if ( show ) {
3166  element.css( animation );
3167 
3168  animation[ ref ] = oppositeMotion + distance;
3169  animation.opacity = 1;
3170  }
3171 
3172  // Animate
3173  element.animate( animation, {
3174  queue: false,
3175  duration: options.duration,
3176  easing: options.easing,
3177  complete: done
3178  } );
3179 } );
3180 
3181 
3182 /*!
3183  * jQuery UI Effects Explode 1.12.1
3184  * http://jqueryui.com
3185  *
3186  * Copyright jQuery Foundation and other contributors
3187  * Released under the MIT license.
3188  * http://jquery.org/license
3189  */
3190 
3191 //>>label: Explode Effect
3192 //>>group: Effects
3193 // jscs:disable maximumLineLength
3194 //>>description: Explodes an element in all directions into n pieces. Implodes an element to its original wholeness.
3195 // jscs:enable maximumLineLength
3196 //>>docs: http://api.jqueryui.com/explode-effect/
3197 //>>demos: http://jqueryui.com/effect/
3198 
3199 
3200 
3201 var effectsEffectExplode = $.effects.define( "explode", "hide", function( options, done ) {
3202 
3203  var i, j, left, top, mx, my,
3204  rows = options.pieces ? Math.round( Math.sqrt( options.pieces ) ) : 3,
3205  cells = rows,
3206  element = $( this ),
3207  mode = options.mode,
3208  show = mode === "show",
3209 
3210  // Show and then visibility:hidden the element before calculating offset
3211  offset = element.show().css( "visibility", "hidden" ).offset(),
3212 
3213  // Width and height of a piece
3214  width = Math.ceil( element.outerWidth() / cells ),
3215  height = Math.ceil( element.outerHeight() / rows ),
3216  pieces = [];
3217 
3218  // Children animate complete:
3219  function childComplete() {
3220  pieces.push( this );
3221  if ( pieces.length === rows * cells ) {
3222  animComplete();
3223  }
3224  }
3225 
3226  // Clone the element for each row and cell.
3227  for ( i = 0; i < rows; i++ ) { // ===>
3228  top = offset.top + i * height;
3229  my = i - ( rows - 1 ) / 2;
3230 
3231  for ( j = 0; j < cells; j++ ) { // |||
3232  left = offset.left + j * width;
3233  mx = j - ( cells - 1 ) / 2;
3234 
3235  // Create a clone of the now hidden main element that will be absolute positioned
3236  // within a wrapper div off the -left and -top equal to size of our pieces
3237  element
3238  .clone()
3239  .appendTo( "body" )
3240  .wrap( "<div></div>" )
3241  .css( {
3242  position: "absolute",
3243  visibility: "visible",
3244  left: -j * width,
3245  top: -i * height
3246  } )
3247 
3248  // Select the wrapper - make it overflow: hidden and absolute positioned based on
3249  // where the original was located +left and +top equal to the size of pieces
3250  .parent()
3251  .addClass( "ui-effects-explode" )
3252  .css( {
3253  position: "absolute",
3254  overflow: "hidden",
3255  width: width,
3256  height: height,
3257  left: left + ( show ? mx * width : 0 ),
3258  top: top + ( show ? my * height : 0 ),
3259  opacity: show ? 0 : 1
3260  } )
3261  .animate( {
3262  left: left + ( show ? 0 : mx * width ),
3263  top: top + ( show ? 0 : my * height ),
3264  opacity: show ? 1 : 0
3265  }, options.duration || 500, options.easing, childComplete );
3266  }
3267  }
3268 
3269  function animComplete() {
3270  element.css( {
3271  visibility: "visible"
3272  } );
3273  $( pieces ).remove();
3274  done();
3275  }
3276 } );
3277 
3278 
3279 /*!
3280  * jQuery UI Effects Fade 1.12.1
3281  * http://jqueryui.com
3282  *
3283  * Copyright jQuery Foundation and other contributors
3284  * Released under the MIT license.
3285  * http://jquery.org/license
3286  */
3287 
3288 //>>label: Fade Effect
3289 //>>group: Effects
3290 //>>description: Fades the element.
3291 //>>docs: http://api.jqueryui.com/fade-effect/
3292 //>>demos: http://jqueryui.com/effect/
3293 
3294 
3295 
3296 var effectsEffectFade = $.effects.define( "fade", "toggle", function( options, done ) {
3297  var show = options.mode === "show";
3298 
3299  $( this )
3300  .css( "opacity", show ? 0 : 1 )
3301  .animate( {
3302  opacity: show ? 1 : 0
3303  }, {
3304  queue: false,
3305  duration: options.duration,
3306  easing: options.easing,
3307  complete: done
3308  } );
3309 } );
3310 
3311 
3312 /*!
3313  * jQuery UI Effects Fold 1.12.1
3314  * http://jqueryui.com
3315  *
3316  * Copyright jQuery Foundation and other contributors
3317  * Released under the MIT license.
3318  * http://jquery.org/license
3319  */
3320 
3321 //>>label: Fold Effect
3322 //>>group: Effects
3323 //>>description: Folds an element first horizontally and then vertically.
3324 //>>docs: http://api.jqueryui.com/fold-effect/
3325 //>>demos: http://jqueryui.com/effect/
3326 
3327 
3328 
3329 var effectsEffectFold = $.effects.define( "fold", "hide", function( options, done ) {
3330 
3331  // Create element
3332  var element = $( this ),
3333  mode = options.mode,
3334  show = mode === "show",
3335  hide = mode === "hide",
3336  size = options.size || 15,
3337  percent = /([0-9]+)%/.exec( size ),
3338  horizFirst = !!options.horizFirst,
3339  ref = horizFirst ? [ "right", "bottom" ] : [ "bottom", "right" ],
3340  duration = options.duration / 2,
3341 
3342  placeholder = $.effects.createPlaceholder( element ),
3343 
3344  start = element.cssClip(),
3345  animation1 = { clip: $.extend( {}, start ) },
3346  animation2 = { clip: $.extend( {}, start ) },
3347 
3348  distance = [ start[ ref[ 0 ] ], start[ ref[ 1 ] ] ],
3349 
3350  queuelen = element.queue().length;
3351 
3352  if ( percent ) {
3353  size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
3354  }
3355  animation1.clip[ ref[ 0 ] ] = size;
3356  animation2.clip[ ref[ 0 ] ] = size;
3357  animation2.clip[ ref[ 1 ] ] = 0;
3358 
3359  if ( show ) {
3360  element.cssClip( animation2.clip );
3361  if ( placeholder ) {
3362  placeholder.css( $.effects.clipToBox( animation2 ) );
3363  }
3364 
3365  animation2.clip = start;
3366  }
3367 
3368  // Animate
3369  element
3370  .queue( function( next ) {
3371  if ( placeholder ) {
3372  placeholder
3373  .animate( $.effects.clipToBox( animation1 ), duration, options.easing )
3374  .animate( $.effects.clipToBox( animation2 ), duration, options.easing );
3375  }
3376 
3377  next();
3378  } )
3379  .animate( animation1, duration, options.easing )
3380  .animate( animation2, duration, options.easing )
3381  .queue( done );
3382 
3383  $.effects.unshift( element, queuelen, 4 );
3384 } );
3385 
3386 
3387 /*!
3388  * jQuery UI Effects Highlight 1.12.1
3389  * http://jqueryui.com
3390  *
3391  * Copyright jQuery Foundation and other contributors
3392  * Released under the MIT license.
3393  * http://jquery.org/license
3394  */
3395 
3396 //>>label: Highlight Effect
3397 //>>group: Effects
3398 //>>description: Highlights the background of an element in a defined color for a custom duration.
3399 //>>docs: http://api.jqueryui.com/highlight-effect/
3400 //>>demos: http://jqueryui.com/effect/
3401 
3402 
3403 
3404 var effectsEffectHighlight = $.effects.define( "highlight", "show", function( options, done ) {
3405  var element = $( this ),
3406  animation = {
3407  backgroundColor: element.css( "backgroundColor" )
3408  };
3409 
3410  if ( options.mode === "hide" ) {
3411  animation.opacity = 0;
3412  }
3413 
3414  $.effects.saveStyle( element );
3415 
3416  element
3417  .css( {
3418  backgroundImage: "none",
3419  backgroundColor: options.color || "#ffff99"
3420  } )
3421  .animate( animation, {
3422  queue: false,
3423  duration: options.duration,
3424  easing: options.easing,
3425  complete: done
3426  } );
3427 } );
3428 
3429 
3430 /*!
3431  * jQuery UI Effects Size 1.12.1
3432  * http://jqueryui.com
3433  *
3434  * Copyright jQuery Foundation and other contributors
3435  * Released under the MIT license.
3436  * http://jquery.org/license
3437  */
3438 
3439 //>>label: Size Effect
3440 //>>group: Effects
3441 //>>description: Resize an element to a specified width and height.
3442 //>>docs: http://api.jqueryui.com/size-effect/
3443 //>>demos: http://jqueryui.com/effect/
3444 
3445 
3446 
3447 var effectsEffectSize = $.effects.define( "size", function( options, done ) {
3448 
3449  // Create element
3450  var baseline, factor, temp,
3451  element = $( this ),
3452 
3453  // Copy for children
3454  cProps = [ "fontSize" ],
3455  vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
3456  hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
3457 
3458  // Set options
3459  mode = options.mode,
3460  restore = mode !== "effect",
3461  scale = options.scale || "both",
3462  origin = options.origin || [ "middle", "center" ],
3463  position = element.css( "position" ),
3464  pos = element.position(),
3465  original = $.effects.scaledDimensions( element ),
3466  from = options.from || original,
3467  to = options.to || $.effects.scaledDimensions( element, 0 );
3468 
3469  $.effects.createPlaceholder( element );
3470 
3471  if ( mode === "show" ) {
3472  temp = from;
3473  from = to;
3474  to = temp;
3475  }
3476 
3477  // Set scaling factor
3478  factor = {
3479  from: {
3480  y: from.height / original.height,
3481  x: from.width / original.width
3482  },
3483  to: {
3484  y: to.height / original.height,
3485  x: to.width / original.width
3486  }
3487  };
3488 
3489  // Scale the css box
3490  if ( scale === "box" || scale === "both" ) {
3491 
3492  // Vertical props scaling
3493  if ( factor.from.y !== factor.to.y ) {
3494  from = $.effects.setTransition( element, vProps, factor.from.y, from );
3495  to = $.effects.setTransition( element, vProps, factor.to.y, to );
3496  }
3497 
3498  // Horizontal props scaling
3499  if ( factor.from.x !== factor.to.x ) {
3500  from = $.effects.setTransition( element, hProps, factor.from.x, from );
3501  to = $.effects.setTransition( element, hProps, factor.to.x, to );
3502  }
3503  }
3504 
3505  // Scale the content
3506  if ( scale === "content" || scale === "both" ) {
3507 
3508  // Vertical props scaling
3509  if ( factor.from.y !== factor.to.y ) {
3510  from = $.effects.setTransition( element, cProps, factor.from.y, from );
3511  to = $.effects.setTransition( element, cProps, factor.to.y, to );
3512  }
3513  }
3514 
3515  // Adjust the position properties based on the provided origin points
3516  if ( origin ) {
3517  baseline = $.effects.getBaseline( origin, original );
3518  from.top = ( original.outerHeight - from.outerHeight ) * baseline.y + pos.top;
3519  from.left = ( original.outerWidth - from.outerWidth ) * baseline.x + pos.left;
3520  to.top = ( original.outerHeight - to.outerHeight ) * baseline.y + pos.top;
3521  to.left = ( original.outerWidth - to.outerWidth ) * baseline.x + pos.left;
3522  }
3523  element.css( from );
3524 
3525  // Animate the children if desired
3526  if ( scale === "content" || scale === "both" ) {
3527 
3528  vProps = vProps.concat( [ "marginTop", "marginBottom" ] ).concat( cProps );
3529  hProps = hProps.concat( [ "marginLeft", "marginRight" ] );
3530 
3531  // Only animate children with width attributes specified
3532  // TODO: is this right? should we include anything with css width specified as well
3533  element.find( "*[width]" ).each( function() {
3534  var child = $( this ),
3535  childOriginal = $.effects.scaledDimensions( child ),
3536  childFrom = {
3537  height: childOriginal.height * factor.from.y,
3538  width: childOriginal.width * factor.from.x,
3539  outerHeight: childOriginal.outerHeight * factor.from.y,
3540  outerWidth: childOriginal.outerWidth * factor.from.x
3541  },
3542  childTo = {
3543  height: childOriginal.height * factor.to.y,
3544  width: childOriginal.width * factor.to.x,
3545  outerHeight: childOriginal.height * factor.to.y,
3546  outerWidth: childOriginal.width * factor.to.x
3547  };
3548 
3549  // Vertical props scaling
3550  if ( factor.from.y !== factor.to.y ) {
3551  childFrom = $.effects.setTransition( child, vProps, factor.from.y, childFrom );
3552  childTo = $.effects.setTransition( child, vProps, factor.to.y, childTo );
3553  }
3554 
3555  // Horizontal props scaling
3556  if ( factor.from.x !== factor.to.x ) {
3557  childFrom = $.effects.setTransition( child, hProps, factor.from.x, childFrom );
3558  childTo = $.effects.setTransition( child, hProps, factor.to.x, childTo );
3559  }
3560 
3561  if ( restore ) {
3562  $.effects.saveStyle( child );
3563  }
3564 
3565  // Animate children
3566  child.css( childFrom );
3567  child.animate( childTo, options.duration, options.easing, function() {
3568 
3569  // Restore children
3570  if ( restore ) {
3571  $.effects.restoreStyle( child );
3572  }
3573  } );
3574  } );
3575  }
3576 
3577  // Animate
3578  element.animate( to, {
3579  queue: false,
3580  duration: options.duration,
3581  easing: options.easing,
3582  complete: function() {
3583 
3584  var offset = element.offset();
3585 
3586  if ( to.opacity === 0 ) {
3587  element.css( "opacity", from.opacity );
3588  }
3589 
3590  if ( !restore ) {
3591  element
3592  .css( "position", position === "static" ? "relative" : position )
3593  .offset( offset );
3594 
3595  // Need to save style here so that automatic style restoration
3596  // doesn't restore to the original styles from before the animation.
3597  $.effects.saveStyle( element );
3598  }
3599 
3600  done();
3601  }
3602  } );
3603 
3604 } );
3605 
3606 
3607 /*!
3608  * jQuery UI Effects Scale 1.12.1
3609  * http://jqueryui.com
3610  *
3611  * Copyright jQuery Foundation and other contributors
3612  * Released under the MIT license.
3613  * http://jquery.org/license
3614  */
3615 
3616 //>>label: Scale Effect
3617 //>>group: Effects
3618 //>>description: Grows or shrinks an element and its content.
3619 //>>docs: http://api.jqueryui.com/scale-effect/
3620 //>>demos: http://jqueryui.com/effect/
3621 
3622 
3623 
3624 var effectsEffectScale = $.effects.define( "scale", function( options, done ) {
3625 
3626  // Create element
3627  var el = $( this ),
3628  mode = options.mode,
3629  percent = parseInt( options.percent, 10 ) ||
3630  ( parseInt( options.percent, 10 ) === 0 ? 0 : ( mode !== "effect" ? 0 : 100 ) ),
3631 
3632  newOptions = $.extend( true, {
3633  from: $.effects.scaledDimensions( el ),
3634  to: $.effects.scaledDimensions( el, percent, options.direction || "both" ),
3635  origin: options.origin || [ "middle", "center" ]
3636  }, options );
3637 
3638  // Fade option to support puff
3639  if ( options.fade ) {
3640  newOptions.from.opacity = 1;
3641  newOptions.to.opacity = 0;
3642  }
3643 
3644  $.effects.effect.size.call( this, newOptions, done );
3645 } );
3646 
3647 
3648 /*!
3649  * jQuery UI Effects Puff 1.12.1
3650  * http://jqueryui.com
3651  *
3652  * Copyright jQuery Foundation and other contributors
3653  * Released under the MIT license.
3654  * http://jquery.org/license
3655  */
3656 
3657 //>>label: Puff Effect
3658 //>>group: Effects
3659 //>>description: Creates a puff effect by scaling the element up and hiding it at the same time.
3660 //>>docs: http://api.jqueryui.com/puff-effect/
3661 //>>demos: http://jqueryui.com/effect/
3662 
3663 
3664 
3665 var effectsEffectPuff = $.effects.define( "puff", "hide", function( options, done ) {
3666  var newOptions = $.extend( true, {}, options, {
3667  fade: true,
3668  percent: parseInt( options.percent, 10 ) || 150
3669  } );
3670 
3671  $.effects.effect.scale.call( this, newOptions, done );
3672 } );
3673 
3674 
3675 /*!
3676  * jQuery UI Effects Pulsate 1.12.1
3677  * http://jqueryui.com
3678  *
3679  * Copyright jQuery Foundation and other contributors
3680  * Released under the MIT license.
3681  * http://jquery.org/license
3682  */
3683 
3684 //>>label: Pulsate Effect
3685 //>>group: Effects
3686 //>>description: Pulsates an element n times by changing the opacity to zero and back.
3687 //>>docs: http://api.jqueryui.com/pulsate-effect/
3688 //>>demos: http://jqueryui.com/effect/
3689 
3690 
3691 
3692 var effectsEffectPulsate = $.effects.define( "pulsate", "show", function( options, done ) {
3693  var element = $( this ),
3694  mode = options.mode,
3695  show = mode === "show",
3696  hide = mode === "hide",
3697  showhide = show || hide,
3698 
3699  // Showing or hiding leaves off the "last" animation
3700  anims = ( ( options.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
3701  duration = options.duration / anims,
3702  animateTo = 0,
3703  i = 1,
3704  queuelen = element.queue().length;
3705 
3706  if ( show || !element.is( ":visible" ) ) {
3707  element.css( "opacity", 0 ).show();
3708  animateTo = 1;
3709  }
3710 
3711  // Anims - 1 opacity "toggles"
3712  for ( ; i < anims; i++ ) {
3713  element.animate( { opacity: animateTo }, duration, options.easing );
3714  animateTo = 1 - animateTo;
3715  }
3716 
3717  element.animate( { opacity: animateTo }, duration, options.easing );
3718 
3719  element.queue( done );
3720 
3721  $.effects.unshift( element, queuelen, anims + 1 );
3722 } );
3723 
3724 
3725 /*!
3726  * jQuery UI Effects Shake 1.12.1
3727  * http://jqueryui.com
3728  *
3729  * Copyright jQuery Foundation and other contributors
3730  * Released under the MIT license.
3731  * http://jquery.org/license
3732  */
3733 
3734 //>>label: Shake Effect
3735 //>>group: Effects
3736 //>>description: Shakes an element horizontally or vertically n times.
3737 //>>docs: http://api.jqueryui.com/shake-effect/
3738 //>>demos: http://jqueryui.com/effect/
3739 
3740 
3741 
3742 var effectsEffectShake = $.effects.define( "shake", function( options, done ) {
3743 
3744  var i = 1,
3745  element = $( this ),
3746  direction = options.direction || "left",
3747  distance = options.distance || 20,
3748  times = options.times || 3,
3749  anims = times * 2 + 1,
3750  speed = Math.round( options.duration / anims ),
3751  ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3752  positiveMotion = ( direction === "up" || direction === "left" ),
3753  animation = {},
3754  animation1 = {},
3755  animation2 = {},
3756 
3757  queuelen = element.queue().length;
3758 
3759  $.effects.createPlaceholder( element );
3760 
3761  // Animation
3762  animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
3763  animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
3764  animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
3765 
3766  // Animate
3767  element.animate( animation, speed, options.easing );
3768 
3769  // Shakes
3770  for ( ; i < times; i++ ) {
3771  element
3772  .animate( animation1, speed, options.easing )
3773  .animate( animation2, speed, options.easing );
3774  }
3775 
3776  element
3777  .animate( animation1, speed, options.easing )
3778  .animate( animation, speed / 2, options.easing )
3779  .queue( done );
3780 
3781  $.effects.unshift( element, queuelen, anims + 1 );
3782 } );
3783 
3784 
3785 /*!
3786  * jQuery UI Effects Slide 1.12.1
3787  * http://jqueryui.com
3788  *
3789  * Copyright jQuery Foundation and other contributors
3790  * Released under the MIT license.
3791  * http://jquery.org/license
3792  */
3793 
3794 //>>label: Slide Effect
3795 //>>group: Effects
3796 //>>description: Slides an element in and out of the viewport.
3797 //>>docs: http://api.jqueryui.com/slide-effect/
3798 //>>demos: http://jqueryui.com/effect/
3799 
3800 
3801 
3802 var effectsEffectSlide = $.effects.define( "slide", "show", function( options, done ) {
3803  var startClip, startRef,
3804  element = $( this ),
3805  map = {
3806  up: [ "bottom", "top" ],
3807  down: [ "top", "bottom" ],
3808  left: [ "right", "left" ],
3809  right: [ "left", "right" ]
3810  },
3811  mode = options.mode,
3812  direction = options.direction || "left",
3813  ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
3814  positiveMotion = ( direction === "up" || direction === "left" ),
3815  distance = options.distance ||
3816  element[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ),
3817  animation = {};
3818 
3819  $.effects.createPlaceholder( element );
3820 
3821  startClip = element.cssClip();
3822  startRef = element.position()[ ref ];
3823 
3824  // Define hide animation
3825  animation[ ref ] = ( positiveMotion ? -1 : 1 ) * distance + startRef;
3826  animation.clip = element.cssClip();
3827  animation.clip[ map[ direction ][ 1 ] ] = animation.clip[ map[ direction ][ 0 ] ];
3828 
3829  // Reverse the animation if we're showing
3830  if ( mode === "show" ) {
3831  element.cssClip( animation.clip );
3832  element.css( ref, animation[ ref ] );
3833  animation.clip = startClip;
3834  animation[ ref ] = startRef;
3835  }
3836 
3837  // Actually animate
3838  element.animate( animation, {
3839  queue: false,
3840  duration: options.duration,
3841  easing: options.easing,
3842  complete: done
3843  } );
3844 } );
3845 
3846 
3847 /*!
3848  * jQuery UI Effects Transfer 1.12.1
3849  * http://jqueryui.com
3850  *
3851  * Copyright jQuery Foundation and other contributors
3852  * Released under the MIT license.
3853  * http://jquery.org/license
3854  */
3855 
3856 //>>label: Transfer Effect
3857 //>>group: Effects
3858 //>>description: Displays a transfer effect from one element to another.
3859 //>>docs: http://api.jqueryui.com/transfer-effect/
3860 //>>demos: http://jqueryui.com/effect/
3861 
3862 
3863 
3864 var effect;
3865 if ( $.uiBackCompat !== false ) {
3866  effect = $.effects.define( "transfer", function( options, done ) {
3867  $( this ).transfer( options, done );
3868  } );
3869 }
3870 var effectsEffectTransfer = effect;
3871 
3872 
3873 /*!
3874  * jQuery UI Focusable 1.12.1
3875  * http://jqueryui.com
3876  *
3877  * Copyright jQuery Foundation and other contributors
3878  * Released under the MIT license.
3879  * http://jquery.org/license
3880  */
3881 
3882 //>>label: :focusable Selector
3883 //>>group: Core
3884 //>>description: Selects elements which can be focused.
3885 //>>docs: http://api.jqueryui.com/focusable-selector/
3886 
3887 
3888 
3889 // Selectors
3890 $.ui.focusable = function( element, hasTabindex ) {
3891  var map, mapName, img, focusableIfVisible, fieldset,
3892  nodeName = element.nodeName.toLowerCase();
3893 
3894  if ( "area" === nodeName ) {
3895  map = element.parentNode;
3896  mapName = map.name;
3897  if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
3898  return false;
3899  }
3900  img = $( "img[usemap='#" + mapName + "']" );
3901  return img.length > 0 && img.is( ":visible" );
3902  }
3903 
3904  if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) {
3905  focusableIfVisible = !element.disabled;
3906 
3907  if ( focusableIfVisible ) {
3908 
3909  // Form controls within a disabled fieldset are disabled.
3910  // However, controls within the fieldset's legend do not get disabled.
3911  // Since controls generally aren't placed inside legends, we skip
3912  // this portion of the check.
3913  fieldset = $( element ).closest( "fieldset" )[ 0 ];
3914  if ( fieldset ) {
3915  focusableIfVisible = !fieldset.disabled;
3916  }
3917  }
3918  } else if ( "a" === nodeName ) {
3919  focusableIfVisible = element.href || hasTabindex;
3920  } else {
3921  focusableIfVisible = hasTabindex;
3922  }
3923 
3924  return focusableIfVisible && $( element ).is( ":visible" ) && visible( $( element ) );
3925 };
3926 
3927 // Support: IE 8 only
3928 // IE 8 doesn't resolve inherit to visible/hidden for computed values
3929 function visible( element ) {
3930  var visibility = element.css( "visibility" );
3931  while ( visibility === "inherit" ) {
3932  element = element.parent();
3933  visibility = element.css( "visibility" );
3934  }
3935  return visibility !== "hidden";
3936 }
3937 
3938 $.extend( $.expr[ ":" ], {
3939  focusable: function( element ) {
3940  return $.ui.focusable( element, $.attr( element, "tabindex" ) != null );
3941  }
3942 } );
3943 
3944 var focusable = $.ui.focusable;
3945 
3946 
3947 
3948 
3949 // Support: IE8 Only
3950 // IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
3951 // with a string, so we need to find the proper form.
3952 var form = $.fn.form = function() {
3953  return typeof this[ 0 ].form === "string" ? this.closest( "form" ) : $( this[ 0 ].form );
3954 };
3955 
3956 
3957 /*!
3958  * jQuery UI Form Reset Mixin 1.12.1
3959  * http://jqueryui.com
3960  *
3961  * Copyright jQuery Foundation and other contributors
3962  * Released under the MIT license.
3963  * http://jquery.org/license
3964  */
3965 
3966 //>>label: Form Reset Mixin
3967 //>>group: Core
3968 //>>description: Refresh input widgets when their form is reset
3969 //>>docs: http://api.jqueryui.com/form-reset-mixin/
3970 
3971 
3972 
3973 var formResetMixin = $.ui.formResetMixin = {
3974  _formResetHandler: function() {
3975  var form = $( this );
3976 
3977  // Wait for the form reset to actually happen before refreshing
3978  setTimeout( function() {
3979  var instances = form.data( "ui-form-reset-instances" );
3980  $.each( instances, function() {
3981  this.refresh();
3982  } );
3983  } );
3984  },
3985 
3986  _bindFormResetHandler: function() {
3987  this.form = this.element.form();
3988  if ( !this.form.length ) {
3989  return;
3990  }
3991 
3992  var instances = this.form.data( "ui-form-reset-instances" ) || [];
3993  if ( !instances.length ) {
3994 
3995  // We don't use _on() here because we use a single event handler per form
3996  this.form.on( "reset.ui-form-reset", this._formResetHandler );
3997  }
3998  instances.push( this );
3999  this.form.data( "ui-form-reset-instances", instances );
4000  },
4001 
4002  _unbindFormResetHandler: function() {
4003  if ( !this.form.length ) {
4004  return;
4005  }
4006 
4007  var instances = this.form.data( "ui-form-reset-instances" );
4008  instances.splice( $.inArray( this, instances ), 1 );
4009  if ( instances.length ) {
4010  this.form.data( "ui-form-reset-instances", instances );
4011  } else {
4012  this.form
4013  .removeData( "ui-form-reset-instances" )
4014  .off( "reset.ui-form-reset" );
4015  }
4016  }
4017 };
4018 
4019 
4020 /*!
4021  * jQuery UI Support for jQuery core 1.7.x 1.12.1
4022  * http://jqueryui.com
4023  *
4024  * Copyright jQuery Foundation and other contributors
4025  * Released under the MIT license.
4026  * http://jquery.org/license
4027  *
4028  */
4029 
4030 //>>label: jQuery 1.7 Support
4031 //>>group: Core
4032 //>>description: Support version 1.7.x of jQuery core
4033 
4034 
4035 
4036 // Support: jQuery 1.7 only
4037 // Not a great way to check versions, but since we only support 1.7+ and only
4038 // need to detect <1.8, this is a simple check that should suffice. Checking
4039 // for "1.7." would be a bit safer, but the version string is 1.7, not 1.7.0
4040 // and we'll never reach 1.70.0 (if we do, we certainly won't be supporting
4041 // 1.7 anymore). See #11197 for why we're not using feature detection.
4042 if ( $.fn.jquery.substring( 0, 3 ) === "1.7" ) {
4043 
4044  // Setters for .innerWidth(), .innerHeight(), .outerWidth(), .outerHeight()
4045  // Unlike jQuery Core 1.8+, these only support numeric values to set the
4046  // dimensions in pixels
4047  $.each( [ "Width", "Height" ], function( i, name ) {
4048  var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
4049  type = name.toLowerCase(),
4050  orig = {
4051  innerWidth: $.fn.innerWidth,
4052  innerHeight: $.fn.innerHeight,
4053  outerWidth: $.fn.outerWidth,
4054  outerHeight: $.fn.outerHeight
4055  };
4056 
4057  function reduce( elem, size, border, margin ) {
4058  $.each( side, function() {
4059  size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
4060  if ( border ) {
4061  size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
4062  }
4063  if ( margin ) {
4064  size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
4065  }
4066  } );
4067  return size;
4068  }
4069 
4070  $.fn[ "inner" + name ] = function( size ) {
4071  if ( size === undefined ) {
4072  return orig[ "inner" + name ].call( this );
4073  }
4074 
4075  return this.each( function() {
4076  $( this ).css( type, reduce( this, size ) + "px" );
4077  } );
4078  };
4079 
4080  $.fn[ "outer" + name ] = function( size, margin ) {
4081  if ( typeof size !== "number" ) {
4082  return orig[ "outer" + name ].call( this, size );
4083  }
4084 
4085  return this.each( function() {
4086  $( this ).css( type, reduce( this, size, true, margin ) + "px" );
4087  } );
4088  };
4089  } );
4090 
4091  $.fn.addBack = function( selector ) {
4092  return this.add( selector == null ?
4093  this.prevObject : this.prevObject.filter( selector )
4094  );
4095  };
4096 }
4097 
4098 ;
4099 /*!
4100  * jQuery UI Keycode 1.12.1
4101  * http://jqueryui.com
4102  *
4103  * Copyright jQuery Foundation and other contributors
4104  * Released under the MIT license.
4105  * http://jquery.org/license
4106  */
4107 
4108 //>>label: Keycode
4109 //>>group: Core
4110 //>>description: Provide keycodes as keynames
4111 //>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
4112 
4113 
4114 var keycode = $.ui.keyCode = {
4115  BACKSPACE: 8,
4116  COMMA: 188,
4117  DELETE: 46,
4118  DOWN: 40,
4119  END: 35,
4120  ENTER: 13,
4121  ESCAPE: 27,
4122  HOME: 36,
4123  LEFT: 37,
4124  PAGE_DOWN: 34,
4125  PAGE_UP: 33,
4126  PERIOD: 190,
4127  RIGHT: 39,
4128  SPACE: 32,
4129  TAB: 9,
4130  UP: 38
4131 };
4132 
4133 
4134 
4135 
4136 // Internal use only
4137 var escapeSelector = $.ui.escapeSelector = ( function() {
4138  var selectorEscape = /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;
4139  return function( selector ) {
4140  return selector.replace( selectorEscape, "\\$1" );
4141  };
4142 } )();
4143 
4144 
4145 /*!
4146  * jQuery UI Labels 1.12.1
4147  * http://jqueryui.com
4148  *
4149  * Copyright jQuery Foundation and other contributors
4150  * Released under the MIT license.
4151  * http://jquery.org/license
4152  */
4153 
4154 //>>label: labels
4155 //>>group: Core
4156 //>>description: Find all the labels associated with a given input
4157 //>>docs: http://api.jqueryui.com/labels/
4158 
4159 
4160 
4161 var labels = $.fn.labels = function() {
4162  var ancestor, selector, id, labels, ancestors;
4163 
4164  // Check control.labels first
4165  if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
4166  return this.pushStack( this[ 0 ].labels );
4167  }
4168 
4169  // Support: IE <= 11, FF <= 37, Android <= 2.3 only
4170  // Above browsers do not support control.labels. Everything below is to support them
4171  // as well as document fragments. control.labels does not work on document fragments
4172  labels = this.eq( 0 ).parents( "label" );
4173 
4174  // Look for the label based on the id
4175  id = this.attr( "id" );
4176  if ( id ) {
4177 
4178  // We don't search against the document in case the element
4179  // is disconnected from the DOM
4180  ancestor = this.eq( 0 ).parents().last();
4181 
4182  // Get a full set of top level ancestors
4183  ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );
4184 
4185  // Create a selector for the label based on the id
4186  selector = "label[for='" + $.ui.escapeSelector( id ) + "']";
4187 
4188  labels = labels.add( ancestors.find( selector ).addBack( selector ) );
4189 
4190  }
4191 
4192  // Return whatever we have found for labels
4193  return this.pushStack( labels );
4194 };
4195 
4196 
4197 /*!
4198  * jQuery UI Scroll Parent 1.12.1
4199  * http://jqueryui.com
4200  *
4201  * Copyright jQuery Foundation and other contributors
4202  * Released under the MIT license.
4203  * http://jquery.org/license
4204  */
4205 
4206 //>>label: scrollParent
4207 //>>group: Core
4208 //>>description: Get the closest ancestor element that is scrollable.
4209 //>>docs: http://api.jqueryui.com/scrollParent/
4210 
4211 
4212 
4213 var scrollParent = $.fn.scrollParent = function( includeHidden ) {
4214  var position = this.css( "position" ),
4215  excludeStaticParent = position === "absolute",
4216  overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
4217  scrollParent = this.parents().filter( function() {
4218  var parent = $( this );
4219  if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
4220  return false;
4221  }
4222  return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) +
4223  parent.css( "overflow-x" ) );
4224  } ).eq( 0 );
4225 
4226  return position === "fixed" || !scrollParent.length ?
4227  $( this[ 0 ].ownerDocument || document ) :
4228  scrollParent;
4229 };
4230 
4231 
4232 /*!
4233  * jQuery UI Tabbable 1.12.1
4234  * http://jqueryui.com
4235  *
4236  * Copyright jQuery Foundation and other contributors
4237  * Released under the MIT license.
4238  * http://jquery.org/license
4239  */
4240 
4241 //>>label: :tabbable Selector
4242 //>>group: Core
4243 //>>description: Selects elements which can be tabbed to.
4244 //>>docs: http://api.jqueryui.com/tabbable-selector/
4245 
4246 
4247 
4248 var tabbable = $.extend( $.expr[ ":" ], {
4249  tabbable: function( element ) {
4250  var tabIndex = $.attr( element, "tabindex" ),
4251  hasTabindex = tabIndex != null;
4252  return ( !hasTabindex || tabIndex >= 0 ) && $.ui.focusable( element, hasTabindex );
4253  }
4254 } );
4255 
4256 
4257 /*!
4258  * jQuery UI Unique ID 1.12.1
4259  * http://jqueryui.com
4260  *
4261  * Copyright jQuery Foundation and other contributors
4262  * Released under the MIT license.
4263  * http://jquery.org/license
4264  */
4265 
4266 //>>label: uniqueId
4267 //>>group: Core
4268 //>>description: Functions to generate and remove uniqueId's
4269 //>>docs: http://api.jqueryui.com/uniqueId/
4270 
4271 
4272 
4273 var uniqueId = $.fn.extend( {
4274  uniqueId: ( function() {
4275  var uuid = 0;
4276 
4277  return function() {
4278  return this.each( function() {
4279  if ( !this.id ) {
4280  this.id = "ui-id-" + ( ++uuid );
4281  }
4282  } );
4283  };
4284  } )(),
4285 
4286  removeUniqueId: function() {
4287  return this.each( function() {
4288  if ( /^ui-id-\d+$/.test( this.id ) ) {
4289  $( this ).removeAttr( "id" );
4290  }
4291  } );
4292  }
4293 } );
4294 
4295 
4296 /*!
4297  * jQuery UI Accordion 1.12.1
4298  * http://jqueryui.com
4299  *
4300  * Copyright jQuery Foundation and other contributors
4301  * Released under the MIT license.
4302  * http://jquery.org/license
4303  */
4304 
4305 //>>label: Accordion
4306 //>>group: Widgets
4307 // jscs:disable maximumLineLength
4308 //>>description: Displays collapsible content panels for presenting information in a limited amount of space.
4309 // jscs:enable maximumLineLength
4310 //>>docs: http://api.jqueryui.com/accordion/
4311 //>>demos: http://jqueryui.com/accordion/
4312 //>>css.structure: ../../themes/base/core.css
4313 //>>css.structure: ../../themes/base/accordion.css
4314 //>>css.theme: ../../themes/base/theme.css
4315 
4316 
4317 
4318 var widgetsAccordion = $.widget( "ui.accordion", {
4319  version: "1.12.1",
4320  options: {
4321  active: 0,
4322  animate: {},
4323  classes: {
4324  "ui-accordion-header": "ui-corner-top",
4325  "ui-accordion-header-collapsed": "ui-corner-all",
4326  "ui-accordion-content": "ui-corner-bottom"
4327  },
4328  collapsible: false,
4329  event: "click",
4330  header: "> li > :first-child, > :not(li):even",
4331  heightStyle: "auto",
4332  icons: {
4333  activeHeader: "ui-icon-triangle-1-s",
4334  header: "ui-icon-triangle-1-e"
4335  },
4336 
4337  // Callbacks
4338  activate: null,
4339  beforeActivate: null
4340  },
4341 
4342  hideProps: {
4343  borderTopWidth: "hide",
4344  borderBottomWidth: "hide",
4345  paddingTop: "hide",
4346  paddingBottom: "hide",
4347  height: "hide"
4348  },
4349 
4350  showProps: {
4351  borderTopWidth: "show",
4352  borderBottomWidth: "show",
4353  paddingTop: "show",
4354  paddingBottom: "show",
4355  height: "show"
4356  },
4357 
4358  _create: function() {
4359  var options = this.options;
4360 
4361  this.prevShow = this.prevHide = $();
4362  this._addClass( "ui-accordion", "ui-widget ui-helper-reset" );
4363  this.element.attr( "role", "tablist" );
4364 
4365  // Don't allow collapsible: false and active: false / null
4366  if ( !options.collapsible && ( options.active === false || options.active == null ) ) {
4367  options.active = 0;
4368  }
4369 
4370  this._processPanels();
4371 
4372  // handle negative values
4373  if ( options.active < 0 ) {
4374  options.active += this.headers.length;
4375  }
4376  this._refresh();
4377  },
4378 
4379  _getCreateEventData: function() {
4380  return {
4381  header: this.active,
4382  panel: !this.active.length ? $() : this.active.next()
4383  };
4384  },
4385 
4386  _createIcons: function() {
4387  var icon, children,
4388  icons = this.options.icons;
4389 
4390  if ( icons ) {
4391  icon = $( "<span>" );
4392  this._addClass( icon, "ui-accordion-header-icon", "ui-icon " + icons.header );
4393  icon.prependTo( this.headers );
4394  children = this.active.children( ".ui-accordion-header-icon" );
4395  this._removeClass( children, icons.header )
4396  ._addClass( children, null, icons.activeHeader )
4397  ._addClass( this.headers, "ui-accordion-icons" );
4398  }
4399  },
4400 
4401  _destroyIcons: function() {
4402  this._removeClass( this.headers, "ui-accordion-icons" );
4403  this.headers.children( ".ui-accordion-header-icon" ).remove();
4404  },
4405 
4406  _destroy: function() {
4407  var contents;
4408 
4409  // Clean up main element
4410  this.element.removeAttr( "role" );
4411 
4412  // Clean up headers
4413  this.headers
4414  .removeAttr( "role aria-expanded aria-selected aria-controls tabIndex" )
4415  .removeUniqueId();
4416 
4417  this._destroyIcons();
4418 
4419  // Clean up content panels
4420  contents = this.headers.next()
4421  .css( "display", "" )
4422  .removeAttr( "role aria-hidden aria-labelledby" )
4423  .removeUniqueId();
4424 
4425  if ( this.options.heightStyle !== "content" ) {
4426  contents.css( "height", "" );
4427  }
4428  },
4429 
4430  _setOption: function( key, value ) {
4431  if ( key === "active" ) {
4432 
4433  // _activate() will handle invalid values and update this.options
4434  this._activate( value );
4435  return;
4436  }
4437 
4438  if ( key === "event" ) {
4439  if ( this.options.event ) {
4440  this._off( this.headers, this.options.event );
4441  }
4442  this._setupEvents( value );
4443  }
4444 
4445  this._super( key, value );
4446 
4447  // Setting collapsible: false while collapsed; open first panel
4448  if ( key === "collapsible" && !value && this.options.active === false ) {
4449  this._activate( 0 );
4450  }
4451 
4452  if ( key === "icons" ) {
4453  this._destroyIcons();
4454  if ( value ) {
4455  this._createIcons();
4456  }
4457  }
4458  },
4459 
4460  _setOptionDisabled: function( value ) {
4461  this._super( value );
4462 
4463  this.element.attr( "aria-disabled", value );
4464 
4465  // Support: IE8 Only
4466  // #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
4467  // so we need to add the disabled class to the headers and panels
4468  this._toggleClass( null, "ui-state-disabled", !!value );
4469  this._toggleClass( this.headers.add( this.headers.next() ), null, "ui-state-disabled",
4470  !!value );
4471  },
4472 
4473  _keydown: function( event ) {
4474  if ( event.altKey || event.ctrlKey ) {
4475  return;
4476  }
4477 
4478  var keyCode = $.ui.keyCode,
4479  length = this.headers.length,
4480  currentIndex = this.headers.index( event.target ),
4481  toFocus = false;
4482 
4483  switch ( event.keyCode ) {
4484  case keyCode.RIGHT:
4485  case keyCode.DOWN:
4486  toFocus = this.headers[ ( currentIndex + 1 ) % length ];
4487  break;
4488  case keyCode.LEFT:
4489  case keyCode.UP:
4490  toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
4491  break;
4492  case keyCode.SPACE:
4493  case keyCode.ENTER:
4494  this._eventHandler( event );
4495  break;
4496  case keyCode.HOME:
4497  toFocus = this.headers[ 0 ];
4498  break;
4499  case keyCode.END:
4500  toFocus = this.headers[ length - 1 ];
4501  break;
4502  }
4503 
4504  if ( toFocus ) {
4505  $( event.target ).attr( "tabIndex", -1 );
4506  $( toFocus ).attr( "tabIndex", 0 );
4507  $( toFocus ).trigger( "focus" );
4508  event.preventDefault();
4509  }
4510  },
4511 
4512  _panelKeyDown: function( event ) {
4513  if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
4514  $( event.currentTarget ).prev().trigger( "focus" );
4515  }
4516  },
4517 
4518  refresh: function() {
4519  var options = this.options;
4520  this._processPanels();
4521 
4522  // Was collapsed or no panel
4523  if ( ( options.active === false && options.collapsible === true ) ||
4524  !this.headers.length ) {
4525  options.active = false;
4526  this.active = $();
4527 
4528  // active false only when collapsible is true
4529  } else if ( options.active === false ) {
4530  this._activate( 0 );
4531 
4532  // was active, but active panel is gone
4533  } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
4534 
4535  // all remaining panel are disabled
4536  if ( this.headers.length === this.headers.find( ".ui-state-disabled" ).length ) {
4537  options.active = false;
4538  this.active = $();
4539 
4540  // activate previous panel
4541  } else {
4542  this._activate( Math.max( 0, options.active - 1 ) );
4543  }
4544 
4545  // was active, active panel still exists
4546  } else {
4547 
4548  // make sure active index is correct
4549  options.active = this.headers.index( this.active );
4550  }
4551 
4552  this._destroyIcons();
4553 
4554  this._refresh();
4555  },
4556 
4557  _processPanels: function() {
4558  var prevHeaders = this.headers,
4559  prevPanels = this.panels;
4560 
4561  this.headers = this.element.find( this.options.header );
4562  this._addClass( this.headers, "ui-accordion-header ui-accordion-header-collapsed",
4563  "ui-state-default" );
4564 
4565  this.panels = this.headers.next().filter( ":not(.ui-accordion-content-active)" ).hide();
4566  this._addClass( this.panels, "ui-accordion-content", "ui-helper-reset ui-widget-content" );
4567 
4568  // Avoid memory leaks (#10056)
4569  if ( prevPanels ) {
4570  this._off( prevHeaders.not( this.headers ) );
4571  this._off( prevPanels.not( this.panels ) );
4572  }
4573  },
4574 
4575  _refresh: function() {
4576  var maxHeight,
4577  options = this.options,
4578  heightStyle = options.heightStyle,
4579  parent = this.element.parent();
4580 
4581  this.active = this._findActive( options.active );
4582  this._addClass( this.active, "ui-accordion-header-active", "ui-state-active" )
4583  ._removeClass( this.active, "ui-accordion-header-collapsed" );
4584  this._addClass( this.active.next(), "ui-accordion-content-active" );
4585  this.active.next().show();
4586 
4587  this.headers
4588  .attr( "role", "tab" )
4589  .each( function() {
4590  var header = $( this ),
4591  headerId = header.uniqueId().attr( "id" ),
4592  panel = header.next(),
4593  panelId = panel.uniqueId().attr( "id" );
4594  header.attr( "aria-controls", panelId );
4595  panel.attr( "aria-labelledby", headerId );
4596  } )
4597  .next()
4598  .attr( "role", "tabpanel" );
4599 
4600  this.headers
4601  .not( this.active )
4602  .attr( {
4603  "aria-selected": "false",
4604  "aria-expanded": "false",
4605  tabIndex: -1
4606  } )
4607  .next()
4608  .attr( {
4609  "aria-hidden": "true"
4610  } )
4611  .hide();
4612 
4613  // Make sure at least one header is in the tab order
4614  if ( !this.active.length ) {
4615  this.headers.eq( 0 ).attr( "tabIndex", 0 );
4616  } else {
4617  this.active.attr( {
4618  "aria-selected": "true",
4619  "aria-expanded": "true",
4620  tabIndex: 0
4621  } )
4622  .next()
4623  .attr( {
4624  "aria-hidden": "false"
4625  } );
4626  }
4627 
4628  this._createIcons();
4629 
4630  this._setupEvents( options.event );
4631 
4632  if ( heightStyle === "fill" ) {
4633  maxHeight = parent.height();
4634  this.element.siblings( ":visible" ).each( function() {
4635  var elem = $( this ),
4636  position = elem.css( "position" );
4637 
4638  if ( position === "absolute" || position === "fixed" ) {
4639  return;
4640  }
4641  maxHeight -= elem.outerHeight( true );
4642  } );
4643 
4644  this.headers.each( function() {
4645  maxHeight -= $( this ).outerHeight( true );
4646  } );
4647 
4648  this.headers.next()
4649  .each( function() {
4650  $( this ).height( Math.max( 0, maxHeight -
4651  $( this ).innerHeight() + $( this ).height() ) );
4652  } )
4653  .css( "overflow", "auto" );
4654  } else if ( heightStyle === "auto" ) {
4655  maxHeight = 0;
4656  this.headers.next()
4657  .each( function() {
4658  var isVisible = $( this ).is( ":visible" );
4659  if ( !isVisible ) {
4660  $( this ).show();
4661  }
4662  maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
4663  if ( !isVisible ) {
4664  $( this ).hide();
4665  }
4666  } )
4667  .height( maxHeight );
4668  }
4669  },
4670 
4671  _activate: function( index ) {
4672  var active = this._findActive( index )[ 0 ];
4673 
4674  // Trying to activate the already active panel
4675  if ( active === this.active[ 0 ] ) {
4676  return;
4677  }
4678 
4679  // Trying to collapse, simulate a click on the currently active header
4680  active = active || this.active[ 0 ];
4681 
4682  this._eventHandler( {
4683  target: active,
4684  currentTarget: active,
4685  preventDefault: $.noop
4686  } );
4687  },
4688 
4689  _findActive: function( selector ) {
4690  return typeof selector === "number" ? this.headers.eq( selector ) : $();
4691  },
4692 
4693  _setupEvents: function( event ) {
4694  var events = {
4695  keydown: "_keydown"
4696  };
4697  if ( event ) {
4698  $.each( event.split( " " ), function( index, eventName ) {
4699  events[ eventName ] = "_eventHandler";
4700  } );
4701  }
4702 
4703  this._off( this.headers.add( this.headers.next() ) );
4704  this._on( this.headers, events );
4705  this._on( this.headers.next(), { keydown: "_panelKeyDown" } );
4706  this._hoverable( this.headers );
4707  this._focusable( this.headers );
4708  },
4709 
4710  _eventHandler: function( event ) {
4711  var activeChildren, clickedChildren,
4712  options = this.options,
4713  active = this.active,
4714  clicked = $( event.currentTarget ),
4715  clickedIsActive = clicked[ 0 ] === active[ 0 ],
4716  collapsing = clickedIsActive && options.collapsible,
4717  toShow = collapsing ? $() : clicked.next(),
4718  toHide = active.next(),
4719  eventData = {
4720  oldHeader: active,
4721  oldPanel: toHide,
4722  newHeader: collapsing ? $() : clicked,
4723  newPanel: toShow
4724  };
4725 
4726  event.preventDefault();
4727 
4728  if (
4729 
4730  // click on active header, but not collapsible
4731  ( clickedIsActive && !options.collapsible ) ||
4732 
4733  // allow canceling activation
4734  ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
4735  return;
4736  }
4737 
4738  options.active = collapsing ? false : this.headers.index( clicked );
4739 
4740  // When the call to ._toggle() comes after the class changes
4741  // it causes a very odd bug in IE 8 (see #6720)
4742  this.active = clickedIsActive ? $() : clicked;
4743  this._toggle( eventData );
4744 
4745  // Switch classes
4746  // corner classes on the previously active header stay after the animation
4747  this._removeClass( active, "ui-accordion-header-active", "ui-state-active" );
4748  if ( options.icons ) {
4749  activeChildren = active.children( ".ui-accordion-header-icon" );
4750  this._removeClass( activeChildren, null, options.icons.activeHeader )
4751  ._addClass( activeChildren, null, options.icons.header );
4752  }
4753 
4754  if ( !clickedIsActive ) {
4755  this._removeClass( clicked, "ui-accordion-header-collapsed" )
4756  ._addClass( clicked, "ui-accordion-header-active", "ui-state-active" );
4757  if ( options.icons ) {
4758  clickedChildren = clicked.children( ".ui-accordion-header-icon" );
4759  this._removeClass( clickedChildren, null, options.icons.header )
4760  ._addClass( clickedChildren, null, options.icons.activeHeader );
4761  }
4762 
4763  this._addClass( clicked.next(), "ui-accordion-content-active" );
4764  }
4765  },
4766 
4767  _toggle: function( data ) {
4768  var toShow = data.newPanel,
4769  toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
4770 
4771  // Handle activating a panel during the animation for another activation
4772  this.prevShow.add( this.prevHide ).stop( true, true );
4773  this.prevShow = toShow;
4774  this.prevHide = toHide;
4775 
4776  if ( this.options.animate ) {
4777  this._animate( toShow, toHide, data );
4778  } else {
4779  toHide.hide();
4780  toShow.show();
4781  this._toggleComplete( data );
4782  }
4783 
4784  toHide.attr( {
4785  "aria-hidden": "true"
4786  } );
4787  toHide.prev().attr( {
4788  "aria-selected": "false",
4789  "aria-expanded": "false"
4790  } );
4791 
4792  // if we're switching panels, remove the old header from the tab order
4793  // if we're opening from collapsed state, remove the previous header from the tab order
4794  // if we're collapsing, then keep the collapsing header in the tab order
4795  if ( toShow.length && toHide.length ) {
4796  toHide.prev().attr( {
4797  "tabIndex": -1,
4798  "aria-expanded": "false"
4799  } );
4800  } else if ( toShow.length ) {
4801  this.headers.filter( function() {
4802  return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
4803  } )
4804  .attr( "tabIndex", -1 );
4805  }
4806 
4807  toShow
4808  .attr( "aria-hidden", "false" )
4809  .prev()
4810  .attr( {
4811  "aria-selected": "true",
4812  "aria-expanded": "true",
4813  tabIndex: 0
4814  } );
4815  },
4816 
4817  _animate: function( toShow, toHide, data ) {
4818  var total, easing, duration,
4819  that = this,
4820  adjust = 0,
4821  boxSizing = toShow.css( "box-sizing" ),
4822  down = toShow.length &&
4823  ( !toHide.length || ( toShow.index() < toHide.index() ) ),
4824  animate = this.options.animate || {},
4825  options = down && animate.down || animate,
4826  complete = function() {
4827  that._toggleComplete( data );
4828  };
4829 
4830  if ( typeof options === "number" ) {
4831  duration = options;
4832  }
4833  if ( typeof options === "string" ) {
4834  easing = options;
4835  }
4836 
4837  // fall back from options to animation in case of partial down settings
4838  easing = easing || options.easing || animate.easing;
4839  duration = duration || options.duration || animate.duration;
4840 
4841  if ( !toHide.length ) {
4842  return toShow.animate( this.showProps, duration, easing, complete );
4843  }
4844  if ( !toShow.length ) {
4845  return toHide.animate( this.hideProps, duration, easing, complete );
4846  }
4847 
4848  total = toShow.show().outerHeight();
4849  toHide.animate( this.hideProps, {
4850  duration: duration,
4851  easing: easing,
4852  step: function( now, fx ) {
4853  fx.now = Math.round( now );
4854  }
4855  } );
4856  toShow
4857  .hide()
4858  .animate( this.showProps, {
4859  duration: duration,
4860  easing: easing,
4861  complete: complete,
4862  step: function( now, fx ) {
4863  fx.now = Math.round( now );
4864  if ( fx.prop !== "height" ) {
4865  if ( boxSizing === "content-box" ) {
4866  adjust += fx.now;
4867  }
4868  } else if ( that.options.heightStyle !== "content" ) {
4869  fx.now = Math.round( total - toHide.outerHeight() - adjust );
4870  adjust = 0;
4871  }
4872  }
4873  } );
4874  },
4875 
4876  _toggleComplete: function( data ) {
4877  var toHide = data.oldPanel,
4878  prev = toHide.prev();
4879 
4880  this._removeClass( toHide, "ui-accordion-content-active" );
4881  this._removeClass( prev, "ui-accordion-header-active" )
4882  ._addClass( prev, "ui-accordion-header-collapsed" );
4883 
4884  // Work around for rendering bug in IE (#5421)
4885  if ( toHide.length ) {
4886  toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
4887  }
4888  this._trigger( "activate", null, data );
4889  }
4890 } );
4891 
4892 
4893 
4894 var safeActiveElement = $.ui.safeActiveElement = function( document ) {
4895  var activeElement;
4896 
4897  // Support: IE 9 only
4898  // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
4899  try {
4900  activeElement = document.activeElement;
4901  } catch ( error ) {
4902  activeElement = document.body;
4903  }
4904 
4905  // Support: IE 9 - 11 only
4906  // IE may return null instead of an element
4907  // Interestingly, this only seems to occur when NOT in an iframe
4908  if ( !activeElement ) {
4909  activeElement = document.body;
4910  }
4911 
4912  // Support: IE 11 only
4913  // IE11 returns a seemingly empty object in some cases when accessing
4914  // document.activeElement from an <iframe>
4915  if ( !activeElement.nodeName ) {
4916  activeElement = document.body;
4917  }
4918 
4919  return activeElement;
4920 };
4921 
4922 
4923 /*!
4924  * jQuery UI Menu 1.12.1
4925  * http://jqueryui.com
4926  *
4927  * Copyright jQuery Foundation and other contributors
4928  * Released under the MIT license.
4929  * http://jquery.org/license
4930  */
4931 
4932 //>>label: Menu
4933 //>>group: Widgets
4934 //>>description: Creates nestable menus.
4935 //>>docs: http://api.jqueryui.com/menu/
4936 //>>demos: http://jqueryui.com/menu/
4937 //>>css.structure: ../../themes/base/core.css
4938 //>>css.structure: ../../themes/base/menu.css
4939 //>>css.theme: ../../themes/base/theme.css
4940 
4941 
4942 
4943 var widgetsMenu = $.widget( "ui.menu", {
4944  version: "1.12.1",
4945  defaultElement: "<ul>",
4946  delay: 300,
4947  options: {
4948  icons: {
4949  submenu: "ui-icon-caret-1-e"
4950  },
4951  items: "> *",
4952  menus: "ul",
4953  position: {
4954  my: "left top",
4955  at: "right top"
4956  },
4957  role: "menu",
4958 
4959  // Callbacks
4960  blur: null,
4961  focus: null,
4962  select: null
4963  },
4964 
4965  _create: function() {
4966  this.activeMenu = this.element;
4967 
4968  // Flag used to prevent firing of the click handler
4969  // as the event bubbles up through nested menus
4970  this.mouseHandled = false;
4971  this.element
4972  .uniqueId()
4973  .attr( {
4974  role: this.options.role,
4975  tabIndex: 0
4976  } );
4977 
4978  this._addClass( "ui-menu", "ui-widget ui-widget-content" );
4979  this._on( {
4980 
4981  // Prevent focus from sticking to links inside menu after clicking
4982  // them (focus should always stay on UL during navigation).
4983  "mousedown .ui-menu-item": function( event ) {
4984  event.preventDefault();
4985  },
4986  "click .ui-menu-item": function( event ) {
4987  var target = $( event.target );
4988  var active = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
4989  if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
4990  this.select( event );
4991 
4992  // Only set the mouseHandled flag if the event will bubble, see #9469.
4993  if ( !event.isPropagationStopped() ) {
4994  this.mouseHandled = true;
4995  }
4996 
4997  // Open submenu on click
4998  if ( target.has( ".ui-menu" ).length ) {
4999  this.expand( event );
5000  } else if ( !this.element.is( ":focus" ) &&
5001  active.closest( ".ui-menu" ).length ) {
5002 
5003  // Redirect focus to the menu
5004  this.element.trigger( "focus", [ true ] );
5005 
5006  // If the active item is on the top level, let it stay active.
5007  // Otherwise, blur the active item since it is no longer visible.
5008  if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
5009  clearTimeout( this.timer );
5010  }
5011  }
5012  }
5013  },
5014  "mouseenter .ui-menu-item": function( event ) {
5015 
5016  // Ignore mouse events while typeahead is active, see #10458.
5017  // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
5018  // is over an item in the menu
5019  if ( this.previousFilter ) {
5020  return;
5021  }
5022 
5023  var actualTarget = $( event.target ).closest( ".ui-menu-item" ),
5024  target = $( event.currentTarget );
5025 
5026  // Ignore bubbled events on parent items, see #11641
5027  if ( actualTarget[ 0 ] !== target[ 0 ] ) {
5028  return;
5029  }
5030 
5031  // Remove ui-state-active class from siblings of the newly focused menu item
5032  // to avoid a jump caused by adjacent elements both having a class with a border
5033  this._removeClass( target.siblings().children( ".ui-state-active" ),
5034  null, "ui-state-active" );
5035  this.focus( event, target );
5036  },
5037  mouseleave: "collapseAll",
5038  "mouseleave .ui-menu": "collapseAll",
5039  focus: function( event, keepActiveItem ) {
5040 
5041  // If there's already an active item, keep it active
5042  // If not, activate the first item
5043  var item = this.active || this.element.find( this.options.items ).eq( 0 );
5044 
5045  if ( !keepActiveItem ) {
5046  this.focus( event, item );
5047  }
5048  },
5049  blur: function( event ) {
5050  this._delay( function() {
5051  var notContained = !$.contains(
5052  this.element[ 0 ],
5053  $.ui.safeActiveElement( this.document[ 0 ] )
5054  );
5055  if ( notContained ) {
5056  this.collapseAll( event );
5057  }
5058  } );
5059  },
5060  keydown: "_keydown"
5061  } );
5062 
5063  this.refresh();
5064 
5065  // Clicks outside of a menu collapse any open menus
5066  this._on( this.document, {
5067  click: function( event ) {
5068  if ( this._closeOnDocumentClick( event ) ) {
5069  this.collapseAll( event );
5070  }
5071 
5072  // Reset the mouseHandled flag
5073  this.mouseHandled = false;
5074  }
5075  } );
5076  },
5077 
5078  _destroy: function() {
5079  var items = this.element.find( ".ui-menu-item" )
5080  .removeAttr( "role aria-disabled" ),
5081  submenus = items.children( ".ui-menu-item-wrapper" )
5082  .removeUniqueId()
5083  .removeAttr( "tabIndex role aria-haspopup" );
5084 
5085  // Destroy (sub)menus
5086  this.element
5087  .removeAttr( "aria-activedescendant" )
5088  .find( ".ui-menu" ).addBack()
5089  .removeAttr( "role aria-labelledby aria-expanded aria-hidden aria-disabled " +
5090  "tabIndex" )
5091  .removeUniqueId()
5092  .show();
5093 
5094  submenus.children().each( function() {
5095  var elem = $( this );
5096  if ( elem.data( "ui-menu-submenu-caret" ) ) {
5097  elem.remove();
5098  }
5099  } );
5100  },
5101 
5102  _keydown: function( event ) {
5103  var match, prev, character, skip,
5104  preventDefault = true;
5105 
5106  switch ( event.keyCode ) {
5107  case $.ui.keyCode.PAGE_UP:
5108  this.previousPage( event );
5109  break;
5110  case $.ui.keyCode.PAGE_DOWN:
5111  this.nextPage( event );
5112  break;
5113  case $.ui.keyCode.HOME:
5114  this._move( "first", "first", event );
5115  break;
5116  case $.ui.keyCode.END:
5117  this._move( "last", "last", event );
5118  break;
5119  case $.ui.keyCode.UP:
5120  this.previous( event );
5121  break;
5122  case $.ui.keyCode.DOWN:
5123  this.next( event );
5124  break;
5125  case $.ui.keyCode.LEFT:
5126  this.collapse( event );
5127  break;
5128  case $.ui.keyCode.RIGHT:
5129  if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
5130  this.expand( event );
5131  }
5132  break;
5133  case $.ui.keyCode.ENTER:
5134  case $.ui.keyCode.SPACE:
5135  this._activate( event );
5136  break;
5137  case $.ui.keyCode.ESCAPE:
5138  this.collapse( event );
5139  break;
5140  default:
5141  preventDefault = false;
5142  prev = this.previousFilter || "";
5143  skip = false;
5144 
5145  // Support number pad values
5146  character = event.keyCode >= 96 && event.keyCode <= 105 ?
5147  ( event.keyCode - 96 ).toString() : String.fromCharCode( event.keyCode );
5148 
5149  clearTimeout( this.filterTimer );
5150 
5151  if ( character === prev ) {
5152  skip = true;
5153  } else {
5154  character = prev + character;
5155  }
5156 
5157  match = this._filterMenuItems( character );
5158  match = skip && match.index( this.active.next() ) !== -1 ?
5159  this.active.nextAll( ".ui-menu-item" ) :
5160  match;
5161 
5162  // If no matches on the current filter, reset to the last character pressed
5163  // to move down the menu to the first item that starts with that character
5164  if ( !match.length ) {
5165  character = String.fromCharCode( event.keyCode );
5166  match = this._filterMenuItems( character );
5167  }
5168 
5169  if ( match.length ) {
5170  this.focus( event, match );
5171  this.previousFilter = character;
5172  this.filterTimer = this._delay( function() {
5173  delete this.previousFilter;
5174  }, 1000 );
5175  } else {
5176  delete this.previousFilter;
5177  }
5178  }
5179 
5180  if ( preventDefault ) {
5181  event.preventDefault();
5182  }
5183  },
5184 
5185  _activate: function( event ) {
5186  if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
5187  if ( this.active.children( "[aria-haspopup='true']" ).length ) {
5188  this.expand( event );
5189  } else {
5190  this.select( event );
5191  }
5192  }
5193  },
5194 
5195  refresh: function() {
5196  var menus, items, newSubmenus, newItems, newWrappers,
5197  that = this,
5198  icon = this.options.icons.submenu,
5199  submenus = this.element.find( this.options.menus );
5200 
5201  this._toggleClass( "ui-menu-icons", null, !!this.element.find( ".ui-icon" ).length );
5202 
5203  // Initialize nested menus
5204  newSubmenus = submenus.filter( ":not(.ui-menu)" )
5205  .hide()
5206  .attr( {
5207  role: this.options.role,
5208  "aria-hidden": "true",
5209  "aria-expanded": "false"
5210  } )
5211  .each( function() {
5212  var menu = $( this ),
5213  item = menu.prev(),
5214  submenuCaret = $( "<span>" ).data( "ui-menu-submenu-caret", true );
5215 
5216  that._addClass( submenuCaret, "ui-menu-icon", "ui-icon " + icon );
5217  item
5218  .attr( "aria-haspopup", "true" )
5219  .prepend( submenuCaret );
5220  menu.attr( "aria-labelledby", item.attr( "id" ) );
5221  } );
5222 
5223  this._addClass( newSubmenus, "ui-menu", "ui-widget ui-widget-content ui-front" );
5224 
5225  menus = submenus.add( this.element );
5226  items = menus.find( this.options.items );
5227 
5228  // Initialize menu-items containing spaces and/or dashes only as dividers
5229  items.not( ".ui-menu-item" ).each( function() {
5230  var item = $( this );
5231  if ( that._isDivider( item ) ) {
5232  that._addClass( item, "ui-menu-divider", "ui-widget-content" );
5233  }
5234  } );
5235 
5236  // Don't refresh list items that are already adapted
5237  newItems = items.not( ".ui-menu-item, .ui-menu-divider" );
5238  newWrappers = newItems.children()
5239  .not( ".ui-menu" )
5240  .uniqueId()
5241  .attr( {
5242  tabIndex: -1,
5243  role: this._itemRole()
5244  } );
5245  this._addClass( newItems, "ui-menu-item" )
5246  ._addClass( newWrappers, "ui-menu-item-wrapper" );
5247 
5248  // Add aria-disabled attribute to any disabled menu item
5249  items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
5250 
5251  // If the active item has been removed, blur the menu
5252  if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
5253  this.blur();
5254  }
5255  },
5256 
5257  _itemRole: function() {
5258  return {
5259  menu: "menuitem",
5260  listbox: "option"
5261  }[ this.options.role ];
5262  },
5263 
5264  _setOption: function( key, value ) {
5265  if ( key === "icons" ) {
5266  var icons = this.element.find( ".ui-menu-icon" );
5267  this._removeClass( icons, null, this.options.icons.submenu )
5268  ._addClass( icons, null, value.submenu );
5269  }
5270  this._super( key, value );
5271  },
5272 
5273  _setOptionDisabled: function( value ) {
5274  this._super( value );
5275 
5276  this.element.attr( "aria-disabled", String( value ) );
5277  this._toggleClass( null, "ui-state-disabled", !!value );
5278  },
5279 
5280  focus: function( event, item ) {
5281  var nested, focused, activeParent;
5282  this.blur( event, event && event.type === "focus" );
5283 
5284  this._scrollIntoView( item );
5285 
5286  this.active = item.first();
5287 
5288  focused = this.active.children( ".ui-menu-item-wrapper" );
5289  this._addClass( focused, null, "ui-state-active" );
5290 
5291  // Only update aria-activedescendant if there's a role
5292  // otherwise we assume focus is managed elsewhere
5293  if ( this.options.role ) {
5294  this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
5295  }
5296 
5297  // Highlight active parent menu item, if any
5298  activeParent = this.active
5299  .parent()
5300  .closest( ".ui-menu-item" )
5301  .children( ".ui-menu-item-wrapper" );
5302  this._addClass( activeParent, null, "ui-state-active" );
5303 
5304  if ( event && event.type === "keydown" ) {
5305  this._close();
5306  } else {
5307  this.timer = this._delay( function() {
5308  this._close();
5309  }, this.delay );
5310  }
5311 
5312  nested = item.children( ".ui-menu" );
5313  if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
5314  this._startOpening( nested );
5315  }
5316  this.activeMenu = item.parent();
5317 
5318  this._trigger( "focus", event, { item: item } );
5319  },
5320 
5321  _scrollIntoView: function( item ) {
5322  var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
5323  if ( this._hasScroll() ) {
5324  borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0;
5325  paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0;
5326  offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
5327  scroll = this.activeMenu.scrollTop();
5328  elementHeight = this.activeMenu.height();
5329  itemHeight = item.outerHeight();
5330 
5331  if ( offset < 0 ) {
5332  this.activeMenu.scrollTop( scroll + offset );
5333  } else if ( offset + itemHeight > elementHeight ) {
5334  this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
5335  }
5336  }
5337  },
5338 
5339  blur: function( event, fromFocus ) {
5340  if ( !fromFocus ) {
5341  clearTimeout( this.timer );
5342  }
5343 
5344  if ( !this.active ) {
5345  return;
5346  }
5347 
5348  this._removeClass( this.active.children( ".ui-menu-item-wrapper" ),
5349  null, "ui-state-active" );
5350 
5351  this._trigger( "blur", event, { item: this.active } );
5352  this.active = null;
5353  },
5354 
5355  _startOpening: function( submenu ) {
5356  clearTimeout( this.timer );
5357 
5358  // Don't open if already open fixes a Firefox bug that caused a .5 pixel
5359  // shift in the submenu position when mousing over the caret icon
5360  if ( submenu.attr( "aria-hidden" ) !== "true" ) {
5361  return;
5362  }
5363 
5364  this.timer = this._delay( function() {
5365  this._close();
5366  this._open( submenu );
5367  }, this.delay );
5368  },
5369 
5370  _open: function( submenu ) {
5371  var position = $.extend( {
5372  of: this.active
5373  }, this.options.position );
5374 
5375  clearTimeout( this.timer );
5376  this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
5377  .hide()
5378  .attr( "aria-hidden", "true" );
5379 
5380  submenu
5381  .show()
5382  .removeAttr( "aria-hidden" )
5383  .attr( "aria-expanded", "true" )
5384  .position( position );
5385  },
5386 
5387  collapseAll: function( event, all ) {
5388  clearTimeout( this.timer );
5389  this.timer = this._delay( function() {
5390 
5391  // If we were passed an event, look for the submenu that contains the event
5392  var currentMenu = all ? this.element :
5393  $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
5394 
5395  // If we found no valid submenu ancestor, use the main menu to close all
5396  // sub menus anyway
5397  if ( !currentMenu.length ) {
5398  currentMenu = this.element;
5399  }
5400 
5401  this._close( currentMenu );
5402 
5403  this.blur( event );
5404 
5405  // Work around active item staying active after menu is blurred
5406  this._removeClass( currentMenu.find( ".ui-state-active" ), null, "ui-state-active" );
5407 
5408  this.activeMenu = currentMenu;
5409  }, this.delay );
5410  },
5411 
5412  // With no arguments, closes the currently active menu - if nothing is active
5413  // it closes all menus. If passed an argument, it will search for menus BELOW
5414  _close: function( startMenu ) {
5415  if ( !startMenu ) {
5416  startMenu = this.active ? this.active.parent() : this.element;
5417  }
5418 
5419  startMenu.find( ".ui-menu" )
5420  .hide()
5421  .attr( "aria-hidden", "true" )
5422  .attr( "aria-expanded", "false" );
5423  },
5424 
5425  _closeOnDocumentClick: function( event ) {
5426  return !$( event.target ).closest( ".ui-menu" ).length;
5427  },
5428 
5429  _isDivider: function( item ) {
5430 
5431  // Match hyphen, em dash, en dash
5432  return !/[^\-\u2014\u2013\s]/.test( item.text() );
5433  },
5434 
5435  collapse: function( event ) {
5436  var newItem = this.active &&
5437  this.active.parent().closest( ".ui-menu-item", this.element );
5438  if ( newItem && newItem.length ) {
5439  this._close();
5440  this.focus( event, newItem );
5441  }
5442  },
5443 
5444  expand: function( event ) {
5445  var newItem = this.active &&
5446  this.active
5447  .children( ".ui-menu " )
5448  .find( this.options.items )
5449  .first();
5450 
5451  if ( newItem && newItem.length ) {
5452  this._open( newItem.parent() );
5453 
5454  // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
5455  this._delay( function() {
5456  this.focus( event, newItem );
5457  } );
5458  }
5459  },
5460 
5461  next: function( event ) {
5462  this._move( "next", "first", event );
5463  },
5464 
5465  previous: function( event ) {
5466  this._move( "prev", "last", event );
5467  },
5468 
5469  isFirstItem: function() {
5470  return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
5471  },
5472 
5473  isLastItem: function() {
5474  return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
5475  },
5476 
5477  _move: function( direction, filter, event ) {
5478  var next;
5479  if ( this.active ) {
5480  if ( direction === "first" || direction === "last" ) {
5481  next = this.active
5482  [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
5483  .eq( -1 );
5484  } else {
5485  next = this.active
5486  [ direction + "All" ]( ".ui-menu-item" )
5487  .eq( 0 );
5488  }
5489  }
5490  if ( !next || !next.length || !this.active ) {
5491  next = this.activeMenu.find( this.options.items )[ filter ]();
5492  }
5493 
5494  this.focus( event, next );
5495  },
5496 
5497  nextPage: function( event ) {
5498  var item, base, height;
5499 
5500  if ( !this.active ) {
5501  this.next( event );
5502  return;
5503  }
5504  if ( this.isLastItem() ) {
5505  return;
5506  }
5507  if ( this._hasScroll() ) {
5508  base = this.active.offset().top;
5509  height = this.element.height();
5510  this.active.nextAll( ".ui-menu-item" ).each( function() {
5511  item = $( this );
5512  return item.offset().top - base - height < 0;
5513  } );
5514 
5515  this.focus( event, item );
5516  } else {
5517  this.focus( event, this.activeMenu.find( this.options.items )
5518  [ !this.active ? "first" : "last" ]() );
5519  }
5520  },
5521 
5522  previousPage: function( event ) {
5523  var item, base, height;
5524  if ( !this.active ) {
5525  this.next( event );
5526  return;
5527  }
5528  if ( this.isFirstItem() ) {
5529  return;
5530  }
5531  if ( this._hasScroll() ) {
5532  base = this.active.offset().top;
5533  height = this.element.height();
5534  this.active.prevAll( ".ui-menu-item" ).each( function() {
5535  item = $( this );
5536  return item.offset().top - base + height > 0;
5537  } );
5538 
5539  this.focus( event, item );
5540  } else {
5541  this.focus( event, this.activeMenu.find( this.options.items ).first() );
5542  }
5543  },
5544 
5545  _hasScroll: function() {
5546  return this.element.outerHeight() < this.element.prop( "scrollHeight" );
5547  },
5548 
5549  select: function( event ) {
5550 
5551  // TODO: It should never be possible to not have an active item at this
5552  // point, but the tests don't trigger mouseenter before click.
5553  this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
5554  var ui = { item: this.active };
5555  if ( !this.active.has( ".ui-menu" ).length ) {
5556  this.collapseAll( event, true );
5557  }
5558  this._trigger( "select", event, ui );
5559  },
5560 
5561  _filterMenuItems: function( character ) {
5562  var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
5563  regex = new RegExp( "^" + escapedCharacter, "i" );
5564 
5565  return this.activeMenu
5566  .find( this.options.items )
5567 
5568  // Only match on items, not dividers or other content (#10571)
5569  .filter( ".ui-menu-item" )
5570  .filter( function() {
5571  return regex.test(
5572  $.trim( $( this ).children( ".ui-menu-item-wrapper" ).text() ) );
5573  } );
5574  }
5575 } );
5576 
5577 
5578 /*!
5579  * jQuery UI Autocomplete 1.12.1
5580  * http://jqueryui.com
5581  *
5582  * Copyright jQuery Foundation and other contributors
5583  * Released under the MIT license.
5584  * http://jquery.org/license
5585  */
5586 
5587 //>>label: Autocomplete
5588 //>>group: Widgets
5589 //>>description: Lists suggested words as the user is typing.
5590 //>>docs: http://api.jqueryui.com/autocomplete/
5591 //>>demos: http://jqueryui.com/autocomplete/
5592 //>>css.structure: ../../themes/base/core.css
5593 //>>css.structure: ../../themes/base/autocomplete.css
5594 //>>css.theme: ../../themes/base/theme.css
5595 
5596 
5597 
5598 $.widget( "ui.autocomplete", {
5599  version: "1.12.1",
5600  defaultElement: "<input>",
5601  options: {
5602  appendTo: null,
5603  autoFocus: false,
5604  delay: 300,
5605  minLength: 1,
5606  position: {
5607  my: "left top",
5608  at: "left bottom",
5609  collision: "none"
5610  },
5611  source: null,
5612 
5613  // Callbacks
5614  change: null,
5615  close: null,
5616  focus: null,
5617  open: null,
5618  response: null,
5619  search: null,
5620  select: null
5621  },
5622 
5623  requestIndex: 0,
5624  pending: 0,
5625 
5626  _create: function() {
5627 
5628  // Some browsers only repeat keydown events, not keypress events,
5629  // so we use the suppressKeyPress flag to determine if we've already
5630  // handled the keydown event. #7269
5631  // Unfortunately the code for & in keypress is the same as the up arrow,
5632  // so we use the suppressKeyPressRepeat flag to avoid handling keypress
5633  // events when we know the keydown event was used to modify the
5634  // search term. #7799
5635  var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
5636  nodeName = this.element[ 0 ].nodeName.toLowerCase(),
5637  isTextarea = nodeName === "textarea",
5638  isInput = nodeName === "input";
5639 
5640  // Textareas are always multi-line
5641  // Inputs are always single-line, even if inside a contentEditable element
5642  // IE also treats inputs as contentEditable
5643  // All other element types are determined by whether or not they're contentEditable
5644  this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );
5645 
5646  this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
5647  this.isNewMenu = true;
5648 
5649  this._addClass( "ui-autocomplete-input" );
5650  this.element.attr( "autocomplete", "off" );
5651 
5652  this._on( this.element, {
5653  keydown: function( event ) {
5654  if ( this.element.prop( "readOnly" ) ) {
5655  suppressKeyPress = true;
5656  suppressInput = true;
5657  suppressKeyPressRepeat = true;
5658  return;
5659  }
5660 
5661  suppressKeyPress = false;
5662  suppressInput = false;
5663  suppressKeyPressRepeat = false;
5664  var keyCode = $.ui.keyCode;
5665  switch ( event.keyCode ) {
5666  case keyCode.PAGE_UP:
5667  suppressKeyPress = true;
5668  this._move( "previousPage", event );
5669  break;
5670  case keyCode.PAGE_DOWN:
5671  suppressKeyPress = true;
5672  this._move( "nextPage", event );
5673  break;
5674  case keyCode.UP:
5675  suppressKeyPress = true;
5676  this._keyEvent( "previous", event );
5677  break;
5678  case keyCode.DOWN:
5679  suppressKeyPress = true;
5680  this._keyEvent( "next", event );
5681  break;
5682  case keyCode.ENTER:
5683 
5684  // when menu is open and has focus
5685  if ( this.menu.active ) {
5686 
5687  // #6055 - Opera still allows the keypress to occur
5688  // which causes forms to submit
5689  suppressKeyPress = true;
5690  event.preventDefault();
5691  this.menu.select( event );
5692  }
5693  break;
5694  case keyCode.TAB:
5695  if ( this.menu.active ) {
5696  this.menu.select( event );
5697  }
5698  break;
5699  case keyCode.ESCAPE:
5700  if ( this.menu.element.is( ":visible" ) ) {
5701  if ( !this.isMultiLine ) {
5702  this._value( this.term );
5703  }
5704  this.close( event );
5705 
5706  // Different browsers have different default behavior for escape
5707  // Single press can mean undo or clear
5708  // Double press in IE means clear the whole form
5709  event.preventDefault();
5710  }
5711  break;
5712  default:
5713  suppressKeyPressRepeat = true;
5714 
5715  // search timeout should be triggered before the input value is changed
5716  this._searchTimeout( event );
5717  break;
5718  }
5719  },
5720  keypress: function( event ) {
5721  if ( suppressKeyPress ) {
5722  suppressKeyPress = false;
5723  if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
5724  event.preventDefault();
5725  }
5726  return;
5727  }
5728  if ( suppressKeyPressRepeat ) {
5729  return;
5730  }
5731 
5732  // Replicate some key handlers to allow them to repeat in Firefox and Opera
5733  var keyCode = $.ui.keyCode;
5734  switch ( event.keyCode ) {
5735  case keyCode.PAGE_UP:
5736  this._move( "previousPage", event );
5737  break;
5738  case keyCode.PAGE_DOWN:
5739  this._move( "nextPage", event );
5740  break;
5741  case keyCode.UP:
5742  this._keyEvent( "previous", event );
5743  break;
5744  case keyCode.DOWN:
5745  this._keyEvent( "next", event );
5746  break;
5747  }
5748  },
5749  input: function( event ) {
5750  if ( suppressInput ) {
5751  suppressInput = false;
5752  event.preventDefault();
5753  return;
5754  }
5755  this._searchTimeout( event );
5756  },
5757  focus: function() {
5758  this.selectedItem = null;
5759  this.previous = this._value();
5760  },
5761  blur: function( event ) {
5762  if ( this.cancelBlur ) {
5763  delete this.cancelBlur;
5764  return;
5765  }
5766 
5767  clearTimeout( this.searching );
5768  this.close( event );
5769  this._change( event );
5770  }
5771  } );
5772 
5773  this._initSource();
5774  this.menu = $( "<ul>" )
5775  .appendTo( this._appendTo() )
5776  .menu( {
5777 
5778  // disable ARIA support, the live region takes care of that
5779  role: null
5780  } )
5781  .hide()
5782  .menu( "instance" );
5783 
5784  this._addClass( this.menu.element, "ui-autocomplete", "ui-front" );
5785  this._on( this.menu.element, {
5786  mousedown: function( event ) {
5787 
5788  // prevent moving focus out of the text field
5789  event.preventDefault();
5790 
5791  // IE doesn't prevent moving focus even with event.preventDefault()
5792  // so we set a flag to know when we should ignore the blur event
5793  this.cancelBlur = true;
5794  this._delay( function() {
5795  delete this.cancelBlur;
5796 
5797  // Support: IE 8 only
5798  // Right clicking a menu item or selecting text from the menu items will
5799  // result in focus moving out of the input. However, we've already received
5800  // and ignored the blur event because of the cancelBlur flag set above. So
5801  // we restore focus to ensure that the menu closes properly based on the user's
5802  // next actions.
5803  if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
5804  this.element.trigger( "focus" );
5805  }
5806  } );
5807  },
5808  menufocus: function( event, ui ) {
5809  var label, item;
5810 
5811  // support: Firefox
5812  // Prevent accidental activation of menu items in Firefox (#7024 #9118)
5813  if ( this.isNewMenu ) {
5814  this.isNewMenu = false;
5815  if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
5816  this.menu.blur();
5817 
5818  this.document.one( "mousemove", function() {
5819  $( event.target ).trigger( event.originalEvent );
5820  } );
5821 
5822  return;
5823  }
5824  }
5825 
5826  item = ui.item.data( "ui-autocomplete-item" );
5827  if ( false !== this._trigger( "focus", event, { item: item } ) ) {
5828 
5829  // use value to match what will end up in the input, if it was a key event
5830  if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
5831  this._value( item.value );
5832  }
5833  }
5834 
5835  // Announce the value in the liveRegion
5836  label = ui.item.attr( "aria-label" ) || item.value;
5837  if ( label && $.trim( label ).length ) {
5838  this.liveRegion.children().hide();
5839  $( "<div>" ).text( label ).appendTo( this.liveRegion );
5840  }
5841  },
5842  menuselect: function( event, ui ) {
5843  var item = ui.item.data( "ui-autocomplete-item" ),
5844  previous = this.previous;
5845 
5846  // Only trigger when focus was lost (click on menu)
5847  if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
5848  this.element.trigger( "focus" );
5849  this.previous = previous;
5850 
5851  // #6109 - IE triggers two focus events and the second
5852  // is asynchronous, so we need to reset the previous
5853  // term synchronously and asynchronously :-(
5854  this._delay( function() {
5855  this.previous = previous;
5856  this.selectedItem = item;
5857  } );
5858  }
5859 
5860  if ( false !== this._trigger( "select", event, { item: item } ) ) {
5861  this._value( item.value );
5862  }
5863 
5864  // reset the term after the select event
5865  // this allows custom select handling to work properly
5866  this.term = this._value();
5867 
5868  this.close( event );
5869  this.selectedItem = item;
5870  }
5871  } );
5872 
5873  this.liveRegion = $( "<div>", {
5874  role: "status",
5875  "aria-live": "assertive",
5876  "aria-relevant": "additions"
5877  } )
5878  .appendTo( this.document[ 0 ].body );
5879 
5880  this._addClass( this.liveRegion, null, "ui-helper-hidden-accessible" );
5881 
5882  // Turning off autocomplete prevents the browser from remembering the
5883  // value when navigating through history, so we re-enable autocomplete
5884  // if the page is unloaded before the widget is destroyed. #7790
5885  this._on( this.window, {
5886  beforeunload: function() {
5887  this.element.removeAttr( "autocomplete" );
5888  }
5889  } );
5890  },
5891 
5892  _destroy: function() {
5893  clearTimeout( this.searching );
5894  this.element.removeAttr( "autocomplete" );
5895  this.menu.element.remove();
5896  this.liveRegion.remove();
5897  },
5898 
5899  _setOption: function( key, value ) {
5900  this._super( key, value );
5901  if ( key === "source" ) {
5902  this._initSource();
5903  }
5904  if ( key === "appendTo" ) {
5905  this.menu.element.appendTo( this._appendTo() );
5906  }
5907  if ( key === "disabled" && value && this.xhr ) {
5908  this.xhr.abort();
5909  }
5910  },
5911 
5912  _isEventTargetInWidget: function( event ) {
5913  var menuElement = this.menu.element[ 0 ];
5914 
5915  return event.target === this.element[ 0 ] ||
5916  event.target === menuElement ||
5917  $.contains( menuElement, event.target );
5918  },
5919 
5920  _closeOnClickOutside: function( event ) {
5921  if ( !this._isEventTargetInWidget( event ) ) {
5922  this.close();
5923  }
5924  },
5925 
5926  _appendTo: function() {
5927  var element = this.options.appendTo;
5928 
5929  if ( element ) {
5930  element = element.jquery || element.nodeType ?
5931  $( element ) :
5932  this.document.find( element ).eq( 0 );
5933  }
5934 
5935  if ( !element || !element[ 0 ] ) {
5936  element = this.element.closest( ".ui-front, dialog" );
5937  }
5938 
5939  if ( !element.length ) {
5940  element = this.document[ 0 ].body;
5941  }
5942 
5943  return element;
5944  },
5945 
5946  _initSource: function() {
5947  var array, url,
5948  that = this;
5949  if ( $.isArray( this.options.source ) ) {
5950  array = this.options.source;
5951  this.source = function( request, response ) {
5952  response( $.ui.autocomplete.filter( array, request.term ) );
5953  };
5954  } else if ( typeof this.options.source === "string" ) {
5955  url = this.options.source;
5956  this.source = function( request, response ) {
5957  if ( that.xhr ) {
5958  that.xhr.abort();
5959  }
5960  that.xhr = $.ajax( {
5961  url: url,
5962  data: request,
5963  dataType: "json",
5964  success: function( data ) {
5965  response( data );
5966  },
5967  error: function() {
5968  response( [] );
5969  }
5970  } );
5971  };
5972  } else {
5973  this.source = this.options.source;
5974  }
5975  },
5976 
5977  _searchTimeout: function( event ) {
5978  clearTimeout( this.searching );
5979  this.searching = this._delay( function() {
5980 
5981  // Search if the value has changed, or if the user retypes the same value (see #7434)
5982  var equalValues = this.term === this._value(),
5983  menuVisible = this.menu.element.is( ":visible" ),
5984  modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
5985 
5986  if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
5987  this.selectedItem = null;
5988  this.search( null, event );
5989  }
5990  }, this.options.delay );
5991  },
5992 
5993  search: function( value, event ) {
5994  value = value != null ? value : this._value();
5995 
5996  // Always save the actual value, not the one passed as an argument
5997  this.term = this._value();
5998 
5999  if ( value.length < this.options.minLength ) {
6000  return this.close( event );
6001  }
6002 
6003  if ( this._trigger( "search", event ) === false ) {
6004  return;
6005  }
6006 
6007  return this._search( value );
6008  },
6009 
6010  _search: function( value ) {
6011  this.pending++;
6012  this._addClass( "ui-autocomplete-loading" );
6013  this.cancelSearch = false;
6014 
6015  this.source( { term: value }, this._response() );
6016  },
6017 
6018  _response: function() {
6019  var index = ++this.requestIndex;
6020 
6021  return $.proxy( function( content ) {
6022  if ( index === this.requestIndex ) {
6023  this.__response( content );
6024  }
6025 
6026  this.pending--;
6027  if ( !this.pending ) {
6028  this._removeClass( "ui-autocomplete-loading" );
6029  }
6030  }, this );
6031  },
6032 
6033  __response: function( content ) {
6034  if ( content ) {
6035  content = this._normalize( content );
6036  }
6037  this._trigger( "response", null, { content: content } );
6038  if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
6039  this._suggest( content );
6040  this._trigger( "open" );
6041  } else {
6042 
6043  // use ._close() instead of .close() so we don't cancel future searches
6044  this._close();
6045  }
6046  },
6047 
6048  close: function( event ) {
6049  this.cancelSearch = true;
6050  this._close( event );
6051  },
6052 
6053  _close: function( event ) {
6054 
6055  // Remove the handler that closes the menu on outside clicks
6056  this._off( this.document, "mousedown" );
6057 
6058  if ( this.menu.element.is( ":visible" ) ) {
6059  this.menu.element.hide();
6060  this.menu.blur();
6061  this.isNewMenu = true;
6062  this._trigger( "close", event );
6063  }
6064  },
6065 
6066  _change: function( event ) {
6067  if ( this.previous !== this._value() ) {
6068  this._trigger( "change", event, { item: this.selectedItem } );
6069  }
6070  },
6071 
6072  _normalize: function( items ) {
6073 
6074  // assume all items have the right format when the first item is complete
6075  if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
6076  return items;
6077  }
6078  return $.map( items, function( item ) {
6079  if ( typeof item === "string" ) {
6080  return {
6081  label: item,
6082  value: item
6083  };
6084  }
6085  return $.extend( {}, item, {
6086  label: item.label || item.value,
6087  value: item.value || item.label
6088  } );
6089  } );
6090  },
6091 
6092  _suggest: function( items ) {
6093  var ul = this.menu.element.empty();
6094  this._renderMenu( ul, items );
6095  this.isNewMenu = true;
6096  this.menu.refresh();
6097 
6098  // Size and position menu
6099  ul.show();
6100  this._resizeMenu();
6101  ul.position( $.extend( {
6102  of: this.element
6103  }, this.options.position ) );
6104 
6105  if ( this.options.autoFocus ) {
6106  this.menu.next();
6107  }
6108 
6109  // Listen for interactions outside of the widget (#6642)
6110  this._on( this.document, {
6111  mousedown: "_closeOnClickOutside"
6112  } );
6113  },
6114 
6115  _resizeMenu: function() {
6116  var ul = this.menu.element;
6117  ul.outerWidth( Math.max(
6118 
6119  // Firefox wraps long text (possibly a rounding bug)
6120  // so we add 1px to avoid the wrapping (#7513)
6121  ul.width( "" ).outerWidth() + 1,
6122  this.element.outerWidth()
6123  ) );
6124  },
6125 
6126  _renderMenu: function( ul, items ) {
6127  var that = this;
6128  $.each( items, function( index, item ) {
6129  that._renderItemData( ul, item );
6130  } );
6131  },
6132 
6133  _renderItemData: function( ul, item ) {
6134  return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
6135  },
6136 
6137  _renderItem: function( ul, item ) {
6138  return $( "<li>" )
6139  .append( $( "<div>" ).text( item.label ) )
6140  .appendTo( ul );
6141  },
6142 
6143  _move: function( direction, event ) {
6144  if ( !this.menu.element.is( ":visible" ) ) {
6145  this.search( null, event );
6146  return;
6147  }
6148  if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
6149  this.menu.isLastItem() && /^next/.test( direction ) ) {
6150 
6151  if ( !this.isMultiLine ) {
6152  this._value( this.term );
6153  }
6154 
6155  this.menu.blur();
6156  return;
6157  }
6158  this.menu[ direction ]( event );
6159  },
6160 
6161  widget: function() {
6162  return this.menu.element;
6163  },
6164 
6165  _value: function() {
6166  return this.valueMethod.apply( this.element, arguments );
6167  },
6168 
6169  _keyEvent: function( keyEvent, event ) {
6170  if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
6171  this._move( keyEvent, event );
6172 
6173  // Prevents moving cursor to beginning/end of the text field in some browsers
6174  event.preventDefault();
6175  }
6176  },
6177 
6178  // Support: Chrome <=50
6179  // We should be able to just use this.element.prop( "isContentEditable" )
6180  // but hidden elements always report false in Chrome.
6181  // https://code.google.com/p/chromium/issues/detail?id=313082
6182  _isContentEditable: function( element ) {
6183  if ( !element.length ) {
6184  return false;
6185  }
6186 
6187  var editable = element.prop( "contentEditable" );
6188 
6189  if ( editable === "inherit" ) {
6190  return this._isContentEditable( element.parent() );
6191  }
6192 
6193  return editable === "true";
6194  }
6195 } );
6196 
6197 $.extend( $.ui.autocomplete, {
6198  escapeRegex: function( value ) {
6199  return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
6200  },
6201  filter: function( array, term ) {
6202  var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
6203  return $.grep( array, function( value ) {
6204  return matcher.test( value.label || value.value || value );
6205  } );
6206  }
6207 } );
6208 
6209 // Live region extension, adding a `messages` option
6210 // NOTE: This is an experimental API. We are still investigating
6211 // a full solution for string manipulation and internationalization.
6212 $.widget( "ui.autocomplete", $.ui.autocomplete, {
6213  options: {
6214  messages: {
6215  noResults: "No search results.",
6216  results: function( amount ) {
6217  return amount + ( amount > 1 ? " results are" : " result is" ) +
6218  " available, use up and down arrow keys to navigate.";
6219  }
6220  }
6221  },
6222 
6223  __response: function( content ) {
6224  var message;
6225  this._superApply( arguments );
6226  if ( this.options.disabled || this.cancelSearch ) {
6227  return;
6228  }
6229  if ( content && content.length ) {
6230  message = this.options.messages.results( content.length );
6231  } else {
6232  message = this.options.messages.noResults;
6233  }
6234  this.liveRegion.children().hide();
6235  $( "<div>" ).text( message ).appendTo( this.liveRegion );
6236  }
6237 } );
6238 
6239 var widgetsAutocomplete = $.ui.autocomplete;
6240 
6241 
6242 /*!
6243  * jQuery UI Controlgroup 1.12.1
6244  * http://jqueryui.com
6245  *
6246  * Copyright jQuery Foundation and other contributors
6247  * Released under the MIT license.
6248  * http://jquery.org/license
6249  */
6250 
6251 //>>label: Controlgroup
6252 //>>group: Widgets
6253 //>>description: Visually groups form control widgets
6254 //>>docs: http://api.jqueryui.com/controlgroup/
6255 //>>demos: http://jqueryui.com/controlgroup/
6256 //>>css.structure: ../../themes/base/core.css
6257 //>>css.structure: ../../themes/base/controlgroup.css
6258 //>>css.theme: ../../themes/base/theme.css
6259 
6260 
6261 var controlgroupCornerRegex = /ui-corner-([a-z]){2,6}/g;
6262 
6263 var widgetsControlgroup = $.widget( "ui.controlgroup", {
6264  version: "1.12.1",
6265  defaultElement: "<div>",
6266  options: {
6267  direction: "horizontal",
6268  disabled: null,
6269  onlyVisible: true,
6270  items: {
6271  "button": "input[type=button], input[type=submit], input[type=reset], button, a",
6272  "controlgroupLabel": ".ui-controlgroup-label",
6273  "checkboxradio": "input[type='checkbox'], input[type='radio']",
6274  "selectmenu": "select",
6275  "spinner": ".ui-spinner-input"
6276  }
6277  },
6278 
6279  _create: function() {
6280  this._enhance();
6281  },
6282 
6283  // To support the enhanced option in jQuery Mobile, we isolate DOM manipulation
6284  _enhance: function() {
6285  this.element.attr( "role", "toolbar" );
6286  this.refresh();
6287  },
6288 
6289  _destroy: function() {
6290  this._callChildMethod( "destroy" );
6291  this.childWidgets.removeData( "ui-controlgroup-data" );
6292  this.element.removeAttr( "role" );
6293  if ( this.options.items.controlgroupLabel ) {
6294  this.element
6295  .find( this.options.items.controlgroupLabel )
6296  .find( ".ui-controlgroup-label-contents" )
6297  .contents().unwrap();
6298  }
6299  },
6300 
6301  _initWidgets: function() {
6302  var that = this,
6303  childWidgets = [];
6304 
6305  // First we iterate over each of the items options
6306  $.each( this.options.items, function( widget, selector ) {
6307  var labels;
6308  var options = {};
6309 
6310  // Make sure the widget has a selector set
6311  if ( !selector ) {
6312  return;
6313  }
6314 
6315  if ( widget === "controlgroupLabel" ) {
6316  labels = that.element.find( selector );
6317  labels.each( function() {
6318  var element = $( this );
6319 
6320  if ( element.children( ".ui-controlgroup-label-contents" ).length ) {
6321  return;
6322  }
6323  element.contents()
6324  .wrapAll( "<span class='ui-controlgroup-label-contents'></span>" );
6325  } );
6326  that._addClass( labels, null, "ui-widget ui-widget-content ui-state-default" );
6327  childWidgets = childWidgets.concat( labels.get() );
6328  return;
6329  }
6330 
6331  // Make sure the widget actually exists
6332  if ( !$.fn[ widget ] ) {
6333  return;
6334  }
6335 
6336  // We assume everything is in the middle to start because we can't determine
6337  // first / last elements until all enhancments are done.
6338  if ( that[ "_" + widget + "Options" ] ) {
6339  options = that[ "_" + widget + "Options" ]( "middle" );
6340  } else {
6341  options = { classes: {} };
6342  }
6343 
6344  // Find instances of this widget inside controlgroup and init them
6345  that.element
6346  .find( selector )
6347  .each( function() {
6348  var element = $( this );
6349  var instance = element[ widget ]( "instance" );
6350 
6351  // We need to clone the default options for this type of widget to avoid
6352  // polluting the variable options which has a wider scope than a single widget.
6353  var instanceOptions = $.widget.extend( {}, options );
6354 
6355  // If the button is the child of a spinner ignore it
6356  // TODO: Find a more generic solution
6357  if ( widget === "button" && element.parent( ".ui-spinner" ).length ) {
6358  return;
6359  }
6360 
6361  // Create the widget if it doesn't exist
6362  if ( !instance ) {
6363  instance = element[ widget ]()[ widget ]( "instance" );
6364  }
6365  if ( instance ) {
6366  instanceOptions.classes =
6367  that._resolveClassesValues( instanceOptions.classes, instance );
6368  }
6369  element[ widget ]( instanceOptions );
6370 
6371  // Store an instance of the controlgroup to be able to reference
6372  // from the outermost element for changing options and refresh
6373  var widgetElement = element[ widget ]( "widget" );
6374  $.data( widgetElement[ 0 ], "ui-controlgroup-data",
6375  instance ? instance : element[ widget ]( "instance" ) );
6376 
6377  childWidgets.push( widgetElement[ 0 ] );
6378  } );
6379  } );
6380 
6381  this.childWidgets = $( $.unique( childWidgets ) );
6382  this._addClass( this.childWidgets, "ui-controlgroup-item" );
6383  },
6384 
6385  _callChildMethod: function( method ) {
6386  this.childWidgets.each( function() {
6387  var element = $( this ),
6388  data = element.data( "ui-controlgroup-data" );
6389  if ( data && data[ method ] ) {
6390  data[ method ]();
6391  }
6392  } );
6393  },
6394 
6395  _updateCornerClass: function( element, position ) {
6396  var remove = "ui-corner-top ui-corner-bottom ui-corner-left ui-corner-right ui-corner-all";
6397  var add = this._buildSimpleOptions( position, "label" ).classes.label;
6398 
6399  this._removeClass( element, null, remove );
6400  this._addClass( element, null, add );
6401  },
6402 
6403  _buildSimpleOptions: function( position, key ) {
6404  var direction = this.options.direction === "vertical";
6405  var result = {
6406  classes: {}
6407  };
6408  result.classes[ key ] = {
6409  "middle": "",
6410  "first": "ui-corner-" + ( direction ? "top" : "left" ),
6411  "last": "ui-corner-" + ( direction ? "bottom" : "right" ),
6412  "only": "ui-corner-all"
6413  }[ position ];
6414 
6415  return result;
6416  },
6417 
6418  _spinnerOptions: function( position ) {
6419  var options = this._buildSimpleOptions( position, "ui-spinner" );
6420 
6421  options.classes[ "ui-spinner-up" ] = "";
6422  options.classes[ "ui-spinner-down" ] = "";
6423 
6424  return options;
6425  },
6426 
6427  _buttonOptions: function( position ) {
6428  return this._buildSimpleOptions( position, "ui-button" );
6429  },
6430 
6431  _checkboxradioOptions: function( position ) {
6432  return this._buildSimpleOptions( position, "ui-checkboxradio-label" );
6433  },
6434 
6435  _selectmenuOptions: function( position ) {
6436  var direction = this.options.direction === "vertical";
6437  return {
6438  width: direction ? "auto" : false,
6439  classes: {
6440  middle: {
6441  "ui-selectmenu-button-open": "",
6442  "ui-selectmenu-button-closed": ""
6443  },
6444  first: {
6445  "ui-selectmenu-button-open": "ui-corner-" + ( direction ? "top" : "tl" ),
6446  "ui-selectmenu-button-closed": "ui-corner-" + ( direction ? "top" : "left" )
6447  },
6448  last: {
6449  "ui-selectmenu-button-open": direction ? "" : "ui-corner-tr",
6450  "ui-selectmenu-button-closed": "ui-corner-" + ( direction ? "bottom" : "right" )
6451  },
6452  only: {
6453  "ui-selectmenu-button-open": "ui-corner-top",
6454  "ui-selectmenu-button-closed": "ui-corner-all"
6455  }
6456 
6457  }[ position ]
6458  };
6459  },
6460 
6461  _resolveClassesValues: function( classes, instance ) {
6462  var result = {};
6463  $.each( classes, function( key ) {
6464  var current = instance.options.classes[ key ] || "";
6465  current = $.trim( current.replace( controlgroupCornerRegex, "" ) );
6466  result[ key ] = ( current + " " + classes[ key ] ).replace( /\s+/g, " " );
6467  } );
6468  return result;
6469  },
6470 
6471  _setOption: function( key, value ) {
6472  if ( key === "direction" ) {
6473  this._removeClass( "ui-controlgroup-" + this.options.direction );
6474  }
6475 
6476  this._super( key, value );
6477  if ( key === "disabled" ) {
6478  this._callChildMethod( value ? "disable" : "enable" );
6479  return;
6480  }
6481 
6482  this.refresh();
6483  },
6484 
6485  refresh: function() {
6486  var children,
6487  that = this;
6488 
6489  this._addClass( "ui-controlgroup ui-controlgroup-" + this.options.direction );
6490 
6491  if ( this.options.direction === "horizontal" ) {
6492  this._addClass( null, "ui-helper-clearfix" );
6493  }
6494  this._initWidgets();
6495 
6496  children = this.childWidgets;
6497 
6498  // We filter here because we need to track all childWidgets not just the visible ones
6499  if ( this.options.onlyVisible ) {
6500  children = children.filter( ":visible" );
6501  }
6502 
6503  if ( children.length ) {
6504 
6505  // We do this last because we need to make sure all enhancment is done
6506  // before determining first and last
6507  $.each( [ "first", "last" ], function( index, value ) {
6508  var instance = children[ value ]().data( "ui-controlgroup-data" );
6509 
6510  if ( instance && that[ "_" + instance.widgetName + "Options" ] ) {
6511  var options = that[ "_" + instance.widgetName + "Options" ](
6512  children.length === 1 ? "only" : value
6513  );
6514  options.classes = that._resolveClassesValues( options.classes, instance );
6515  instance.element[ instance.widgetName ]( options );
6516  } else {
6517  that._updateCornerClass( children[ value ](), value );
6518  }
6519  } );
6520 
6521  // Finally call the refresh method on each of the child widgets.
6522  this._callChildMethod( "refresh" );
6523  }
6524  }
6525 } );
6526 
6527 /*!
6528  * jQuery UI Checkboxradio 1.12.1
6529  * http://jqueryui.com
6530  *
6531  * Copyright jQuery Foundation and other contributors
6532  * Released under the MIT license.
6533  * http://jquery.org/license
6534  */
6535 
6536 //>>label: Checkboxradio
6537 //>>group: Widgets
6538 //>>description: Enhances a form with multiple themeable checkboxes or radio buttons.
6539 //>>docs: http://api.jqueryui.com/checkboxradio/
6540 //>>demos: http://jqueryui.com/checkboxradio/
6541 //>>css.structure: ../../themes/base/core.css
6542 //>>css.structure: ../../themes/base/button.css
6543 //>>css.structure: ../../themes/base/checkboxradio.css
6544 //>>css.theme: ../../themes/base/theme.css
6545 
6546 
6547 
6548 $.widget( "ui.checkboxradio", [ $.ui.formResetMixin, {
6549  version: "1.12.1",
6550  options: {
6551  disabled: null,
6552  label: null,
6553  icon: true,
6554  classes: {
6555  "ui-checkboxradio-label": "ui-corner-all",
6556  "ui-checkboxradio-icon": "ui-corner-all"
6557  }
6558  },
6559 
6560  _getCreateOptions: function() {
6561  var disabled, labels;
6562  var that = this;
6563  var options = this._super() || {};
6564 
6565  // We read the type here, because it makes more sense to throw a element type error first,
6566  // rather then the error for lack of a label. Often if its the wrong type, it
6567  // won't have a label (e.g. calling on a div, btn, etc)
6568  this._readType();
6569 
6570  labels = this.element.labels();
6571 
6572  // If there are multiple labels, use the last one
6573  this.label = $( labels[ labels.length - 1 ] );
6574  if ( !this.label.length ) {
6575  $.error( "No label found for checkboxradio widget" );
6576  }
6577 
6578  this.originalLabel = "";
6579 
6580  // We need to get the label text but this may also need to make sure it does not contain the
6581  // input itself.
6582  this.label.contents().not( this.element[ 0 ] ).each( function() {
6583 
6584  // The label contents could be text, html, or a mix. We concat each element to get a
6585  // string representation of the label, without the input as part of it.
6586  that.originalLabel += this.nodeType === 3 ? $( this ).text() : this.outerHTML;
6587  } );
6588 
6589  // Set the label option if we found label text
6590  if ( this.originalLabel ) {
6591  options.label = this.originalLabel;
6592  }
6593 
6594  disabled = this.element[ 0 ].disabled;
6595  if ( disabled != null ) {
6596  options.disabled = disabled;
6597  }
6598  return options;
6599  },
6600 
6601  _create: function() {
6602  var checked = this.element[ 0 ].checked;
6603 
6604  this._bindFormResetHandler();
6605 
6606  if ( this.options.disabled == null ) {
6607  this.options.disabled = this.element[ 0 ].disabled;
6608  }
6609 
6610  this._setOption( "disabled", this.options.disabled );
6611  this._addClass( "ui-checkboxradio", "ui-helper-hidden-accessible" );
6612  this._addClass( this.label, "ui-checkboxradio-label", "ui-button ui-widget" );
6613 
6614  if ( this.type === "radio" ) {
6615  this._addClass( this.label, "ui-checkboxradio-radio-label" );
6616  }
6617 
6618  if ( this.options.label && this.options.label !== this.originalLabel ) {
6619  this._updateLabel();
6620  } else if ( this.originalLabel ) {
6621  this.options.label = this.originalLabel;
6622  }
6623 
6624  this._enhance();
6625 
6626  if ( checked ) {
6627  this._addClass( this.label, "ui-checkboxradio-checked", "ui-state-active" );
6628  if ( this.icon ) {
6629  this._addClass( this.icon, null, "ui-state-hover" );
6630  }
6631  }
6632 
6633  this._on( {
6634  change: "_toggleClasses",
6635  focus: function() {
6636  this._addClass( this.label, null, "ui-state-focus ui-visual-focus" );
6637  },
6638  blur: function() {
6639  this._removeClass( this.label, null, "ui-state-focus ui-visual-focus" );
6640  }
6641  } );
6642  },
6643 
6644  _readType: function() {
6645  var nodeName = this.element[ 0 ].nodeName.toLowerCase();
6646  this.type = this.element[ 0 ].type;
6647  if ( nodeName !== "input" || !/radio|checkbox/.test( this.type ) ) {
6648  $.error( "Can't create checkboxradio on element.nodeName=" + nodeName +
6649  " and element.type=" + this.type );
6650  }
6651  },
6652 
6653  // Support jQuery Mobile enhanced option
6654  _enhance: function() {
6655  this._updateIcon( this.element[ 0 ].checked );
6656  },
6657 
6658  widget: function() {
6659  return this.label;
6660  },
6661 
6662  _getRadioGroup: function() {
6663  var group;
6664  var name = this.element[ 0 ].name;
6665  var nameSelector = "input[name='" + $.ui.escapeSelector( name ) + "']";
6666 
6667  if ( !name ) {
6668  return $( [] );
6669  }
6670 
6671  if ( this.form.length ) {
6672  group = $( this.form[ 0 ].elements ).filter( nameSelector );
6673  } else {
6674 
6675  // Not inside a form, check all inputs that also are not inside a form
6676  group = $( nameSelector ).filter( function() {
6677  return $( this ).form().length === 0;
6678  } );
6679  }
6680 
6681  return group.not( this.element );
6682  },
6683 
6684  _toggleClasses: function() {
6685  var checked = this.element[ 0 ].checked;
6686  this._toggleClass( this.label, "ui-checkboxradio-checked", "ui-state-active", checked );
6687 
6688  if ( this.options.icon && this.type === "checkbox" ) {
6689  this._toggleClass( this.icon, null, "ui-icon-check ui-state-checked", checked )
6690  ._toggleClass( this.icon, null, "ui-icon-blank", !checked );
6691  }
6692 
6693  if ( this.type === "radio" ) {
6694  this._getRadioGroup()
6695  .each( function() {
6696  var instance = $( this ).checkboxradio( "instance" );
6697 
6698  if ( instance ) {
6699  instance._removeClass( instance.label,
6700  "ui-checkboxradio-checked", "ui-state-active" );
6701  }
6702  } );
6703  }
6704  },
6705 
6706  _destroy: function() {
6707  this._unbindFormResetHandler();
6708 
6709  if ( this.icon ) {
6710  this.icon.remove();
6711  this.iconSpace.remove();
6712  }
6713  },
6714 
6715  _setOption: function( key, value ) {
6716 
6717  // We don't allow the value to be set to nothing
6718  if ( key === "label" && !value ) {
6719  return;
6720  }
6721 
6722  this._super( key, value );
6723 
6724  if ( key === "disabled" ) {
6725  this._toggleClass( this.label, null, "ui-state-disabled", value );
6726  this.element[ 0 ].disabled = value;
6727 
6728  // Don't refresh when setting disabled
6729  return;
6730  }
6731  this.refresh();
6732  },
6733 
6734  _updateIcon: function( checked ) {
6735  var toAdd = "ui-icon ui-icon-background ";
6736 
6737  if ( this.options.icon ) {
6738  if ( !this.icon ) {
6739  this.icon = $( "<span>" );
6740  this.iconSpace = $( "<span> </span>" );
6741  this._addClass( this.iconSpace, "ui-checkboxradio-icon-space" );
6742  }
6743 
6744  if ( this.type === "checkbox" ) {
6745  toAdd += checked ? "ui-icon-check ui-state-checked" : "ui-icon-blank";
6746  this._removeClass( this.icon, null, checked ? "ui-icon-blank" : "ui-icon-check" );
6747  } else {
6748  toAdd += "ui-icon-blank";
6749  }
6750  this._addClass( this.icon, "ui-checkboxradio-icon", toAdd );
6751  if ( !checked ) {
6752  this._removeClass( this.icon, null, "ui-icon-check ui-state-checked" );
6753  }
6754  this.icon.prependTo( this.label ).after( this.iconSpace );
6755  } else if ( this.icon !== undefined ) {
6756  this.icon.remove();
6757  this.iconSpace.remove();
6758  delete this.icon;
6759  }
6760  },
6761 
6762  _updateLabel: function() {
6763 
6764  // Remove the contents of the label ( minus the icon, icon space, and input )
6765  var contents = this.label.contents().not( this.element[ 0 ] );
6766  if ( this.icon ) {
6767  contents = contents.not( this.icon[ 0 ] );
6768  }
6769  if ( this.iconSpace ) {
6770  contents = contents.not( this.iconSpace[ 0 ] );
6771  }
6772  contents.remove();
6773 
6774  this.label.append( this.options.label );
6775  },
6776 
6777  refresh: function() {
6778  var checked = this.element[ 0 ].checked,
6779  isDisabled = this.element[ 0 ].disabled;
6780 
6781  this._updateIcon( checked );
6782  this._toggleClass( this.label, "ui-checkboxradio-checked", "ui-state-active", checked );
6783  if ( this.options.label !== null ) {
6784  this._updateLabel();
6785  }
6786 
6787  if ( isDisabled !== this.options.disabled ) {
6788  this._setOptions( { "disabled": isDisabled } );
6789  }
6790  }
6791 
6792 } ] );
6793 
6794 var widgetsCheckboxradio = $.ui.checkboxradio;
6795 
6796 
6797 /*!
6798  * jQuery UI Button 1.12.1
6799  * http://jqueryui.com
6800  *
6801  * Copyright jQuery Foundation and other contributors
6802  * Released under the MIT license.
6803  * http://jquery.org/license
6804  */
6805 
6806 //>>label: Button
6807 //>>group: Widgets
6808 //>>description: Enhances a form with themeable buttons.
6809 //>>docs: http://api.jqueryui.com/button/
6810 //>>demos: http://jqueryui.com/button/
6811 //>>css.structure: ../../themes/base/core.css
6812 //>>css.structure: ../../themes/base/button.css
6813 //>>css.theme: ../../themes/base/theme.css
6814 
6815 
6816 
6817 $.widget( "ui.button", {
6818  version: "1.12.1",
6819  defaultElement: "<button>",
6820  options: {
6821  classes: {
6822  "ui-button": "ui-corner-all"
6823  },
6824  disabled: null,
6825  icon: null,
6826  iconPosition: "beginning",
6827  label: null,
6828  showLabel: true
6829  },
6830 
6831  _getCreateOptions: function() {
6832  var disabled,
6833 
6834  // This is to support cases like in jQuery Mobile where the base widget does have
6835  // an implementation of _getCreateOptions
6836  options = this._super() || {};
6837 
6838  this.isInput = this.element.is( "input" );
6839 
6840  disabled = this.element[ 0 ].disabled;
6841  if ( disabled != null ) {
6842  options.disabled = disabled;
6843  }
6844 
6845  this.originalLabel = this.isInput ? this.element.val() : this.element.html();
6846  if ( this.originalLabel ) {
6847  options.label = this.originalLabel;
6848  }
6849 
6850  return options;
6851  },
6852 
6853  _create: function() {
6854  if ( !this.option.showLabel & !this.options.icon ) {
6855  this.options.showLabel = true;
6856  }
6857 
6858  // We have to check the option again here even though we did in _getCreateOptions,
6859  // because null may have been passed on init which would override what was set in
6860  // _getCreateOptions
6861  if ( this.options.disabled == null ) {
6862  this.options.disabled = this.element[ 0 ].disabled || false;
6863  }
6864 
6865  this.hasTitle = !!this.element.attr( "title" );
6866 
6867  // Check to see if the label needs to be set or if its already correct
6868  if ( this.options.label && this.options.label !== this.originalLabel ) {
6869  if ( this.isInput ) {
6870  this.element.val( this.options.label );
6871  } else {
6872  this.element.html( this.options.label );
6873  }
6874  }
6875  this._addClass( "ui-button", "ui-widget" );
6876  this._setOption( "disabled", this.options.disabled );
6877  this._enhance();
6878 
6879  if ( this.element.is( "a" ) ) {
6880  this._on( {
6881  "keyup": function( event ) {
6882  if ( event.keyCode === $.ui.keyCode.SPACE ) {
6883  event.preventDefault();
6884 
6885  // Support: PhantomJS <= 1.9, IE 8 Only
6886  // If a native click is available use it so we actually cause navigation
6887  // otherwise just trigger a click event
6888  if ( this.element[ 0 ].click ) {
6889  this.element[ 0 ].click();
6890  } else {
6891  this.element.trigger( "click" );
6892  }
6893  }
6894  }
6895  } );
6896  }
6897  },
6898 
6899  _enhance: function() {
6900  if ( !this.element.is( "button" ) ) {
6901  this.element.attr( "role", "button" );
6902  }
6903 
6904  if ( this.options.icon ) {
6905  this._updateIcon( "icon", this.options.icon );
6906  this._updateTooltip();
6907  }
6908  },
6909 
6910  _updateTooltip: function() {
6911  this.title = this.element.attr( "title" );
6912 
6913  if ( !this.options.showLabel && !this.title ) {
6914  this.element.attr( "title", this.options.label );
6915  }
6916  },
6917 
6918  _updateIcon: function( option, value ) {
6919  var icon = option !== "iconPosition",
6920  position = icon ? this.options.iconPosition : value,
6921  displayBlock = position === "top" || position === "bottom";
6922 
6923  // Create icon
6924  if ( !this.icon ) {
6925  this.icon = $( "<span>" );
6926 
6927  this._addClass( this.icon, "ui-button-icon", "ui-icon" );
6928 
6929  if ( !this.options.showLabel ) {
6930  this._addClass( "ui-button-icon-only" );
6931  }
6932  } else if ( icon ) {
6933 
6934  // If we are updating the icon remove the old icon class
6935  this._removeClass( this.icon, null, this.options.icon );
6936  }
6937 
6938  // If we are updating the icon add the new icon class
6939  if ( icon ) {
6940  this._addClass( this.icon, null, value );
6941  }
6942 
6943  this._attachIcon( position );
6944 
6945  // If the icon is on top or bottom we need to add the ui-widget-icon-block class and remove
6946  // the iconSpace if there is one.
6947  if ( displayBlock ) {
6948  this._addClass( this.icon, null, "ui-widget-icon-block" );
6949  if ( this.iconSpace ) {
6950  this.iconSpace.remove();
6951  }
6952  } else {
6953 
6954  // Position is beginning or end so remove the ui-widget-icon-block class and add the
6955  // space if it does not exist
6956  if ( !this.iconSpace ) {
6957  this.iconSpace = $( "<span> </span>" );
6958  this._addClass( this.iconSpace, "ui-button-icon-space" );
6959  }
6960  this._removeClass( this.icon, null, "ui-wiget-icon-block" );
6961  this._attachIconSpace( position );
6962  }
6963  },
6964 
6965  _destroy: function() {
6966  this.element.removeAttr( "role" );
6967 
6968  if ( this.icon ) {
6969  this.icon.remove();
6970  }
6971  if ( this.iconSpace ) {
6972  this.iconSpace.remove();
6973  }
6974  if ( !this.hasTitle ) {
6975  this.element.removeAttr( "title" );
6976  }
6977  },
6978 
6979  _attachIconSpace: function( iconPosition ) {
6980  this.icon[ /^(?:end|bottom)/.test( iconPosition ) ? "before" : "after" ]( this.iconSpace );
6981  },
6982 
6983  _attachIcon: function( iconPosition ) {
6984  this.element[ /^(?:end|bottom)/.test( iconPosition ) ? "append" : "prepend" ]( this.icon );
6985  },
6986 
6987  _setOptions: function( options ) {
6988  var newShowLabel = options.showLabel === undefined ?
6989  this.options.showLabel :
6990  options.showLabel,
6991  newIcon = options.icon === undefined ? this.options.icon : options.icon;
6992 
6993  if ( !newShowLabel && !newIcon ) {
6994  options.showLabel = true;
6995  }
6996  this._super( options );
6997  },
6998 
6999  _setOption: function( key, value ) {
7000  if ( key === "icon" ) {
7001  if ( value ) {
7002  this._updateIcon( key, value );
7003  } else if ( this.icon ) {
7004  this.icon.remove();
7005  if ( this.iconSpace ) {
7006  this.iconSpace.remove();
7007  }
7008  }
7009  }
7010 
7011  if ( key === "iconPosition" ) {
7012  this._updateIcon( key, value );
7013  }
7014 
7015  // Make sure we can't end up with a button that has neither text nor icon
7016  if ( key === "showLabel" ) {
7017  this._toggleClass( "ui-button-icon-only", null, !value );
7018  this._updateTooltip();
7019  }
7020 
7021  if ( key === "label" ) {
7022  if ( this.isInput ) {
7023  this.element.val( value );
7024  } else {
7025 
7026  // If there is an icon, append it, else nothing then append the value
7027  // this avoids removal of the icon when setting label text
7028  this.element.html( value );
7029  if ( this.icon ) {
7030  this._attachIcon( this.options.iconPosition );
7031  this._attachIconSpace( this.options.iconPosition );
7032  }
7033  }
7034  }
7035 
7036  this._super( key, value );
7037 
7038  if ( key === "disabled" ) {
7039  this._toggleClass( null, "ui-state-disabled", value );
7040  this.element[ 0 ].disabled = value;
7041  if ( value ) {
7042  this.element.blur();
7043  }
7044  }
7045  },
7046 
7047  refresh: function() {
7048 
7049  // Make sure to only check disabled if its an element that supports this otherwise
7050  // check for the disabled class to determine state
7051  var isDisabled = this.element.is( "input, button" ) ?
7052  this.element[ 0 ].disabled : this.element.hasClass( "ui-button-disabled" );
7053 
7054  if ( isDisabled !== this.options.disabled ) {
7055  this._setOptions( { disabled: isDisabled } );
7056  }
7057 
7058  this._updateTooltip();
7059  }
7060 } );
7061 
7062 // DEPRECATED
7063 if ( $.uiBackCompat !== false ) {
7064 
7065  // Text and Icons options
7066  $.widget( "ui.button", $.ui.button, {
7067  options: {
7068  text: true,
7069  icons: {
7070  primary: null,
7071  secondary: null
7072  }
7073  },
7074 
7075  _create: function() {
7076  if ( this.options.showLabel && !this.options.text ) {
7077  this.options.showLabel = this.options.text;
7078  }
7079  if ( !this.options.showLabel && this.options.text ) {
7080  this.options.text = this.options.showLabel;
7081  }
7082  if ( !this.options.icon && ( this.options.icons.primary ||
7083  this.options.icons.secondary ) ) {
7084  if ( this.options.icons.primary ) {
7085  this.options.icon = this.options.icons.primary;
7086  } else {
7087  this.options.icon = this.options.icons.secondary;
7088  this.options.iconPosition = "end";
7089  }
7090  } else if ( this.options.icon ) {
7091  this.options.icons.primary = this.options.icon;
7092  }
7093  this._super();
7094  },
7095 
7096  _setOption: function( key, value ) {
7097  if ( key === "text" ) {
7098  this._super( "showLabel", value );
7099  return;
7100  }
7101  if ( key === "showLabel" ) {
7102  this.options.text = value;
7103  }
7104  if ( key === "icon" ) {
7105  this.options.icons.primary = value;
7106  }
7107  if ( key === "icons" ) {
7108  if ( value.primary ) {
7109  this._super( "icon", value.primary );
7110  this._super( "iconPosition", "beginning" );
7111  } else if ( value.secondary ) {
7112  this._super( "icon", value.secondary );
7113  this._super( "iconPosition", "end" );
7114  }
7115  }
7116  this._superApply( arguments );
7117  }
7118  } );
7119 
7120  $.fn.button = ( function( orig ) {
7121  return function() {
7122  if ( !this.length || ( this.length && this[ 0 ].tagName !== "INPUT" ) ||
7123  ( this.length && this[ 0 ].tagName === "INPUT" && (
7124  this.attr( "type" ) !== "checkbox" && this.attr( "type" ) !== "radio"
7125  ) ) ) {
7126  return orig.apply( this, arguments );
7127  }
7128  if ( !$.ui.checkboxradio ) {
7129  $.error( "Checkboxradio widget missing" );
7130  }
7131  if ( arguments.length === 0 ) {
7132  return this.checkboxradio( {
7133  "icon": false
7134  } );
7135  }
7136  return this.checkboxradio.apply( this, arguments );
7137  };
7138  } )( $.fn.button );
7139 
7140  $.fn.buttonset = function() {
7141  if ( !$.ui.controlgroup ) {
7142  $.error( "Controlgroup widget missing" );
7143  }
7144  if ( arguments[ 0 ] === "option" && arguments[ 1 ] === "items" && arguments[ 2 ] ) {
7145  return this.controlgroup.apply( this,
7146  [ arguments[ 0 ], "items.button", arguments[ 2 ] ] );
7147  }
7148  if ( arguments[ 0 ] === "option" && arguments[ 1 ] === "items" ) {
7149  return this.controlgroup.apply( this, [ arguments[ 0 ], "items.button" ] );
7150  }
7151  if ( typeof arguments[ 0 ] === "object" && arguments[ 0 ].items ) {
7152  arguments[ 0 ].items = {
7153  button: arguments[ 0 ].items
7154  };
7155  }
7156  return this.controlgroup.apply( this, arguments );
7157  };
7158 }
7159 
7160 var widgetsButton = $.ui.button;
7161 
7162 
7163 // jscs:disable maximumLineLength
7164 /* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */
7165 /*!
7166  * jQuery UI Datepicker 1.12.1
7167  * http://jqueryui.com
7168  *
7169  * Copyright jQuery Foundation and other contributors
7170  * Released under the MIT license.
7171  * http://jquery.org/license
7172  */
7173 
7174 //>>label: Datepicker
7175 //>>group: Widgets
7176 //>>description: Displays a calendar from an input or inline for selecting dates.
7177 //>>docs: http://api.jqueryui.com/datepicker/
7178 //>>demos: http://jqueryui.com/datepicker/
7179 //>>css.structure: ../../themes/base/core.css
7180 //>>css.structure: ../../themes/base/datepicker.css
7181 //>>css.theme: ../../themes/base/theme.css
7182 
7183 
7184 
7185 $.extend( $.ui, { datepicker: { version: "1.12.1" } } );
7186 
7187 var datepicker_instActive;
7188 
7189 function datepicker_getZindex( elem ) {
7190  var position, value;
7191  while ( elem.length && elem[ 0 ] !== document ) {
7192 
7193  // Ignore z-index if position is set to a value where z-index is ignored by the browser
7194  // This makes behavior of this function consistent across browsers
7195  // WebKit always returns auto if the element is positioned
7196  position = elem.css( "position" );
7197  if ( position === "absolute" || position === "relative" || position === "fixed" ) {
7198 
7199  // IE returns 0 when zIndex is not specified
7200  // other browsers return a string
7201  // we ignore the case of nested elements with an explicit value of 0
7202  // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
7203  value = parseInt( elem.css( "zIndex" ), 10 );
7204  if ( !isNaN( value ) && value !== 0 ) {
7205  return value;
7206  }
7207  }
7208  elem = elem.parent();
7209  }
7210 
7211  return 0;
7212 }
7213 /* Date picker manager.
7214  Use the singleton instance of this class, $.datepicker, to interact with the date picker.
7215  Settings for (groups of) date pickers are maintained in an instance object,
7216  allowing multiple different settings on the same page. */
7217 
7218 function Datepicker() {
7219  this._curInst = null; // The current instance in use
7220  this._keyEvent = false; // If the last event was a key event
7221  this._disabledInputs = []; // List of date picker inputs that have been disabled
7222  this._datepickerShowing = false; // True if the popup picker is showing , false if not
7223  this._inDialog = false; // True if showing within a "dialog", false if not
7224  this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
7225  this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
7226  this._appendClass = "ui-datepicker-append"; // The name of the append marker class
7227  this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
7228  this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
7229  this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
7230  this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
7231  this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
7232  this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
7233  this.regional = []; // Available regional settings, indexed by language code
7234  this.regional[ "" ] = { // Default regional settings
7235  closeText: "Done", // Display text for close link
7236  prevText: "Prev", // Display text for previous month link
7237  nextText: "Next", // Display text for next month link
7238  currentText: "Today", // Display text for current month link
7239  monthNames: [ "January","February","March","April","May","June",
7240  "July","August","September","October","November","December" ], // Names of months for drop-down and formatting
7241  monthNamesShort: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ], // For formatting
7242  dayNames: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ], // For formatting
7243  dayNamesShort: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ], // For formatting
7244  dayNamesMin: [ "Su","Mo","Tu","We","Th","Fr","Sa" ], // Column headings for days starting at Sunday
7245  weekHeader: "Wk", // Column header for week of the year
7246  dateFormat: "mm/dd/yy", // See format options on parseDate
7247  firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
7248  isRTL: false, // True if right-to-left language, false if left-to-right
7249  showMonthAfterYear: false, // True if the year select precedes month, false for month then year
7250  yearSuffix: "" // Additional text to append to the year in the month headers
7251  };
7252  this._defaults = { // Global defaults for all the date picker instances
7253  showOn: "focus", // "focus" for popup on focus,
7254  // "button" for trigger button, or "both" for either
7255  showAnim: "fadeIn", // Name of jQuery animation for popup
7256  showOptions: {}, // Options for enhanced animations
7257  defaultDate: null, // Used when field is blank: actual date,
7258  // +/-number for offset from today, null for today
7259  appendText: "", // Display text following the input box, e.g. showing the format
7260  buttonText: "...", // Text for trigger button
7261  buttonImage: "", // URL for trigger button image
7262  buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
7263  hideIfNoPrevNext: false, // True to hide next/previous month links
7264  // if not applicable, false to just disable them
7265  navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
7266  gotoCurrent: false, // True if today link goes back to current selection instead
7267  changeMonth: false, // True if month can be selected directly, false if only prev/next
7268  changeYear: false, // True if year can be selected directly, false if only prev/next
7269  yearRange: "c-10:c+10", // Range of years to display in drop-down,
7270  // either relative to today's year (-nn:+nn), relative to currently displayed year
7271  // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
7272  showOtherMonths: false, // True to show dates in other months, false to leave blank
7273  selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
7274  showWeek: false, // True to show week of the year, false to not show it
7275  calculateWeek: this.iso8601Week, // How to calculate the week of the year,
7276  // takes a Date and returns the number of the week for it
7277  shortYearCutoff: "+10", // Short year values < this are in the current century,
7278  // > this are in the previous century,
7279  // string value starting with "+" for current year + value
7280  minDate: null, // The earliest selectable date, or null for no limit
7281  maxDate: null, // The latest selectable date, or null for no limit
7282  duration: "fast", // Duration of display/closure
7283  beforeShowDay: null, // Function that takes a date and returns an array with
7284  // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
7285  // [2] = cell title (optional), e.g. $.datepicker.noWeekends
7286  beforeShow: null, // Function that takes an input field and
7287  // returns a set of custom settings for the date picker
7288  onSelect: null, // Define a callback function when a date is selected
7289  onChangeMonthYear: null, // Define a callback function when the month or year is changed
7290  onClose: null, // Define a callback function when the datepicker is closed
7291  numberOfMonths: 1, // Number of months to show at a time
7292  showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
7293  stepMonths: 1, // Number of months to step back/forward
7294  stepBigMonths: 12, // Number of months to step back/forward for the big links
7295  altField: "", // Selector for an alternate field to store selected dates into
7296  altFormat: "", // The date format to use for the alternate field
7297  constrainInput: true, // The input is constrained by the current date format
7298  showButtonPanel: false, // True to show button panel, false to not show it
7299  autoSize: false, // True to size the input for the date format, false to leave as is
7300  disabled: false // The initial disabled state
7301  };
7302  $.extend( this._defaults, this.regional[ "" ] );
7303  this.regional.en = $.extend( true, {}, this.regional[ "" ] );
7304  this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
7305  this.dpDiv = datepicker_bindHover( $( "<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>" ) );
7306 }
7307 
7308 $.extend( Datepicker.prototype, {
7309  /* Class name added to elements to indicate already configured with a date picker. */
7310  markerClassName: "hasDatepicker",
7311 
7312  //Keep track of the maximum number of rows displayed (see #7043)
7313  maxRows: 4,
7314 
7315  // TODO rename to "widget" when switching to widget factory
7316  _widgetDatepicker: function() {
7317  return this.dpDiv;
7318  },
7319 
7320  /* Override the default settings for all instances of the date picker.
7321  * @param settings object - the new settings to use as defaults (anonymous object)
7322  * @return the manager object
7323  */
7324  setDefaults: function( settings ) {
7325  datepicker_extendRemove( this._defaults, settings || {} );
7326  return this;
7327  },
7328 
7329  /* Attach the date picker to a jQuery selection.
7330  * @param target element - the target input field or division or span
7331  * @param settings object - the new settings to use for this date picker instance (anonymous)
7332  */
7333  _attachDatepicker: function( target, settings ) {
7334  var nodeName, inline, inst;
7335  nodeName = target.nodeName.toLowerCase();
7336  inline = ( nodeName === "div" || nodeName === "span" );
7337  if ( !target.id ) {
7338  this.uuid += 1;
7339  target.id = "dp" + this.uuid;
7340  }
7341  inst = this._newInst( $( target ), inline );
7342  inst.settings = $.extend( {}, settings || {} );
7343  if ( nodeName === "input" ) {
7344  this._connectDatepicker( target, inst );
7345  } else if ( inline ) {
7346  this._inlineDatepicker( target, inst );
7347  }
7348  },
7349 
7350  /* Create a new instance object. */
7351  _newInst: function( target, inline ) {
7352  var id = target[ 0 ].id.replace( /([^A-Za-z0-9_\-])/g, "\\\\$1" ); // escape jQuery meta chars
7353  return { id: id, input: target, // associated target
7354  selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
7355  drawMonth: 0, drawYear: 0, // month being drawn
7356  inline: inline, // is datepicker inline or not
7357  dpDiv: ( !inline ? this.dpDiv : // presentation div
7358  datepicker_bindHover( $( "<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>" ) ) ) };
7359  },
7360 
7361  /* Attach the date picker to an input field. */
7362  _connectDatepicker: function( target, inst ) {
7363  var input = $( target );
7364  inst.append = $( [] );
7365  inst.trigger = $( [] );
7366  if ( input.hasClass( this.markerClassName ) ) {
7367  return;
7368  }
7369  this._attachments( input, inst );
7370  input.addClass( this.markerClassName ).on( "keydown", this._doKeyDown ).
7371  on( "keypress", this._doKeyPress ).on( "keyup", this._doKeyUp );
7372  this._autoSize( inst );
7373  $.data( target, "datepicker", inst );
7374 
7375  //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
7376  if ( inst.settings.disabled ) {
7377  this._disableDatepicker( target );
7378  }
7379  },
7380 
7381  /* Make attachments based on settings. */
7382  _attachments: function( input, inst ) {
7383  var showOn, buttonText, buttonImage,
7384  appendText = this._get( inst, "appendText" ),
7385  isRTL = this._get( inst, "isRTL" );
7386 
7387  if ( inst.append ) {
7388  inst.append.remove();
7389  }
7390  if ( appendText ) {
7391  inst.append = $( "<span class='" + this._appendClass + "'>" + appendText + "</span>" );
7392  input[ isRTL ? "before" : "after" ]( inst.append );
7393  }
7394 
7395  input.off( "focus", this._showDatepicker );
7396 
7397  if ( inst.trigger ) {
7398  inst.trigger.remove();
7399  }
7400 
7401  showOn = this._get( inst, "showOn" );
7402  if ( showOn === "focus" || showOn === "both" ) { // pop-up date picker when in the marked field
7403  input.on( "focus", this._showDatepicker );
7404  }
7405  if ( showOn === "button" || showOn === "both" ) { // pop-up date picker when button clicked
7406  buttonText = this._get( inst, "buttonText" );
7407  buttonImage = this._get( inst, "buttonImage" );
7408  inst.trigger = $( this._get( inst, "buttonImageOnly" ) ?
7409  $( "<img/>" ).addClass( this._triggerClass ).
7410  attr( { src: buttonImage, alt: buttonText, title: buttonText } ) :
7411  $( "<button type='button'></button>" ).addClass( this._triggerClass ).
7412  html( !buttonImage ? buttonText : $( "<img/>" ).attr(
7413  { src:buttonImage, alt:buttonText, title:buttonText } ) ) );
7414  input[ isRTL ? "before" : "after" ]( inst.trigger );
7415  inst.trigger.on( "click", function() {
7416  if ( $.datepicker._datepickerShowing && $.datepicker._lastInput === input[ 0 ] ) {
7417  $.datepicker._hideDatepicker();
7418  } else if ( $.datepicker._datepickerShowing && $.datepicker._lastInput !== input[ 0 ] ) {
7419  $.datepicker._hideDatepicker();
7420  $.datepicker._showDatepicker( input[ 0 ] );
7421  } else {
7422  $.datepicker._showDatepicker( input[ 0 ] );
7423  }
7424  return false;
7425  } );
7426  }
7427  },
7428 
7429  /* Apply the maximum length for the date format. */
7430  _autoSize: function( inst ) {
7431  if ( this._get( inst, "autoSize" ) && !inst.inline ) {
7432  var findMax, max, maxI, i,
7433  date = new Date( 2009, 12 - 1, 20 ), // Ensure double digits
7434  dateFormat = this._get( inst, "dateFormat" );
7435 
7436  if ( dateFormat.match( /[DM]/ ) ) {
7437  findMax = function( names ) {
7438  max = 0;
7439  maxI = 0;
7440  for ( i = 0; i < names.length; i++ ) {
7441  if ( names[ i ].length > max ) {
7442  max = names[ i ].length;
7443  maxI = i;
7444  }
7445  }
7446  return maxI;
7447  };
7448  date.setMonth( findMax( this._get( inst, ( dateFormat.match( /MM/ ) ?
7449  "monthNames" : "monthNamesShort" ) ) ) );
7450  date.setDate( findMax( this._get( inst, ( dateFormat.match( /DD/ ) ?
7451  "dayNames" : "dayNamesShort" ) ) ) + 20 - date.getDay() );
7452  }
7453  inst.input.attr( "size", this._formatDate( inst, date ).length );
7454  }
7455  },
7456 
7457  /* Attach an inline date picker to a div. */
7458  _inlineDatepicker: function( target, inst ) {
7459  var divSpan = $( target );
7460  if ( divSpan.hasClass( this.markerClassName ) ) {
7461  return;
7462  }
7463  divSpan.addClass( this.markerClassName ).append( inst.dpDiv );
7464  $.data( target, "datepicker", inst );
7465  this._setDate( inst, this._getDefaultDate( inst ), true );
7466  this._updateDatepicker( inst );
7467  this._updateAlternate( inst );
7468 
7469  //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
7470  if ( inst.settings.disabled ) {
7471  this._disableDatepicker( target );
7472  }
7473 
7474  // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
7475  // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
7476  inst.dpDiv.css( "display", "block" );
7477  },
7478 
7479  /* Pop-up the date picker in a "dialog" box.
7480  * @param input element - ignored
7481  * @param date string or Date - the initial date to display
7482  * @param onSelect function - the function to call when a date is selected
7483  * @param settings object - update the dialog date picker instance's settings (anonymous object)
7484  * @param pos int[2] - coordinates for the dialog's position within the screen or
7485  * event - with x/y coordinates or
7486  * leave empty for default (screen centre)
7487  * @return the manager object
7488  */
7489  _dialogDatepicker: function( input, date, onSelect, settings, pos ) {
7490  var id, browserWidth, browserHeight, scrollX, scrollY,
7491  inst = this._dialogInst; // internal instance
7492 
7493  if ( !inst ) {
7494  this.uuid += 1;
7495  id = "dp" + this.uuid;
7496  this._dialogInput = $( "<input type='text' id='" + id +
7497  "' style='position: absolute; top: -100px; width: 0px;'/>" );
7498  this._dialogInput.on( "keydown", this._doKeyDown );
7499  $( "body" ).append( this._dialogInput );
7500  inst = this._dialogInst = this._newInst( this._dialogInput, false );
7501  inst.settings = {};
7502  $.data( this._dialogInput[ 0 ], "datepicker", inst );
7503  }
7504  datepicker_extendRemove( inst.settings, settings || {} );
7505  date = ( date && date.constructor === Date ? this._formatDate( inst, date ) : date );
7506  this._dialogInput.val( date );
7507 
7508  this._pos = ( pos ? ( pos.length ? pos : [ pos.pageX, pos.pageY ] ) : null );
7509  if ( !this._pos ) {
7510  browserWidth = document.documentElement.clientWidth;
7511  browserHeight = document.documentElement.clientHeight;
7512  scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
7513  scrollY = document.documentElement.scrollTop || document.body.scrollTop;
7514  this._pos = // should use actual width/height below
7515  [ ( browserWidth / 2 ) - 100 + scrollX, ( browserHeight / 2 ) - 150 + scrollY ];
7516  }
7517 
7518  // Move input on screen for focus, but hidden behind dialog
7519  this._dialogInput.css( "left", ( this._pos[ 0 ] + 20 ) + "px" ).css( "top", this._pos[ 1 ] + "px" );
7520  inst.settings.onSelect = onSelect;
7521  this._inDialog = true;
7522  this.dpDiv.addClass( this._dialogClass );
7523  this._showDatepicker( this._dialogInput[ 0 ] );
7524  if ( $.blockUI ) {
7525  $.blockUI( this.dpDiv );
7526  }
7527  $.data( this._dialogInput[ 0 ], "datepicker", inst );
7528  return this;
7529  },
7530 
7531  /* Detach a datepicker from its control.
7532  * @param target element - the target input field or division or span
7533  */
7534  _destroyDatepicker: function( target ) {
7535  var nodeName,
7536  $target = $( target ),
7537  inst = $.data( target, "datepicker" );
7538 
7539  if ( !$target.hasClass( this.markerClassName ) ) {
7540  return;
7541  }
7542 
7543  nodeName = target.nodeName.toLowerCase();
7544  $.removeData( target, "datepicker" );
7545  if ( nodeName === "input" ) {
7546  inst.append.remove();
7547  inst.trigger.remove();
7548  $target.removeClass( this.markerClassName ).
7549  off( "focus", this._showDatepicker ).
7550  off( "keydown", this._doKeyDown ).
7551  off( "keypress", this._doKeyPress ).
7552  off( "keyup", this._doKeyUp );
7553  } else if ( nodeName === "div" || nodeName === "span" ) {
7554  $target.removeClass( this.markerClassName ).empty();
7555  }
7556 
7557  if ( datepicker_instActive === inst ) {
7558  datepicker_instActive = null;
7559  }
7560  },
7561 
7562  /* Enable the date picker to a jQuery selection.
7563  * @param target element - the target input field or division or span
7564  */
7565  _enableDatepicker: function( target ) {
7566  var nodeName, inline,
7567  $target = $( target ),
7568  inst = $.data( target, "datepicker" );
7569 
7570  if ( !$target.hasClass( this.markerClassName ) ) {
7571  return;
7572  }
7573 
7574  nodeName = target.nodeName.toLowerCase();
7575  if ( nodeName === "input" ) {
7576  target.disabled = false;
7577  inst.trigger.filter( "button" ).
7578  each( function() { this.disabled = false; } ).end().
7579  filter( "img" ).css( { opacity: "1.0", cursor: "" } );
7580  } else if ( nodeName === "div" || nodeName === "span" ) {
7581  inline = $target.children( "." + this._inlineClass );
7582  inline.children().removeClass( "ui-state-disabled" );
7583  inline.find( "select.ui-datepicker-month, select.ui-datepicker-year" ).
7584  prop( "disabled", false );
7585  }
7586  this._disabledInputs = $.map( this._disabledInputs,
7587  function( value ) { return ( value === target ? null : value ); } ); // delete entry
7588  },
7589 
7590  /* Disable the date picker to a jQuery selection.
7591  * @param target element - the target input field or division or span
7592  */
7593  _disableDatepicker: function( target ) {
7594  var nodeName, inline,
7595  $target = $( target ),
7596  inst = $.data( target, "datepicker" );
7597 
7598  if ( !$target.hasClass( this.markerClassName ) ) {
7599  return;
7600  }
7601 
7602  nodeName = target.nodeName.toLowerCase();
7603  if ( nodeName === "input" ) {
7604  target.disabled = true;
7605  inst.trigger.filter( "button" ).
7606  each( function() { this.disabled = true; } ).end().
7607  filter( "img" ).css( { opacity: "0.5", cursor: "default" } );
7608  } else if ( nodeName === "div" || nodeName === "span" ) {
7609  inline = $target.children( "." + this._inlineClass );
7610  inline.children().addClass( "ui-state-disabled" );
7611  inline.find( "select.ui-datepicker-month, select.ui-datepicker-year" ).
7612  prop( "disabled", true );
7613  }
7614  this._disabledInputs = $.map( this._disabledInputs,
7615  function( value ) { return ( value === target ? null : value ); } ); // delete entry
7616  this._disabledInputs[ this._disabledInputs.length ] = target;
7617  },
7618 
7619  /* Is the first field in a jQuery collection disabled as a datepicker?
7620  * @param target element - the target input field or division or span
7621  * @return boolean - true if disabled, false if enabled
7622  */
7623  _isDisabledDatepicker: function( target ) {
7624  if ( !target ) {
7625  return false;
7626  }
7627  for ( var i = 0; i < this._disabledInputs.length; i++ ) {
7628  if ( this._disabledInputs[ i ] === target ) {
7629  return true;
7630  }
7631  }
7632  return false;
7633  },
7634 
7635  /* Retrieve the instance data for the target control.
7636  * @param target element - the target input field or division or span
7637  * @return object - the associated instance data
7638  * @throws error if a jQuery problem getting data
7639  */
7640  _getInst: function( target ) {
7641  try {
7642  return $.data( target, "datepicker" );
7643  }
7644  catch ( err ) {
7645  throw "Missing instance data for this datepicker";
7646  }
7647  },
7648 
7649  /* Update or retrieve the settings for a date picker attached to an input field or division.
7650  * @param target element - the target input field or division or span
7651  * @param name object - the new settings to update or
7652  * string - the name of the setting to change or retrieve,
7653  * when retrieving also "all" for all instance settings or
7654  * "defaults" for all global defaults
7655  * @param value any - the new value for the setting
7656  * (omit if above is an object or to retrieve a value)
7657  */
7658  _optionDatepicker: function( target, name, value ) {
7659  var settings, date, minDate, maxDate,
7660  inst = this._getInst( target );
7661 
7662  if ( arguments.length === 2 && typeof name === "string" ) {
7663  return ( name === "defaults" ? $.extend( {}, $.datepicker._defaults ) :
7664  ( inst ? ( name === "all" ? $.extend( {}, inst.settings ) :
7665  this._get( inst, name ) ) : null ) );
7666  }
7667 
7668  settings = name || {};
7669  if ( typeof name === "string" ) {
7670  settings = {};
7671  settings[ name ] = value;
7672  }
7673 
7674  if ( inst ) {
7675  if ( this._curInst === inst ) {
7676  this._hideDatepicker();
7677  }
7678 
7679  date = this._getDateDatepicker( target, true );
7680  minDate = this._getMinMaxDate( inst, "min" );
7681  maxDate = this._getMinMaxDate( inst, "max" );
7682  datepicker_extendRemove( inst.settings, settings );
7683 
7684  // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
7685  if ( minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined ) {
7686  inst.settings.minDate = this._formatDate( inst, minDate );
7687  }
7688  if ( maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined ) {
7689  inst.settings.maxDate = this._formatDate( inst, maxDate );
7690  }
7691  if ( "disabled" in settings ) {
7692  if ( settings.disabled ) {
7693  this._disableDatepicker( target );
7694  } else {
7695  this._enableDatepicker( target );
7696  }
7697  }
7698  this._attachments( $( target ), inst );
7699  this._autoSize( inst );
7700  this._setDate( inst, date );
7701  this._updateAlternate( inst );
7702  this._updateDatepicker( inst );
7703  }
7704  },
7705 
7706  // Change method deprecated
7707  _changeDatepicker: function( target, name, value ) {
7708  this._optionDatepicker( target, name, value );
7709  },
7710 
7711  /* Redraw the date picker attached to an input field or division.
7712  * @param target element - the target input field or division or span
7713  */
7714  _refreshDatepicker: function( target ) {
7715  var inst = this._getInst( target );
7716  if ( inst ) {
7717  this._updateDatepicker( inst );
7718  }
7719  },
7720 
7721  /* Set the dates for a jQuery selection.
7722  * @param target element - the target input field or division or span
7723  * @param date Date - the new date
7724  */
7725  _setDateDatepicker: function( target, date ) {
7726  var inst = this._getInst( target );
7727  if ( inst ) {
7728  this._setDate( inst, date );
7729  this._updateDatepicker( inst );
7730  this._updateAlternate( inst );
7731  }
7732  },
7733 
7734  /* Get the date(s) for the first entry in a jQuery selection.
7735  * @param target element - the target input field or division or span
7736  * @param noDefault boolean - true if no default date is to be used
7737  * @return Date - the current date
7738  */
7739  _getDateDatepicker: function( target, noDefault ) {
7740  var inst = this._getInst( target );
7741  if ( inst && !inst.inline ) {
7742  this._setDateFromField( inst, noDefault );
7743  }
7744  return ( inst ? this._getDate( inst ) : null );
7745  },
7746 
7747  /* Handle keystrokes. */
7748  _doKeyDown: function( event ) {
7749  var onSelect, dateStr, sel,
7750  inst = $.datepicker._getInst( event.target ),
7751  handled = true,
7752  isRTL = inst.dpDiv.is( ".ui-datepicker-rtl" );
7753 
7754  inst._keyEvent = true;
7755  if ( $.datepicker._datepickerShowing ) {
7756  switch ( event.keyCode ) {
7757  case 9: $.datepicker._hideDatepicker();
7758  handled = false;
7759  break; // hide on tab out
7760  case 13: sel = $( "td." + $.datepicker._dayOverClass + ":not(." +
7761  $.datepicker._currentClass + ")", inst.dpDiv );
7762  if ( sel[ 0 ] ) {
7763  $.datepicker._selectDay( event.target, inst.selectedMonth, inst.selectedYear, sel[ 0 ] );
7764  }
7765 
7766  onSelect = $.datepicker._get( inst, "onSelect" );
7767  if ( onSelect ) {
7768  dateStr = $.datepicker._formatDate( inst );
7769 
7770  // Trigger custom callback
7771  onSelect.apply( ( inst.input ? inst.input[ 0 ] : null ), [ dateStr, inst ] );
7772  } else {
7773  $.datepicker._hideDatepicker();
7774  }
7775 
7776  return false; // don't submit the form
7777  case 27: $.datepicker._hideDatepicker();
7778  break; // hide on escape
7779  case 33: $.datepicker._adjustDate( event.target, ( event.ctrlKey ?
7780  -$.datepicker._get( inst, "stepBigMonths" ) :
7781  -$.datepicker._get( inst, "stepMonths" ) ), "M" );
7782  break; // previous month/year on page up/+ ctrl
7783  case 34: $.datepicker._adjustDate( event.target, ( event.ctrlKey ?
7784  +$.datepicker._get( inst, "stepBigMonths" ) :
7785  +$.datepicker._get( inst, "stepMonths" ) ), "M" );
7786  break; // next month/year on page down/+ ctrl
7787  case 35: if ( event.ctrlKey || event.metaKey ) {
7788  $.datepicker._clearDate( event.target );
7789  }
7790  handled = event.ctrlKey || event.metaKey;
7791  break; // clear on ctrl or command +end
7792  case 36: if ( event.ctrlKey || event.metaKey ) {
7793  $.datepicker._gotoToday( event.target );
7794  }
7795  handled = event.ctrlKey || event.metaKey;
7796  break; // current on ctrl or command +home
7797  case 37: if ( event.ctrlKey || event.metaKey ) {
7798  $.datepicker._adjustDate( event.target, ( isRTL ? +1 : -1 ), "D" );
7799  }
7800  handled = event.ctrlKey || event.metaKey;
7801 
7802  // -1 day on ctrl or command +left
7803  if ( event.originalEvent.altKey ) {
7804  $.datepicker._adjustDate( event.target, ( event.ctrlKey ?
7805  -$.datepicker._get( inst, "stepBigMonths" ) :
7806  -$.datepicker._get( inst, "stepMonths" ) ), "M" );
7807  }
7808 
7809  // next month/year on alt +left on Mac
7810  break;
7811  case 38: if ( event.ctrlKey || event.metaKey ) {
7812  $.datepicker._adjustDate( event.target, -7, "D" );
7813  }
7814  handled = event.ctrlKey || event.metaKey;
7815  break; // -1 week on ctrl or command +up
7816  case 39: if ( event.ctrlKey || event.metaKey ) {
7817  $.datepicker._adjustDate( event.target, ( isRTL ? -1 : +1 ), "D" );
7818  }
7819  handled = event.ctrlKey || event.metaKey;
7820 
7821  // +1 day on ctrl or command +right
7822  if ( event.originalEvent.altKey ) {
7823  $.datepicker._adjustDate( event.target, ( event.ctrlKey ?
7824  +$.datepicker._get( inst, "stepBigMonths" ) :
7825  +$.datepicker._get( inst, "stepMonths" ) ), "M" );
7826  }
7827 
7828  // next month/year on alt +right
7829  break;
7830  case 40: if ( event.ctrlKey || event.metaKey ) {
7831  $.datepicker._adjustDate( event.target, +7, "D" );
7832  }
7833  handled = event.ctrlKey || event.metaKey;
7834  break; // +1 week on ctrl or command +down
7835  default: handled = false;
7836  }
7837  } else if ( event.keyCode === 36 && event.ctrlKey ) { // display the date picker on ctrl+home
7838  $.datepicker._showDatepicker( this );
7839  } else {
7840  handled = false;
7841  }
7842 
7843  if ( handled ) {
7844  event.preventDefault();
7845  event.stopPropagation();
7846  }
7847  },
7848 
7849  /* Filter entered characters - based on date format. */
7850  _doKeyPress: function( event ) {
7851  var chars, chr,
7852  inst = $.datepicker._getInst( event.target );
7853 
7854  if ( $.datepicker._get( inst, "constrainInput" ) ) {
7855  chars = $.datepicker._possibleChars( $.datepicker._get( inst, "dateFormat" ) );
7856  chr = String.fromCharCode( event.charCode == null ? event.keyCode : event.charCode );
7857  return event.ctrlKey || event.metaKey || ( chr < " " || !chars || chars.indexOf( chr ) > -1 );
7858  }
7859  },
7860 
7861  /* Synchronise manual entry and field/alternate field. */
7862  _doKeyUp: function( event ) {
7863  var date,
7864  inst = $.datepicker._getInst( event.target );
7865 
7866  if ( inst.input.val() !== inst.lastVal ) {
7867  try {
7868  date = $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ),
7869  ( inst.input ? inst.input.val() : null ),
7870  $.datepicker._getFormatConfig( inst ) );
7871 
7872  if ( date ) { // only if valid
7873  $.datepicker._setDateFromField( inst );
7874  $.datepicker._updateAlternate( inst );
7875  $.datepicker._updateDatepicker( inst );
7876  }
7877  }
7878  catch ( err ) {
7879  }
7880  }
7881  return true;
7882  },
7883 
7884  /* Pop-up the date picker for a given input field.
7885  * If false returned from beforeShow event handler do not show.
7886  * @param input element - the input field attached to the date picker or
7887  * event - if triggered by focus
7888  */
7889  _showDatepicker: function( input ) {
7890  input = input.target || input;
7891  if ( input.nodeName.toLowerCase() !== "input" ) { // find from button/image trigger
7892  input = $( "input", input.parentNode )[ 0 ];
7893  }
7894 
7895  if ( $.datepicker._isDisabledDatepicker( input ) || $.datepicker._lastInput === input ) { // already here
7896  return;
7897  }
7898 
7899  var inst, beforeShow, beforeShowSettings, isFixed,
7900  offset, showAnim, duration;
7901 
7902  inst = $.datepicker._getInst( input );
7903  if ( $.datepicker._curInst && $.datepicker._curInst !== inst ) {
7904  $.datepicker._curInst.dpDiv.stop( true, true );
7905  if ( inst && $.datepicker._datepickerShowing ) {
7906  $.datepicker._hideDatepicker( $.datepicker._curInst.input[ 0 ] );
7907  }
7908  }
7909 
7910  beforeShow = $.datepicker._get( inst, "beforeShow" );
7911  beforeShowSettings = beforeShow ? beforeShow.apply( input, [ input, inst ] ) : {};
7912  if ( beforeShowSettings === false ) {
7913  return;
7914  }
7915  datepicker_extendRemove( inst.settings, beforeShowSettings );
7916 
7917  inst.lastVal = null;
7918  $.datepicker._lastInput = input;
7919  $.datepicker._setDateFromField( inst );
7920 
7921  if ( $.datepicker._inDialog ) { // hide cursor
7922  input.value = "";
7923  }
7924  if ( !$.datepicker._pos ) { // position below input
7925  $.datepicker._pos = $.datepicker._findPos( input );
7926  $.datepicker._pos[ 1 ] += input.offsetHeight; // add the height
7927  }
7928 
7929  isFixed = false;
7930  $( input ).parents().each( function() {
7931  isFixed |= $( this ).css( "position" ) === "fixed";
7932  return !isFixed;
7933  } );
7934 
7935  offset = { left: $.datepicker._pos[ 0 ], top: $.datepicker._pos[ 1 ] };
7936  $.datepicker._pos = null;
7937 
7938  //to avoid flashes on Firefox
7939  inst.dpDiv.empty();
7940 
7941  // determine sizing offscreen
7942  inst.dpDiv.css( { position: "absolute", display: "block", top: "-1000px" } );
7943  $.datepicker._updateDatepicker( inst );
7944 
7945  // fix width for dynamic number of date pickers
7946  // and adjust position before showing
7947  offset = $.datepicker._checkOffset( inst, offset, isFixed );
7948  inst.dpDiv.css( { position: ( $.datepicker._inDialog && $.blockUI ?
7949  "static" : ( isFixed ? "fixed" : "absolute" ) ), display: "none",
7950  left: offset.left + "px", top: offset.top + "px" } );
7951 
7952  if ( !inst.inline ) {
7953  showAnim = $.datepicker._get( inst, "showAnim" );
7954  duration = $.datepicker._get( inst, "duration" );
7955  inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
7956  $.datepicker._datepickerShowing = true;
7957 
7958  if ( $.effects && $.effects.effect[ showAnim ] ) {
7959  inst.dpDiv.show( showAnim, $.datepicker._get( inst, "showOptions" ), duration );
7960  } else {
7961  inst.dpDiv[ showAnim || "show" ]( showAnim ? duration : null );
7962  }
7963 
7964  if ( $.datepicker._shouldFocusInput( inst ) ) {
7965  inst.input.trigger( "focus" );
7966  }
7967 
7968  $.datepicker._curInst = inst;
7969  }
7970  },
7971 
7972  /* Generate the date picker content. */
7973  _updateDatepicker: function( inst ) {
7974  this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
7975  datepicker_instActive = inst; // for delegate hover events
7976  inst.dpDiv.empty().append( this._generateHTML( inst ) );
7977  this._attachHandlers( inst );
7978 
7979  var origyearshtml,
7980  numMonths = this._getNumberOfMonths( inst ),
7981  cols = numMonths[ 1 ],
7982  width = 17,
7983  activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
7984 
7985  if ( activeCell.length > 0 ) {
7986  datepicker_handleMouseover.apply( activeCell.get( 0 ) );
7987  }
7988 
7989  inst.dpDiv.removeClass( "ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4" ).width( "" );
7990  if ( cols > 1 ) {
7991  inst.dpDiv.addClass( "ui-datepicker-multi-" + cols ).css( "width", ( width * cols ) + "em" );
7992  }
7993  inst.dpDiv[ ( numMonths[ 0 ] !== 1 || numMonths[ 1 ] !== 1 ? "add" : "remove" ) +
7994  "Class" ]( "ui-datepicker-multi" );
7995  inst.dpDiv[ ( this._get( inst, "isRTL" ) ? "add" : "remove" ) +
7996  "Class" ]( "ui-datepicker-rtl" );
7997 
7998  if ( inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
7999  inst.input.trigger( "focus" );
8000  }
8001 
8002  // Deffered render of the years select (to avoid flashes on Firefox)
8003  if ( inst.yearshtml ) {
8004  origyearshtml = inst.yearshtml;
8005  setTimeout( function() {
8006 
8007  //assure that inst.yearshtml didn't change.
8008  if ( origyearshtml === inst.yearshtml && inst.yearshtml ) {
8009  inst.dpDiv.find( "select.ui-datepicker-year:first" ).replaceWith( inst.yearshtml );
8010  }
8011  origyearshtml = inst.yearshtml = null;
8012  }, 0 );
8013  }
8014  },
8015 
8016  // #6694 - don't focus the input if it's already focused
8017  // this breaks the change event in IE
8018  // Support: IE and jQuery <1.9
8019  _shouldFocusInput: function( inst ) {
8020  return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
8021  },
8022 
8023  /* Check positioning to remain on screen. */
8024  _checkOffset: function( inst, offset, isFixed ) {
8025  var dpWidth = inst.dpDiv.outerWidth(),
8026  dpHeight = inst.dpDiv.outerHeight(),
8027  inputWidth = inst.input ? inst.input.outerWidth() : 0,
8028  inputHeight = inst.input ? inst.input.outerHeight() : 0,
8029  viewWidth = document.documentElement.clientWidth + ( isFixed ? 0 : $( document ).scrollLeft() ),
8030  viewHeight = document.documentElement.clientHeight + ( isFixed ? 0 : $( document ).scrollTop() );
8031 
8032  offset.left -= ( this._get( inst, "isRTL" ) ? ( dpWidth - inputWidth ) : 0 );
8033  offset.left -= ( isFixed && offset.left === inst.input.offset().left ) ? $( document ).scrollLeft() : 0;
8034  offset.top -= ( isFixed && offset.top === ( inst.input.offset().top + inputHeight ) ) ? $( document ).scrollTop() : 0;
8035 
8036  // Now check if datepicker is showing outside window viewport - move to a better place if so.
8037  offset.left -= Math.min( offset.left, ( offset.left + dpWidth > viewWidth && viewWidth > dpWidth ) ?
8038  Math.abs( offset.left + dpWidth - viewWidth ) : 0 );
8039  offset.top -= Math.min( offset.top, ( offset.top + dpHeight > viewHeight && viewHeight > dpHeight ) ?
8040  Math.abs( dpHeight + inputHeight ) : 0 );
8041 
8042  return offset;
8043  },
8044 
8045  /* Find an object's position on the screen. */
8046  _findPos: function( obj ) {
8047  var position,
8048  inst = this._getInst( obj ),
8049  isRTL = this._get( inst, "isRTL" );
8050 
8051  while ( obj && ( obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden( obj ) ) ) {
8052  obj = obj[ isRTL ? "previousSibling" : "nextSibling" ];
8053  }
8054 
8055  position = $( obj ).offset();
8056  return [ position.left, position.top ];
8057  },
8058 
8059  /* Hide the date picker from view.
8060  * @param input element - the input field attached to the date picker
8061  */
8062  _hideDatepicker: function( input ) {
8063  var showAnim, duration, postProcess, onClose,
8064  inst = this._curInst;
8065 
8066  if ( !inst || ( input && inst !== $.data( input, "datepicker" ) ) ) {
8067  return;
8068  }
8069 
8070  if ( this._datepickerShowing ) {
8071  showAnim = this._get( inst, "showAnim" );
8072  duration = this._get( inst, "duration" );
8073  postProcess = function() {
8074  $.datepicker._tidyDialog( inst );
8075  };
8076 
8077  // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
8078  if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
8079  inst.dpDiv.hide( showAnim, $.datepicker._get( inst, "showOptions" ), duration, postProcess );
8080  } else {
8081  inst.dpDiv[ ( showAnim === "slideDown" ? "slideUp" :
8082  ( showAnim === "fadeIn" ? "fadeOut" : "hide" ) ) ]( ( showAnim ? duration : null ), postProcess );
8083  }
8084 
8085  if ( !showAnim ) {
8086  postProcess();
8087  }
8088  this._datepickerShowing = false;
8089 
8090  onClose = this._get( inst, "onClose" );
8091  if ( onClose ) {
8092  onClose.apply( ( inst.input ? inst.input[ 0 ] : null ), [ ( inst.input ? inst.input.val() : "" ), inst ] );
8093  }
8094 
8095  this._lastInput = null;
8096  if ( this._inDialog ) {
8097  this._dialogInput.css( { position: "absolute", left: "0", top: "-100px" } );
8098  if ( $.blockUI ) {
8099  $.unblockUI();
8100  $( "body" ).append( this.dpDiv );
8101  }
8102  }
8103  this._inDialog = false;
8104  }
8105  },
8106 
8107  /* Tidy up after a dialog display. */
8108  _tidyDialog: function( inst ) {
8109  inst.dpDiv.removeClass( this._dialogClass ).off( ".ui-datepicker-calendar" );
8110  },
8111 
8112  /* Close date picker if clicked elsewhere. */
8113  _checkExternalClick: function( event ) {
8114  if ( !$.datepicker._curInst ) {
8115  return;
8116  }
8117 
8118  var $target = $( event.target ),
8119  inst = $.datepicker._getInst( $target[ 0 ] );
8120 
8121  if ( ( ( $target[ 0 ].id !== $.datepicker._mainDivId &&
8122  $target.parents( "#" + $.datepicker._mainDivId ).length === 0 &&
8123  !$target.hasClass( $.datepicker.markerClassName ) &&
8124  !$target.closest( "." + $.datepicker._triggerClass ).length &&
8125  $.datepicker._datepickerShowing && !( $.datepicker._inDialog && $.blockUI ) ) ) ||
8126  ( $target.hasClass( $.datepicker.markerClassName ) && $.datepicker._curInst !== inst ) ) {
8127  $.datepicker._hideDatepicker();
8128  }
8129  },
8130 
8131  /* Adjust one of the date sub-fields. */
8132  _adjustDate: function( id, offset, period ) {
8133  var target = $( id ),
8134  inst = this._getInst( target[ 0 ] );
8135 
8136  if ( this._isDisabledDatepicker( target[ 0 ] ) ) {
8137  return;
8138  }
8139  this._adjustInstDate( inst, offset +
8140  ( period === "M" ? this._get( inst, "showCurrentAtPos" ) : 0 ), // undo positioning
8141  period );
8142  this._updateDatepicker( inst );
8143  },
8144 
8145  /* Action for current link. */
8146  _gotoToday: function( id ) {
8147  var date,
8148  target = $( id ),
8149  inst = this._getInst( target[ 0 ] );
8150 
8151  if ( this._get( inst, "gotoCurrent" ) && inst.currentDay ) {
8152  inst.selectedDay = inst.currentDay;
8153  inst.drawMonth = inst.selectedMonth = inst.currentMonth;
8154  inst.drawYear = inst.selectedYear = inst.currentYear;
8155  } else {
8156  date = new Date();
8157  inst.selectedDay = date.getDate();
8158  inst.drawMonth = inst.selectedMonth = date.getMonth();
8159  inst.drawYear = inst.selectedYear = date.getFullYear();
8160  }
8161  this._notifyChange( inst );
8162  this._adjustDate( target );
8163  },
8164 
8165  /* Action for selecting a new month/year. */
8166  _selectMonthYear: function( id, select, period ) {
8167  var target = $( id ),
8168  inst = this._getInst( target[ 0 ] );
8169 
8170  inst[ "selected" + ( period === "M" ? "Month" : "Year" ) ] =
8171  inst[ "draw" + ( period === "M" ? "Month" : "Year" ) ] =
8172  parseInt( select.options[ select.selectedIndex ].value, 10 );
8173 
8174  this._notifyChange( inst );
8175  this._adjustDate( target );
8176  },
8177 
8178  /* Action for selecting a day. */
8179  _selectDay: function( id, month, year, td ) {
8180  var inst,
8181  target = $( id );
8182 
8183  if ( $( td ).hasClass( this._unselectableClass ) || this._isDisabledDatepicker( target[ 0 ] ) ) {
8184  return;
8185  }
8186 
8187  inst = this._getInst( target[ 0 ] );
8188  inst.selectedDay = inst.currentDay = $( "a", td ).html();
8189  inst.selectedMonth = inst.currentMonth = month;
8190  inst.selectedYear = inst.currentYear = year;
8191  this._selectDate( id, this._formatDate( inst,
8192  inst.currentDay, inst.currentMonth, inst.currentYear ) );
8193  },
8194 
8195  /* Erase the input field and hide the date picker. */
8196  _clearDate: function( id ) {
8197  var target = $( id );
8198  this._selectDate( target, "" );
8199  },
8200 
8201  /* Update the input field with the selected date. */
8202  _selectDate: function( id, dateStr ) {
8203  var onSelect,
8204  target = $( id ),
8205  inst = this._getInst( target[ 0 ] );
8206 
8207  dateStr = ( dateStr != null ? dateStr : this._formatDate( inst ) );
8208  if ( inst.input ) {
8209  inst.input.val( dateStr );
8210  }
8211  this._updateAlternate( inst );
8212 
8213  onSelect = this._get( inst, "onSelect" );
8214  if ( onSelect ) {
8215  onSelect.apply( ( inst.input ? inst.input[ 0 ] : null ), [ dateStr, inst ] ); // trigger custom callback
8216  } else if ( inst.input ) {
8217  inst.input.trigger( "change" ); // fire the change event
8218  }
8219 
8220  if ( inst.inline ) {
8221  this._updateDatepicker( inst );
8222  } else {
8223  this._hideDatepicker();
8224  this._lastInput = inst.input[ 0 ];
8225  if ( typeof( inst.input[ 0 ] ) !== "object" ) {
8226  inst.input.trigger( "focus" ); // restore focus
8227  }
8228  this._lastInput = null;
8229  }
8230  },
8231 
8232  /* Update any alternate field to synchronise with the main field. */
8233  _updateAlternate: function( inst ) {
8234  var altFormat, date, dateStr,
8235  altField = this._get( inst, "altField" );
8236 
8237  if ( altField ) { // update alternate field too
8238  altFormat = this._get( inst, "altFormat" ) || this._get( inst, "dateFormat" );
8239  date = this._getDate( inst );
8240  dateStr = this.formatDate( altFormat, date, this._getFormatConfig( inst ) );
8241  $( altField ).val( dateStr );
8242  }
8243  },
8244 
8245  /* Set as beforeShowDay function to prevent selection of weekends.
8246  * @param date Date - the date to customise
8247  * @return [boolean, string] - is this date selectable?, what is its CSS class?
8248  */
8249  noWeekends: function( date ) {
8250  var day = date.getDay();
8251  return [ ( day > 0 && day < 6 ), "" ];
8252  },
8253 
8254  /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
8255  * @param date Date - the date to get the week for
8256  * @return number - the number of the week within the year that contains this date
8257  */
8258  iso8601Week: function( date ) {
8259  var time,
8260  checkDate = new Date( date.getTime() );
8261 
8262  // Find Thursday of this week starting on Monday
8263  checkDate.setDate( checkDate.getDate() + 4 - ( checkDate.getDay() || 7 ) );
8264 
8265  time = checkDate.getTime();
8266  checkDate.setMonth( 0 ); // Compare with Jan 1
8267  checkDate.setDate( 1 );
8268  return Math.floor( Math.round( ( time - checkDate ) / 86400000 ) / 7 ) + 1;
8269  },
8270 
8271  /* Parse a string value into a date object.
8272  * See formatDate below for the possible formats.
8273  *
8274  * @param format string - the expected format of the date
8275  * @param value string - the date in the above format
8276  * @param settings Object - attributes include:
8277  * shortYearCutoff number - the cutoff year for determining the century (optional)
8278  * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
8279  * dayNames string[7] - names of the days from Sunday (optional)
8280  * monthNamesShort string[12] - abbreviated names of the months (optional)
8281  * monthNames string[12] - names of the months (optional)
8282  * @return Date - the extracted date value or null if value is blank
8283  */
8284  parseDate: function( format, value, settings ) {
8285  if ( format == null || value == null ) {
8286  throw "Invalid arguments";
8287  }
8288 
8289  value = ( typeof value === "object" ? value.toString() : value + "" );
8290  if ( value === "" ) {
8291  return null;
8292  }
8293 
8294  var iFormat, dim, extra,
8295  iValue = 0,
8296  shortYearCutoffTemp = ( settings ? settings.shortYearCutoff : null ) || this._defaults.shortYearCutoff,
8297  shortYearCutoff = ( typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
8298  new Date().getFullYear() % 100 + parseInt( shortYearCutoffTemp, 10 ) ),
8299  dayNamesShort = ( settings ? settings.dayNamesShort : null ) || this._defaults.dayNamesShort,
8300  dayNames = ( settings ? settings.dayNames : null ) || this._defaults.dayNames,
8301  monthNamesShort = ( settings ? settings.monthNamesShort : null ) || this._defaults.monthNamesShort,
8302  monthNames = ( settings ? settings.monthNames : null ) || this._defaults.monthNames,
8303  year = -1,
8304  month = -1,
8305  day = -1,
8306  doy = -1,
8307  literal = false,
8308  date,
8309 
8310  // Check whether a format character is doubled
8311  lookAhead = function( match ) {
8312  var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match );
8313  if ( matches ) {
8314  iFormat++;
8315  }
8316  return matches;
8317  },
8318 
8319  // Extract a number from the string value
8320  getNumber = function( match ) {
8321  var isDoubled = lookAhead( match ),
8322  size = ( match === "@" ? 14 : ( match === "!" ? 20 :
8323  ( match === "y" && isDoubled ? 4 : ( match === "o" ? 3 : 2 ) ) ) ),
8324  minSize = ( match === "y" ? size : 1 ),
8325  digits = new RegExp( "^\\d{" + minSize + "," + size + "}" ),
8326  num = value.substring( iValue ).match( digits );
8327  if ( !num ) {
8328  throw "Missing number at position " + iValue;
8329  }
8330  iValue += num[ 0 ].length;
8331  return parseInt( num[ 0 ], 10 );
8332  },
8333 
8334  // Extract a name from the string value and convert to an index
8335  getName = function( match, shortNames, longNames ) {
8336  var index = -1,
8337  names = $.map( lookAhead( match ) ? longNames : shortNames, function( v, k ) {
8338  return [ [ k, v ] ];
8339  } ).sort( function( a, b ) {
8340  return -( a[ 1 ].length - b[ 1 ].length );
8341  } );
8342 
8343  $.each( names, function( i, pair ) {
8344  var name = pair[ 1 ];
8345  if ( value.substr( iValue, name.length ).toLowerCase() === name.toLowerCase() ) {
8346  index = pair[ 0 ];
8347  iValue += name.length;
8348  return false;
8349  }
8350  } );
8351  if ( index !== -1 ) {
8352  return index + 1;
8353  } else {
8354  throw "Unknown name at position " + iValue;
8355  }
8356  },
8357 
8358  // Confirm that a literal character matches the string value
8359  checkLiteral = function() {
8360  if ( value.charAt( iValue ) !== format.charAt( iFormat ) ) {
8361  throw "Unexpected literal at position " + iValue;
8362  }
8363  iValue++;
8364  };
8365 
8366  for ( iFormat = 0; iFormat < format.length; iFormat++ ) {
8367  if ( literal ) {
8368  if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) {
8369  literal = false;
8370  } else {
8371  checkLiteral();
8372  }
8373  } else {
8374  switch ( format.charAt( iFormat ) ) {
8375  case "d":
8376  day = getNumber( "d" );
8377  break;
8378  case "D":
8379  getName( "D", dayNamesShort, dayNames );
8380  break;
8381  case "o":
8382  doy = getNumber( "o" );
8383  break;
8384  case "m":
8385  month = getNumber( "m" );
8386  break;
8387  case "M":
8388  month = getName( "M", monthNamesShort, monthNames );
8389  break;
8390  case "y":
8391  year = getNumber( "y" );
8392  break;
8393  case "@":
8394  date = new Date( getNumber( "@" ) );
8395  year = date.getFullYear();
8396  month = date.getMonth() + 1;
8397  day = date.getDate();
8398  break;
8399  case "!":
8400  date = new Date( ( getNumber( "!" ) - this._ticksTo1970 ) / 10000 );
8401  year = date.getFullYear();
8402  month = date.getMonth() + 1;
8403  day = date.getDate();
8404  break;
8405  case "'":
8406  if ( lookAhead( "'" ) ) {
8407  checkLiteral();
8408  } else {
8409  literal = true;
8410  }
8411  break;
8412  default:
8413  checkLiteral();
8414  }
8415  }
8416  }
8417 
8418  if ( iValue < value.length ) {
8419  extra = value.substr( iValue );
8420  if ( !/^\s+/.test( extra ) ) {
8421  throw "Extra/unparsed characters found in date: " + extra;
8422  }
8423  }
8424 
8425  if ( year === -1 ) {
8426  year = new Date().getFullYear();
8427  } else if ( year < 100 ) {
8428  year += new Date().getFullYear() - new Date().getFullYear() % 100 +
8429  ( year <= shortYearCutoff ? 0 : -100 );
8430  }
8431 
8432  if ( doy > -1 ) {
8433  month = 1;
8434  day = doy;
8435  do {
8436  dim = this._getDaysInMonth( year, month - 1 );
8437  if ( day <= dim ) {
8438  break;
8439  }
8440  month++;
8441  day -= dim;
8442  } while ( true );
8443  }
8444 
8445  date = this._daylightSavingAdjust( new Date( year, month - 1, day ) );
8446  if ( date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day ) {
8447  throw "Invalid date"; // E.g. 31/02/00
8448  }
8449  return date;
8450  },
8451 
8452  /* Standard date formats. */
8453  ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
8454  COOKIE: "D, dd M yy",
8455  ISO_8601: "yy-mm-dd",
8456  RFC_822: "D, d M y",
8457  RFC_850: "DD, dd-M-y",
8458  RFC_1036: "D, d M y",
8459  RFC_1123: "D, d M yy",
8460  RFC_2822: "D, d M yy",
8461  RSS: "D, d M y", // RFC 822
8462  TICKS: "!",
8463  TIMESTAMP: "@",
8464  W3C: "yy-mm-dd", // ISO 8601
8465 
8466  _ticksTo1970: ( ( ( 1970 - 1 ) * 365 + Math.floor( 1970 / 4 ) - Math.floor( 1970 / 100 ) +
8467  Math.floor( 1970 / 400 ) ) * 24 * 60 * 60 * 10000000 ),
8468 
8469  /* Format a date object into a string value.
8470  * The format can be combinations of the following:
8471  * d - day of month (no leading zero)
8472  * dd - day of month (two digit)
8473  * o - day of year (no leading zeros)
8474  * oo - day of year (three digit)
8475  * D - day name short
8476  * DD - day name long
8477  * m - month of year (no leading zero)
8478  * mm - month of year (two digit)
8479  * M - month name short
8480  * MM - month name long
8481  * y - year (two digit)
8482  * yy - year (four digit)
8483  * @ - Unix timestamp (ms since 01/01/1970)
8484  * ! - Windows ticks (100ns since 01/01/0001)
8485  * "..." - literal text
8486  * '' - single quote
8487  *
8488  * @param format string - the desired format of the date
8489  * @param date Date - the date value to format
8490  * @param settings Object - attributes include:
8491  * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
8492  * dayNames string[7] - names of the days from Sunday (optional)
8493  * monthNamesShort string[12] - abbreviated names of the months (optional)
8494  * monthNames string[12] - names of the months (optional)
8495  * @return string - the date in the above format
8496  */
8497  formatDate: function( format, date, settings ) {
8498  if ( !date ) {
8499  return "";
8500  }
8501 
8502  var iFormat,
8503  dayNamesShort = ( settings ? settings.dayNamesShort : null ) || this._defaults.dayNamesShort,
8504  dayNames = ( settings ? settings.dayNames : null ) || this._defaults.dayNames,
8505  monthNamesShort = ( settings ? settings.monthNamesShort : null ) || this._defaults.monthNamesShort,
8506  monthNames = ( settings ? settings.monthNames : null ) || this._defaults.monthNames,
8507 
8508  // Check whether a format character is doubled
8509  lookAhead = function( match ) {
8510  var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match );
8511  if ( matches ) {
8512  iFormat++;
8513  }
8514  return matches;
8515  },
8516 
8517  // Format a number, with leading zero if necessary
8518  formatNumber = function( match, value, len ) {
8519  var num = "" + value;
8520  if ( lookAhead( match ) ) {
8521  while ( num.length < len ) {
8522  num = "0" + num;
8523  }
8524  }
8525  return num;
8526  },
8527 
8528  // Format a name, short or long as requested
8529  formatName = function( match, value, shortNames, longNames ) {
8530  return ( lookAhead( match ) ? longNames[ value ] : shortNames[ value ] );
8531  },
8532  output = "",
8533  literal = false;
8534 
8535  if ( date ) {
8536  for ( iFormat = 0; iFormat < format.length; iFormat++ ) {
8537  if ( literal ) {
8538  if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) {
8539  literal = false;
8540  } else {
8541  output += format.charAt( iFormat );
8542  }
8543  } else {
8544  switch ( format.charAt( iFormat ) ) {
8545  case "d":
8546  output += formatNumber( "d", date.getDate(), 2 );
8547  break;
8548  case "D":
8549  output += formatName( "D", date.getDay(), dayNamesShort, dayNames );
8550  break;
8551  case "o":
8552  output += formatNumber( "o",
8553  Math.round( ( new Date( date.getFullYear(), date.getMonth(), date.getDate() ).getTime() - new Date( date.getFullYear(), 0, 0 ).getTime() ) / 86400000 ), 3 );
8554  break;
8555  case "m":
8556  output += formatNumber( "m", date.getMonth() + 1, 2 );
8557  break;
8558  case "M":
8559  output += formatName( "M", date.getMonth(), monthNamesShort, monthNames );
8560  break;
8561  case "y":
8562  output += ( lookAhead( "y" ) ? date.getFullYear() :
8563  ( date.getFullYear() % 100 < 10 ? "0" : "" ) + date.getFullYear() % 100 );
8564  break;
8565  case "@":
8566  output += date.getTime();
8567  break;
8568  case "!":
8569  output += date.getTime() * 10000 + this._ticksTo1970;
8570  break;
8571  case "'":
8572  if ( lookAhead( "'" ) ) {
8573  output += "'";
8574  } else {
8575  literal = true;
8576  }
8577  break;
8578  default:
8579  output += format.charAt( iFormat );
8580  }
8581  }
8582  }
8583  }
8584  return output;
8585  },
8586 
8587  /* Extract all possible characters from the date format. */
8588  _possibleChars: function( format ) {
8589  var iFormat,
8590  chars = "",
8591  literal = false,
8592 
8593  // Check whether a format character is doubled
8594  lookAhead = function( match ) {
8595  var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match );
8596  if ( matches ) {
8597  iFormat++;
8598  }
8599  return matches;
8600  };
8601 
8602  for ( iFormat = 0; iFormat < format.length; iFormat++ ) {
8603  if ( literal ) {
8604  if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) {
8605  literal = false;
8606  } else {
8607  chars += format.charAt( iFormat );
8608  }
8609  } else {
8610  switch ( format.charAt( iFormat ) ) {
8611  case "d": case "m": case "y": case "@":
8612  chars += "0123456789";
8613  break;
8614  case "D": case "M":
8615  return null; // Accept anything
8616  case "'":
8617  if ( lookAhead( "'" ) ) {
8618  chars += "'";
8619  } else {
8620  literal = true;
8621  }
8622  break;
8623  default:
8624  chars += format.charAt( iFormat );
8625  }
8626  }
8627  }
8628  return chars;
8629  },
8630 
8631  /* Get a setting value, defaulting if necessary. */
8632  _get: function( inst, name ) {
8633  return inst.settings[ name ] !== undefined ?
8634  inst.settings[ name ] : this._defaults[ name ];
8635  },
8636 
8637  /* Parse existing date and initialise date picker. */
8638  _setDateFromField: function( inst, noDefault ) {
8639  if ( inst.input.val() === inst.lastVal ) {
8640  return;
8641  }
8642 
8643  var dateFormat = this._get( inst, "dateFormat" ),
8644  dates = inst.lastVal = inst.input ? inst.input.val() : null,
8645  defaultDate = this._getDefaultDate( inst ),
8646  date = defaultDate,
8647  settings = this._getFormatConfig( inst );
8648 
8649  try {
8650  date = this.parseDate( dateFormat, dates, settings ) || defaultDate;
8651  } catch ( event ) {
8652  dates = ( noDefault ? "" : dates );
8653  }
8654  inst.selectedDay = date.getDate();
8655  inst.drawMonth = inst.selectedMonth = date.getMonth();
8656  inst.drawYear = inst.selectedYear = date.getFullYear();
8657  inst.currentDay = ( dates ? date.getDate() : 0 );
8658  inst.currentMonth = ( dates ? date.getMonth() : 0 );
8659  inst.currentYear = ( dates ? date.getFullYear() : 0 );
8660  this._adjustInstDate( inst );
8661  },
8662 
8663  /* Retrieve the default date shown on opening. */
8664  _getDefaultDate: function( inst ) {
8665  return this._restrictMinMax( inst,
8666  this._determineDate( inst, this._get( inst, "defaultDate" ), new Date() ) );
8667  },
8668 
8669  /* A date may be specified as an exact value or a relative one. */
8670  _determineDate: function( inst, date, defaultDate ) {
8671  var offsetNumeric = function( offset ) {
8672  var date = new Date();
8673  date.setDate( date.getDate() + offset );
8674  return date;
8675  },
8676  offsetString = function( offset ) {
8677  try {
8678  return $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ),
8679  offset, $.datepicker._getFormatConfig( inst ) );
8680  }
8681  catch ( e ) {
8682 
8683  // Ignore
8684  }
8685 
8686  var date = ( offset.toLowerCase().match( /^c/ ) ?
8687  $.datepicker._getDate( inst ) : null ) || new Date(),
8688  year = date.getFullYear(),
8689  month = date.getMonth(),
8690  day = date.getDate(),
8691  pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
8692  matches = pattern.exec( offset );
8693 
8694  while ( matches ) {
8695  switch ( matches[ 2 ] || "d" ) {
8696  case "d" : case "D" :
8697  day += parseInt( matches[ 1 ], 10 ); break;
8698  case "w" : case "W" :
8699  day += parseInt( matches[ 1 ], 10 ) * 7; break;
8700  case "m" : case "M" :
8701  month += parseInt( matches[ 1 ], 10 );
8702  day = Math.min( day, $.datepicker._getDaysInMonth( year, month ) );
8703  break;
8704  case "y": case "Y" :
8705  year += parseInt( matches[ 1 ], 10 );
8706  day = Math.min( day, $.datepicker._getDaysInMonth( year, month ) );
8707  break;
8708  }
8709  matches = pattern.exec( offset );
8710  }
8711  return new Date( year, month, day );
8712  },
8713  newDate = ( date == null || date === "" ? defaultDate : ( typeof date === "string" ? offsetString( date ) :
8714  ( typeof date === "number" ? ( isNaN( date ) ? defaultDate : offsetNumeric( date ) ) : new Date( date.getTime() ) ) ) );
8715 
8716  newDate = ( newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate );
8717  if ( newDate ) {
8718  newDate.setHours( 0 );
8719  newDate.setMinutes( 0 );
8720  newDate.setSeconds( 0 );
8721  newDate.setMilliseconds( 0 );
8722  }
8723  return this._daylightSavingAdjust( newDate );
8724  },
8725 
8726  /* Handle switch to/from daylight saving.
8727  * Hours may be non-zero on daylight saving cut-over:
8728  * > 12 when midnight changeover, but then cannot generate
8729  * midnight datetime, so jump to 1AM, otherwise reset.
8730  * @param date (Date) the date to check
8731  * @return (Date) the corrected date
8732  */
8733  _daylightSavingAdjust: function( date ) {
8734  if ( !date ) {
8735  return null;
8736  }
8737  date.setHours( date.getHours() > 12 ? date.getHours() + 2 : 0 );
8738  return date;
8739  },
8740 
8741  /* Set the date(s) directly. */
8742  _setDate: function( inst, date, noChange ) {
8743  var clear = !date,
8744  origMonth = inst.selectedMonth,
8745  origYear = inst.selectedYear,
8746  newDate = this._restrictMinMax( inst, this._determineDate( inst, date, new Date() ) );
8747 
8748  inst.selectedDay = inst.currentDay = newDate.getDate();
8749  inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
8750  inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
8751  if ( ( origMonth !== inst.selectedMonth || origYear !== inst.selectedYear ) && !noChange ) {
8752  this._notifyChange( inst );
8753  }
8754  this._adjustInstDate( inst );
8755  if ( inst.input ) {
8756  inst.input.val( clear ? "" : this._formatDate( inst ) );
8757  }
8758  },
8759 
8760  /* Retrieve the date(s) directly. */
8761  _getDate: function( inst ) {
8762  var startDate = ( !inst.currentYear || ( inst.input && inst.input.val() === "" ) ? null :
8763  this._daylightSavingAdjust( new Date(
8764  inst.currentYear, inst.currentMonth, inst.currentDay ) ) );
8765  return startDate;
8766  },
8767 
8768  /* Attach the onxxx handlers. These are declared statically so
8769  * they work with static code transformers like Caja.
8770  */
8771  _attachHandlers: function( inst ) {
8772  var stepMonths = this._get( inst, "stepMonths" ),
8773  id = "#" + inst.id.replace( /\\\\/g, "\\" );
8774  inst.dpDiv.find( "[data-handler]" ).map( function() {
8775  var handler = {
8776  prev: function() {
8777  $.datepicker._adjustDate( id, -stepMonths, "M" );
8778  },
8779  next: function() {
8780  $.datepicker._adjustDate( id, +stepMonths, "M" );
8781  },
8782  hide: function() {
8783  $.datepicker._hideDatepicker();
8784  },
8785  today: function() {
8786  $.datepicker._gotoToday( id );
8787  },
8788  selectDay: function() {
8789  $.datepicker._selectDay( id, +this.getAttribute( "data-month" ), +this.getAttribute( "data-year" ), this );
8790  return false;
8791  },
8792  selectMonth: function() {
8793  $.datepicker._selectMonthYear( id, this, "M" );
8794  return false;
8795  },
8796  selectYear: function() {
8797  $.datepicker._selectMonthYear( id, this, "Y" );
8798  return false;
8799  }
8800  };
8801  $( this ).on( this.getAttribute( "data-event" ), handler[ this.getAttribute( "data-handler" ) ] );
8802  } );
8803  },
8804 
8805  /* Generate the HTML for the current state of the date picker. */
8806  _generateHTML: function( inst ) {
8807  var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
8808  controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
8809  monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
8810  selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
8811  cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
8812  printDate, dRow, tbody, daySettings, otherMonth, unselectable,
8813  tempDate = new Date(),
8814  today = this._daylightSavingAdjust(
8815  new Date( tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate() ) ), // clear time
8816  isRTL = this._get( inst, "isRTL" ),
8817  showButtonPanel = this._get( inst, "showButtonPanel" ),
8818  hideIfNoPrevNext = this._get( inst, "hideIfNoPrevNext" ),
8819  navigationAsDateFormat = this._get( inst, "navigationAsDateFormat" ),
8820  numMonths = this._getNumberOfMonths( inst ),
8821  showCurrentAtPos = this._get( inst, "showCurrentAtPos" ),
8822  stepMonths = this._get( inst, "stepMonths" ),
8823  isMultiMonth = ( numMonths[ 0 ] !== 1 || numMonths[ 1 ] !== 1 ),
8824  currentDate = this._daylightSavingAdjust( ( !inst.currentDay ? new Date( 9999, 9, 9 ) :
8825  new Date( inst.currentYear, inst.currentMonth, inst.currentDay ) ) ),
8826  minDate = this._getMinMaxDate( inst, "min" ),
8827  maxDate = this._getMinMaxDate( inst, "max" ),
8828  drawMonth = inst.drawMonth - showCurrentAtPos,
8829  drawYear = inst.drawYear;
8830 
8831  if ( drawMonth < 0 ) {
8832  drawMonth += 12;
8833  drawYear--;
8834  }
8835  if ( maxDate ) {
8836  maxDraw = this._daylightSavingAdjust( new Date( maxDate.getFullYear(),
8837  maxDate.getMonth() - ( numMonths[ 0 ] * numMonths[ 1 ] ) + 1, maxDate.getDate() ) );
8838  maxDraw = ( minDate && maxDraw < minDate ? minDate : maxDraw );
8839  while ( this._daylightSavingAdjust( new Date( drawYear, drawMonth, 1 ) ) > maxDraw ) {
8840  drawMonth--;
8841  if ( drawMonth < 0 ) {
8842  drawMonth = 11;
8843  drawYear--;
8844  }
8845  }
8846  }
8847  inst.drawMonth = drawMonth;
8848  inst.drawYear = drawYear;
8849 
8850  prevText = this._get( inst, "prevText" );
8851  prevText = ( !navigationAsDateFormat ? prevText : this.formatDate( prevText,
8852  this._daylightSavingAdjust( new Date( drawYear, drawMonth - stepMonths, 1 ) ),
8853  this._getFormatConfig( inst ) ) );
8854 
8855  prev = ( this._canAdjustMonth( inst, -1, drawYear, drawMonth ) ?
8856  "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
8857  " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w" ) + "'>" + prevText + "</span></a>" :
8858  ( 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>" ) );
8859 
8860  nextText = this._get( inst, "nextText" );
8861  nextText = ( !navigationAsDateFormat ? nextText : this.formatDate( nextText,
8862  this._daylightSavingAdjust( new Date( drawYear, drawMonth + stepMonths, 1 ) ),
8863  this._getFormatConfig( inst ) ) );
8864 
8865  next = ( this._canAdjustMonth( inst, +1, drawYear, drawMonth ) ?
8866  "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
8867  " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e" ) + "'>" + nextText + "</span></a>" :
8868  ( 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>" ) );
8869 
8870  currentText = this._get( inst, "currentText" );
8871  gotoDate = ( this._get( inst, "gotoCurrent" ) && inst.currentDay ? currentDate : today );
8872  currentText = ( !navigationAsDateFormat ? currentText :
8873  this.formatDate( currentText, gotoDate, this._getFormatConfig( inst ) ) );
8874 
8875  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'>" +
8876  this._get( inst, "closeText" ) + "</button>" : "" );
8877 
8878  buttonPanel = ( showButtonPanel ) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + ( isRTL ? controls : "" ) +
8879  ( 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'" +
8880  ">" + currentText + "</button>" : "" ) + ( isRTL ? "" : controls ) + "</div>" : "";
8881 
8882  firstDay = parseInt( this._get( inst, "firstDay" ), 10 );
8883  firstDay = ( isNaN( firstDay ) ? 0 : firstDay );
8884 
8885  showWeek = this._get( inst, "showWeek" );
8886  dayNames = this._get( inst, "dayNames" );
8887  dayNamesMin = this._get( inst, "dayNamesMin" );
8888  monthNames = this._get( inst, "monthNames" );
8889  monthNamesShort = this._get( inst, "monthNamesShort" );
8890  beforeShowDay = this._get( inst, "beforeShowDay" );
8891  showOtherMonths = this._get( inst, "showOtherMonths" );
8892  selectOtherMonths = this._get( inst, "selectOtherMonths" );
8893  defaultDate = this._getDefaultDate( inst );
8894  html = "";
8895 
8896  for ( row = 0; row < numMonths[ 0 ]; row++ ) {
8897  group = "";
8898  this.maxRows = 4;
8899  for ( col = 0; col < numMonths[ 1 ]; col++ ) {
8900  selectedDate = this._daylightSavingAdjust( new Date( drawYear, drawMonth, inst.selectedDay ) );
8901  cornerClass = " ui-corner-all";
8902  calender = "";
8903  if ( isMultiMonth ) {
8904  calender += "<div class='ui-datepicker-group";
8905  if ( numMonths[ 1 ] > 1 ) {
8906  switch ( col ) {
8907  case 0: calender += " ui-datepicker-group-first";
8908  cornerClass = " ui-corner-" + ( isRTL ? "right" : "left" ); break;
8909  case numMonths[ 1 ] - 1: calender += " ui-datepicker-group-last";
8910  cornerClass = " ui-corner-" + ( isRTL ? "left" : "right" ); break;
8911  default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
8912  }
8913  }
8914  calender += "'>";
8915  }
8916  calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
8917  ( /all|left/.test( cornerClass ) && row === 0 ? ( isRTL ? next : prev ) : "" ) +
8918  ( /all|right/.test( cornerClass ) && row === 0 ? ( isRTL ? prev : next ) : "" ) +
8919  this._generateMonthYearHeader( inst, drawMonth, drawYear, minDate, maxDate,
8920  row > 0 || col > 0, monthNames, monthNamesShort ) + // draw month headers
8921  "</div><table class='ui-datepicker-calendar'><thead>" +
8922  "<tr>";
8923  thead = ( showWeek ? "<th class='ui-datepicker-week-col'>" + this._get( inst, "weekHeader" ) + "</th>" : "" );
8924  for ( dow = 0; dow < 7; dow++ ) { // days of the week
8925  day = ( dow + firstDay ) % 7;
8926  thead += "<th scope='col'" + ( ( dow + firstDay + 6 ) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "" ) + ">" +
8927  "<span title='" + dayNames[ day ] + "'>" + dayNamesMin[ day ] + "</span></th>";
8928  }
8929  calender += thead + "</tr></thead><tbody>";
8930  daysInMonth = this._getDaysInMonth( drawYear, drawMonth );
8931  if ( drawYear === inst.selectedYear && drawMonth === inst.selectedMonth ) {
8932  inst.selectedDay = Math.min( inst.selectedDay, daysInMonth );
8933  }
8934  leadDays = ( this._getFirstDayOfMonth( drawYear, drawMonth ) - firstDay + 7 ) % 7;
8935  curRows = Math.ceil( ( leadDays + daysInMonth ) / 7 ); // calculate the number of rows to generate
8936  numRows = ( isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows ); //If multiple months, use the higher number of rows (see #7043)
8937  this.maxRows = numRows;
8938  printDate = this._daylightSavingAdjust( new Date( drawYear, drawMonth, 1 - leadDays ) );
8939  for ( dRow = 0; dRow < numRows; dRow++ ) { // create date picker rows
8940  calender += "<tr>";
8941  tbody = ( !showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
8942  this._get( inst, "calculateWeek" )( printDate ) + "</td>" );
8943  for ( dow = 0; dow < 7; dow++ ) { // create date picker days
8944  daySettings = ( beforeShowDay ?
8945  beforeShowDay.apply( ( inst.input ? inst.input[ 0 ] : null ), [ printDate ] ) : [ true, "" ] );
8946  otherMonth = ( printDate.getMonth() !== drawMonth );
8947  unselectable = ( otherMonth && !selectOtherMonths ) || !daySettings[ 0 ] ||
8948  ( minDate && printDate < minDate ) || ( maxDate && printDate > maxDate );
8949  tbody += "<td class='" +
8950  ( ( dow + firstDay + 6 ) % 7 >= 5 ? " ui-datepicker-week-end" : "" ) + // highlight weekends
8951  ( otherMonth ? " ui-datepicker-other-month" : "" ) + // highlight days from other months
8952  ( ( printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent ) || // user pressed key
8953  ( defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime() ) ?
8954 
8955  // or defaultDate is current printedDate and defaultDate is selectedDate
8956  " " + this._dayOverClass : "" ) + // highlight selected day
8957  ( unselectable ? " " + this._unselectableClass + " ui-state-disabled" : "" ) + // highlight unselectable days
8958  ( otherMonth && !showOtherMonths ? "" : " " + daySettings[ 1 ] + // highlight custom dates
8959  ( printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "" ) + // highlight selected day
8960  ( printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "" ) ) + "'" + // highlight today (if different)
8961  ( ( !otherMonth || showOtherMonths ) && daySettings[ 2 ] ? " title='" + daySettings[ 2 ].replace( /'/g, "&#39;" ) + "'" : "" ) + // cell title
8962  ( unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'" ) + ">" + // actions
8963  ( otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
8964  ( unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
8965  ( printDate.getTime() === today.getTime() ? " ui-state-highlight" : "" ) +
8966  ( printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "" ) + // highlight selected day
8967  ( otherMonth ? " ui-priority-secondary" : "" ) + // distinguish dates from other months
8968  "' href='#'>" + printDate.getDate() + "</a>" ) ) + "</td>"; // display selectable date
8969  printDate.setDate( printDate.getDate() + 1 );
8970  printDate = this._daylightSavingAdjust( printDate );
8971  }
8972  calender += tbody + "</tr>";
8973  }
8974  drawMonth++;
8975  if ( drawMonth > 11 ) {
8976  drawMonth = 0;
8977  drawYear++;
8978  }
8979  calender += "</tbody></table>" + ( isMultiMonth ? "</div>" +
8980  ( ( numMonths[ 0 ] > 0 && col === numMonths[ 1 ] - 1 ) ? "<div class='ui-datepicker-row-break'></div>" : "" ) : "" );
8981  group += calender;
8982  }
8983  html += group;
8984  }
8985  html += buttonPanel;
8986  inst._keyEvent = false;
8987  return html;
8988  },
8989 
8990  /* Generate the month and year header. */
8991  _generateMonthYearHeader: function( inst, drawMonth, drawYear, minDate, maxDate,
8992  secondary, monthNames, monthNamesShort ) {
8993 
8994  var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
8995  changeMonth = this._get( inst, "changeMonth" ),
8996  changeYear = this._get( inst, "changeYear" ),
8997  showMonthAfterYear = this._get( inst, "showMonthAfterYear" ),
8998  html = "<div class='ui-datepicker-title'>",
8999  monthHtml = "";
9000 
9001  // Month selection
9002  if ( secondary || !changeMonth ) {
9003  monthHtml += "<span class='ui-datepicker-month'>" + monthNames[ drawMonth ] + "</span>";
9004  } else {
9005  inMinYear = ( minDate && minDate.getFullYear() === drawYear );
9006  inMaxYear = ( maxDate && maxDate.getFullYear() === drawYear );
9007  monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
9008  for ( month = 0; month < 12; month++ ) {
9009  if ( ( !inMinYear || month >= minDate.getMonth() ) && ( !inMaxYear || month <= maxDate.getMonth() ) ) {
9010  monthHtml += "<option value='" + month + "'" +
9011  ( month === drawMonth ? " selected='selected'" : "" ) +
9012  ">" + monthNamesShort[ month ] + "</option>";
9013  }
9014  }
9015  monthHtml += "</select>";
9016  }
9017 
9018  if ( !showMonthAfterYear ) {
9019  html += monthHtml + ( secondary || !( changeMonth && changeYear ) ? "&#xa0;" : "" );
9020  }
9021 
9022  // Year selection
9023  if ( !inst.yearshtml ) {
9024  inst.yearshtml = "";
9025  if ( secondary || !changeYear ) {
9026  html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
9027  } else {
9028 
9029  // determine range of years to display
9030  years = this._get( inst, "yearRange" ).split( ":" );
9031  thisYear = new Date().getFullYear();
9032  determineYear = function( value ) {
9033  var year = ( value.match( /c[+\-].*/ ) ? drawYear + parseInt( value.substring( 1 ), 10 ) :
9034  ( value.match( /[+\-].*/ ) ? thisYear + parseInt( value, 10 ) :
9035  parseInt( value, 10 ) ) );
9036  return ( isNaN( year ) ? thisYear : year );
9037  };
9038  year = determineYear( years[ 0 ] );
9039  endYear = Math.max( year, determineYear( years[ 1 ] || "" ) );
9040  year = ( minDate ? Math.max( year, minDate.getFullYear() ) : year );
9041  endYear = ( maxDate ? Math.min( endYear, maxDate.getFullYear() ) : endYear );
9042  inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
9043  for ( ; year <= endYear; year++ ) {
9044  inst.yearshtml += "<option value='" + year + "'" +
9045  ( year === drawYear ? " selected='selected'" : "" ) +
9046  ">" + year + "</option>";
9047  }
9048  inst.yearshtml += "</select>";
9049 
9050  html += inst.yearshtml;
9051  inst.yearshtml = null;
9052  }
9053  }
9054 
9055  html += this._get( inst, "yearSuffix" );
9056  if ( showMonthAfterYear ) {
9057  html += ( secondary || !( changeMonth && changeYear ) ? "&#xa0;" : "" ) + monthHtml;
9058  }
9059  html += "</div>"; // Close datepicker_header
9060  return html;
9061  },
9062 
9063  /* Adjust one of the date sub-fields. */
9064  _adjustInstDate: function( inst, offset, period ) {
9065  var year = inst.selectedYear + ( period === "Y" ? offset : 0 ),
9066  month = inst.selectedMonth + ( period === "M" ? offset : 0 ),
9067  day = Math.min( inst.selectedDay, this._getDaysInMonth( year, month ) ) + ( period === "D" ? offset : 0 ),
9068  date = this._restrictMinMax( inst, this._daylightSavingAdjust( new Date( year, month, day ) ) );
9069 
9070  inst.selectedDay = date.getDate();
9071  inst.drawMonth = inst.selectedMonth = date.getMonth();
9072  inst.drawYear = inst.selectedYear = date.getFullYear();
9073  if ( period === "M" || period === "Y" ) {
9074  this._notifyChange( inst );
9075  }
9076  },
9077 
9078  /* Ensure a date is within any min/max bounds. */
9079  _restrictMinMax: function( inst, date ) {
9080  var minDate = this._getMinMaxDate( inst, "min" ),
9081  maxDate = this._getMinMaxDate( inst, "max" ),
9082  newDate = ( minDate && date < minDate ? minDate : date );
9083  return ( maxDate && newDate > maxDate ? maxDate : newDate );
9084  },
9085 
9086  /* Notify change of month/year. */
9087  _notifyChange: function( inst ) {
9088  var onChange = this._get( inst, "onChangeMonthYear" );
9089  if ( onChange ) {
9090  onChange.apply( ( inst.input ? inst.input[ 0 ] : null ),
9091  [ inst.selectedYear, inst.selectedMonth + 1, inst ] );
9092  }
9093  },
9094 
9095  /* Determine the number of months to show. */
9096  _getNumberOfMonths: function( inst ) {
9097  var numMonths = this._get( inst, "numberOfMonths" );
9098  return ( numMonths == null ? [ 1, 1 ] : ( typeof numMonths === "number" ? [ 1, numMonths ] : numMonths ) );
9099  },
9100 
9101  /* Determine the current maximum date - ensure no time components are set. */
9102  _getMinMaxDate: function( inst, minMax ) {
9103  return this._determineDate( inst, this._get( inst, minMax + "Date" ), null );
9104  },
9105 
9106  /* Find the number of days in a given month. */
9107  _getDaysInMonth: function( year, month ) {
9108  return 32 - this._daylightSavingAdjust( new Date( year, month, 32 ) ).getDate();
9109  },
9110 
9111  /* Find the day of the week of the first of a month. */
9112  _getFirstDayOfMonth: function( year, month ) {
9113  return new Date( year, month, 1 ).getDay();
9114  },
9115 
9116  /* Determines if we should allow a "next/prev" month display change. */
9117  _canAdjustMonth: function( inst, offset, curYear, curMonth ) {
9118  var numMonths = this._getNumberOfMonths( inst ),
9119  date = this._daylightSavingAdjust( new Date( curYear,
9120  curMonth + ( offset < 0 ? offset : numMonths[ 0 ] * numMonths[ 1 ] ), 1 ) );
9121 
9122  if ( offset < 0 ) {
9123  date.setDate( this._getDaysInMonth( date.getFullYear(), date.getMonth() ) );
9124  }
9125  return this._isInRange( inst, date );
9126  },
9127 
9128  /* Is the given date in the accepted range? */
9129  _isInRange: function( inst, date ) {
9130  var yearSplit, currentYear,
9131  minDate = this._getMinMaxDate( inst, "min" ),
9132  maxDate = this._getMinMaxDate( inst, "max" ),
9133  minYear = null,
9134  maxYear = null,
9135  years = this._get( inst, "yearRange" );
9136  if ( years ) {
9137  yearSplit = years.split( ":" );
9138  currentYear = new Date().getFullYear();
9139  minYear = parseInt( yearSplit[ 0 ], 10 );
9140  maxYear = parseInt( yearSplit[ 1 ], 10 );
9141  if ( yearSplit[ 0 ].match( /[+\-].*/ ) ) {
9142  minYear += currentYear;
9143  }
9144  if ( yearSplit[ 1 ].match( /[+\-].*/ ) ) {
9145  maxYear += currentYear;
9146  }
9147  }
9148 
9149  return ( ( !minDate || date.getTime() >= minDate.getTime() ) &&
9150  ( !maxDate || date.getTime() <= maxDate.getTime() ) &&
9151  ( !minYear || date.getFullYear() >= minYear ) &&
9152  ( !maxYear || date.getFullYear() <= maxYear ) );
9153  },
9154 
9155  /* Provide the configuration settings for formatting/parsing. */
9156  _getFormatConfig: function( inst ) {
9157  var shortYearCutoff = this._get( inst, "shortYearCutoff" );
9158  shortYearCutoff = ( typeof shortYearCutoff !== "string" ? shortYearCutoff :
9159  new Date().getFullYear() % 100 + parseInt( shortYearCutoff, 10 ) );
9160  return { shortYearCutoff: shortYearCutoff,
9161  dayNamesShort: this._get( inst, "dayNamesShort" ), dayNames: this._get( inst, "dayNames" ),
9162  monthNamesShort: this._get( inst, "monthNamesShort" ), monthNames: this._get( inst, "monthNames" ) };
9163  },
9164 
9165  /* Format the given date for display. */
9166  _formatDate: function( inst, day, month, year ) {
9167  if ( !day ) {
9168  inst.currentDay = inst.selectedDay;
9169  inst.currentMonth = inst.selectedMonth;
9170  inst.currentYear = inst.selectedYear;
9171  }
9172  var date = ( day ? ( typeof day === "object" ? day :
9173  this._daylightSavingAdjust( new Date( year, month, day ) ) ) :
9174  this._daylightSavingAdjust( new Date( inst.currentYear, inst.currentMonth, inst.currentDay ) ) );
9175  return this.formatDate( this._get( inst, "dateFormat" ), date, this._getFormatConfig( inst ) );
9176  }
9177 } );
9178 
9179 /*
9180  * Bind hover events for datepicker elements.
9181  * Done via delegate so the binding only occurs once in the lifetime of the parent div.
9182  * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
9183  */
9184 function datepicker_bindHover( dpDiv ) {
9185  var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
9186  return dpDiv.on( "mouseout", selector, function() {
9187  $( this ).removeClass( "ui-state-hover" );
9188  if ( this.className.indexOf( "ui-datepicker-prev" ) !== -1 ) {
9189  $( this ).removeClass( "ui-datepicker-prev-hover" );
9190  }
9191  if ( this.className.indexOf( "ui-datepicker-next" ) !== -1 ) {
9192  $( this ).removeClass( "ui-datepicker-next-hover" );
9193  }
9194  } )
9195  .on( "mouseover", selector, datepicker_handleMouseover );
9196 }
9197 
9198 function datepicker_handleMouseover() {
9199  if ( !$.datepicker._isDisabledDatepicker( datepicker_instActive.inline ? datepicker_instActive.dpDiv.parent()[ 0 ] : datepicker_instActive.input[ 0 ] ) ) {
9200  $( this ).parents( ".ui-datepicker-calendar" ).find( "a" ).removeClass( "ui-state-hover" );
9201  $( this ).addClass( "ui-state-hover" );
9202  if ( this.className.indexOf( "ui-datepicker-prev" ) !== -1 ) {
9203  $( this ).addClass( "ui-datepicker-prev-hover" );
9204  }
9205  if ( this.className.indexOf( "ui-datepicker-next" ) !== -1 ) {
9206  $( this ).addClass( "ui-datepicker-next-hover" );
9207  }
9208  }
9209 }
9210 
9211 /* jQuery extend now ignores nulls! */
9212 function datepicker_extendRemove( target, props ) {
9213  $.extend( target, props );
9214  for ( var name in props ) {
9215  if ( props[ name ] == null ) {
9216  target[ name ] = props[ name ];
9217  }
9218  }
9219  return target;
9220 }
9221 
9222 /* Invoke the datepicker functionality.
9223  @param options string - a command, optionally followed by additional parameters or
9224  Object - settings for attaching new datepicker functionality
9225  @return jQuery object */
9226 $.fn.datepicker = function( options ) {
9227 
9228  /* Verify an empty collection wasn't passed - Fixes #6976 */
9229  if ( !this.length ) {
9230  return this;
9231  }
9232 
9233  /* Initialise the date picker. */
9234  if ( !$.datepicker.initialized ) {
9235  $( document ).on( "mousedown", $.datepicker._checkExternalClick );
9236  $.datepicker.initialized = true;
9237  }
9238 
9239  /* Append datepicker main container to body if not exist. */
9240  if ( $( "#" + $.datepicker._mainDivId ).length === 0 ) {
9241  $( "body" ).append( $.datepicker.dpDiv );
9242  }
9243 
9244  var otherArgs = Array.prototype.slice.call( arguments, 1 );
9245  if ( typeof options === "string" && ( options === "isDisabled" || options === "getDate" || options === "widget" ) ) {
9246  return $.datepicker[ "_" + options + "Datepicker" ].
9247  apply( $.datepicker, [ this[ 0 ] ].concat( otherArgs ) );
9248  }
9249  if ( options === "option" && arguments.length === 2 && typeof arguments[ 1 ] === "string" ) {
9250  return $.datepicker[ "_" + options + "Datepicker" ].
9251  apply( $.datepicker, [ this[ 0 ] ].concat( otherArgs ) );
9252  }
9253  return this.each( function() {
9254  typeof options === "string" ?
9255  $.datepicker[ "_" + options + "Datepicker" ].
9256  apply( $.datepicker, [ this ].concat( otherArgs ) ) :
9257  $.datepicker._attachDatepicker( this, options );
9258  } );
9259 };
9260 
9261 $.datepicker = new Datepicker(); // singleton instance
9262 $.datepicker.initialized = false;
9263 $.datepicker.uuid = new Date().getTime();
9264 $.datepicker.version = "1.12.1";
9265 
9266 var widgetsDatepicker = $.datepicker;
9267 
9268 
9269 
9270 
9271 // This file is deprecated
9272 var ie = $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
9273 
9274 /*!
9275  * jQuery UI Mouse 1.12.1
9276  * http://jqueryui.com
9277  *
9278  * Copyright jQuery Foundation and other contributors
9279  * Released under the MIT license.
9280  * http://jquery.org/license
9281  */
9282 
9283 //>>label: Mouse
9284 //>>group: Widgets
9285 //>>description: Abstracts mouse-based interactions to assist in creating certain widgets.
9286 //>>docs: http://api.jqueryui.com/mouse/
9287 
9288 
9289 
9290 var mouseHandled = false;
9291 $( document ).on( "mouseup", function() {
9292  mouseHandled = false;
9293 } );
9294 
9295 var widgetsMouse = $.widget( "ui.mouse", {
9296  version: "1.12.1",
9297  options: {
9298  cancel: "input, textarea, button, select, option",
9299  distance: 1,
9300  delay: 0
9301  },
9302  _mouseInit: function() {
9303  var that = this;
9304 
9305  this.element
9306  .on( "mousedown." + this.widgetName, function( event ) {
9307  return that._mouseDown( event );
9308  } )
9309  .on( "click." + this.widgetName, function( event ) {
9310  if ( true === $.data( event.target, that.widgetName + ".preventClickEvent" ) ) {
9311  $.removeData( event.target, that.widgetName + ".preventClickEvent" );
9312  event.stopImmediatePropagation();
9313  return false;
9314  }
9315  } );
9316 
9317  this.started = false;
9318  },
9319 
9320  // TODO: make sure destroying one instance of mouse doesn't mess with
9321  // other instances of mouse
9322  _mouseDestroy: function() {
9323  this.element.off( "." + this.widgetName );
9324  if ( this._mouseMoveDelegate ) {
9325  this.document
9326  .off( "mousemove." + this.widgetName, this._mouseMoveDelegate )
9327  .off( "mouseup." + this.widgetName, this._mouseUpDelegate );
9328  }
9329  },
9330 
9331  _mouseDown: function( event ) {
9332 
9333  // don't let more than one widget handle mouseStart
9334  if ( mouseHandled ) {
9335  return;
9336  }
9337 
9338  this._mouseMoved = false;
9339 
9340  // We may have missed mouseup (out of window)
9341  ( this._mouseStarted && this._mouseUp( event ) );
9342 
9343  this._mouseDownEvent = event;
9344 
9345  var that = this,
9346  btnIsLeft = ( event.which === 1 ),
9347 
9348  // event.target.nodeName works around a bug in IE 8 with
9349  // disabled inputs (#7620)
9350  elIsCancel = ( typeof this.options.cancel === "string" && event.target.nodeName ?
9351  $( event.target ).closest( this.options.cancel ).length : false );
9352  if ( !btnIsLeft || elIsCancel || !this._mouseCapture( event ) ) {
9353  return true;
9354  }
9355 
9356  this.mouseDelayMet = !this.options.delay;
9357  if ( !this.mouseDelayMet ) {
9358  this._mouseDelayTimer = setTimeout( function() {
9359  that.mouseDelayMet = true;
9360  }, this.options.delay );
9361  }
9362 
9363  if ( this._mouseDistanceMet( event ) && this._mouseDelayMet( event ) ) {
9364  this._mouseStarted = ( this._mouseStart( event ) !== false );
9365  if ( !this._mouseStarted ) {
9366  event.preventDefault();
9367  return true;
9368  }
9369  }
9370 
9371  // Click event may never have fired (Gecko & Opera)
9372  if ( true === $.data( event.target, this.widgetName + ".preventClickEvent" ) ) {
9373  $.removeData( event.target, this.widgetName + ".preventClickEvent" );
9374  }
9375 
9376  // These delegates are required to keep context
9377  this._mouseMoveDelegate = function( event ) {
9378  return that._mouseMove( event );
9379  };
9380  this._mouseUpDelegate = function( event ) {
9381  return that._mouseUp( event );
9382  };
9383 
9384  this.document
9385  .on( "mousemove." + this.widgetName, this._mouseMoveDelegate )
9386  .on( "mouseup." + this.widgetName, this._mouseUpDelegate );
9387 
9388  event.preventDefault();
9389 
9390  mouseHandled = true;
9391  return true;
9392  },
9393 
9394  _mouseMove: function( event ) {
9395 
9396  // Only check for mouseups outside the document if you've moved inside the document
9397  // at least once. This prevents the firing of mouseup in the case of IE<9, which will
9398  // fire a mousemove event if content is placed under the cursor. See #7778
9399  // Support: IE <9
9400  if ( this._mouseMoved ) {
9401 
9402  // IE mouseup check - mouseup happened when mouse was out of window
9403  if ( $.ui.ie && ( !document.documentMode || document.documentMode < 9 ) &&
9404  !event.button ) {
9405  return this._mouseUp( event );
9406 
9407  // Iframe mouseup check - mouseup occurred in another document
9408  } else if ( !event.which ) {
9409 
9410  // Support: Safari <=8 - 9
9411  // Safari sets which to 0 if you press any of the following keys
9412  // during a drag (#14461)
9413  if ( event.originalEvent.altKey || event.originalEvent.ctrlKey ||
9414  event.originalEvent.metaKey || event.originalEvent.shiftKey ) {
9415  this.ignoreMissingWhich = true;
9416  } else if ( !this.ignoreMissingWhich ) {
9417  return this._mouseUp( event );
9418  }
9419  }
9420  }
9421 
9422  if ( event.which || event.button ) {
9423  this._mouseMoved = true;
9424  }
9425 
9426  if ( this._mouseStarted ) {
9427  this._mouseDrag( event );
9428  return event.preventDefault();
9429  }
9430 
9431  if ( this._mouseDistanceMet( event ) && this._mouseDelayMet( event ) ) {
9432  this._mouseStarted =
9433  ( this._mouseStart( this._mouseDownEvent, event ) !== false );
9434  ( this._mouseStarted ? this._mouseDrag( event ) : this._mouseUp( event ) );
9435  }
9436 
9437  return !this._mouseStarted;
9438  },
9439 
9440  _mouseUp: function( event ) {
9441  this.document
9442  .off( "mousemove." + this.widgetName, this._mouseMoveDelegate )
9443  .off( "mouseup." + this.widgetName, this._mouseUpDelegate );
9444 
9445  if ( this._mouseStarted ) {
9446  this._mouseStarted = false;
9447 
9448  if ( event.target === this._mouseDownEvent.target ) {
9449  $.data( event.target, this.widgetName + ".preventClickEvent", true );
9450  }
9451 
9452  this._mouseStop( event );
9453  }
9454 
9455  if ( this._mouseDelayTimer ) {
9456  clearTimeout( this._mouseDelayTimer );
9457  delete this._mouseDelayTimer;
9458  }
9459 
9460  this.ignoreMissingWhich = false;
9461  mouseHandled = false;
9462  event.preventDefault();
9463  },
9464 
9465  _mouseDistanceMet: function( event ) {
9466  return ( Math.max(
9467  Math.abs( this._mouseDownEvent.pageX - event.pageX ),
9468  Math.abs( this._mouseDownEvent.pageY - event.pageY )
9469  ) >= this.options.distance
9470  );
9471  },
9472 
9473  _mouseDelayMet: function( /* event */ ) {
9474  return this.mouseDelayMet;
9475  },
9476 
9477  // These are placeholder methods, to be overriden by extending plugin
9478  _mouseStart: function( /* event */ ) {},
9479  _mouseDrag: function( /* event */ ) {},
9480  _mouseStop: function( /* event */ ) {},
9481  _mouseCapture: function( /* event */ ) { return true; }
9482 } );
9483 
9484 
9485 
9486 
9487 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
9488 var plugin = $.ui.plugin = {
9489  add: function( module, option, set ) {
9490  var i,
9491  proto = $.ui[ module ].prototype;
9492  for ( i in set ) {
9493  proto.plugins[ i ] = proto.plugins[ i ] || [];
9494  proto.plugins[ i ].push( [ option, set[ i ] ] );
9495  }
9496  },
9497  call: function( instance, name, args, allowDisconnected ) {
9498  var i,
9499  set = instance.plugins[ name ];
9500 
9501  if ( !set ) {
9502  return;
9503  }
9504 
9505  if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode ||
9506  instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
9507  return;
9508  }
9509 
9510  for ( i = 0; i < set.length; i++ ) {
9511  if ( instance.options[ set[ i ][ 0 ] ] ) {
9512  set[ i ][ 1 ].apply( instance.element, args );
9513  }
9514  }
9515  }
9516 };
9517 
9518 
9519 
9520 var safeBlur = $.ui.safeBlur = function( element ) {
9521 
9522  // Support: IE9 - 10 only
9523  // If the <body> is blurred, IE will switch windows, see #9420
9524  if ( element && element.nodeName.toLowerCase() !== "body" ) {
9525  $( element ).trigger( "blur" );
9526  }
9527 };
9528 
9529 
9530 /*!
9531  * jQuery UI Draggable 1.12.1
9532  * http://jqueryui.com
9533  *
9534  * Copyright jQuery Foundation and other contributors
9535  * Released under the MIT license.
9536  * http://jquery.org/license
9537  */
9538 
9539 //>>label: Draggable
9540 //>>group: Interactions
9541 //>>description: Enables dragging functionality for any element.
9542 //>>docs: http://api.jqueryui.com/draggable/
9543 //>>demos: http://jqueryui.com/draggable/
9544 //>>css.structure: ../../themes/base/draggable.css
9545 
9546 
9547 
9548 $.widget( "ui.draggable", $.ui.mouse, {
9549  version: "1.12.1",
9550  widgetEventPrefix: "drag",
9551  options: {
9552  addClasses: true,
9553  appendTo: "parent",
9554  axis: false,
9555  connectToSortable: false,
9556  containment: false,
9557  cursor: "auto",
9558  cursorAt: false,
9559  grid: false,
9560  handle: false,
9561  helper: "original",
9562  iframeFix: false,
9563  opacity: false,
9564  refreshPositions: false,
9565  revert: false,
9566  revertDuration: 500,
9567  scope: "default",
9568  scroll: true,
9569  scrollSensitivity: 20,
9570  scrollSpeed: 20,
9571  snap: false,
9572  snapMode: "both",
9573  snapTolerance: 20,
9574  stack: false,
9575  zIndex: false,
9576 
9577  // Callbacks
9578  drag: null,
9579  start: null,
9580  stop: null
9581  },
9582  _create: function() {
9583 
9584  if ( this.options.helper === "original" ) {
9585  this._setPositionRelative();
9586  }
9587  if ( this.options.addClasses ) {
9588  this._addClass( "ui-draggable" );
9589  }
9590  this._setHandleClassName();
9591 
9592  this._mouseInit();
9593  },
9594 
9595  _setOption: function( key, value ) {
9596  this._super( key, value );
9597  if ( key === "handle" ) {
9598  this._removeHandleClassName();
9599  this._setHandleClassName();
9600  }
9601  },
9602 
9603  _destroy: function() {
9604  if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
9605  this.destroyOnClear = true;
9606  return;
9607  }
9608  this._removeHandleClassName();
9609  this._mouseDestroy();
9610  },
9611 
9612  _mouseCapture: function( event ) {
9613  var o = this.options;
9614 
9615  // Among others, prevent a drag on a resizable-handle
9616  if ( this.helper || o.disabled ||
9617  $( event.target ).closest( ".ui-resizable-handle" ).length > 0 ) {
9618  return false;
9619  }
9620 
9621  //Quit if we're not on a valid handle
9622  this.handle = this._getHandle( event );
9623  if ( !this.handle ) {
9624  return false;
9625  }
9626 
9627  this._blurActiveElement( event );
9628 
9629  this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
9630 
9631  return true;
9632 
9633  },
9634 
9635  _blockFrames: function( selector ) {
9636  this.iframeBlocks = this.document.find( selector ).map( function() {
9637  var iframe = $( this );
9638 
9639  return $( "<div>" )
9640  .css( "position", "absolute" )
9641  .appendTo( iframe.parent() )
9642  .outerWidth( iframe.outerWidth() )
9643  .outerHeight( iframe.outerHeight() )
9644  .offset( iframe.offset() )[ 0 ];
9645  } );
9646  },
9647 
9648  _unblockFrames: function() {
9649  if ( this.iframeBlocks ) {
9650  this.iframeBlocks.remove();
9651  delete this.iframeBlocks;
9652  }
9653  },
9654 
9655  _blurActiveElement: function( event ) {
9656  var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),
9657  target = $( event.target );
9658 
9659  // Don't blur if the event occurred on an element that is within
9660  // the currently focused element
9661  // See #10527, #12472
9662  if ( target.closest( activeElement ).length ) {
9663  return;
9664  }
9665 
9666  // Blur any element that currently has focus, see #4261
9667  $.ui.safeBlur( activeElement );
9668  },
9669 
9670  _mouseStart: function( event ) {
9671 
9672  var o = this.options;
9673 
9674  //Create and append the visible helper
9675  this.helper = this._createHelper( event );
9676 
9677  this._addClass( this.helper, "ui-draggable-dragging" );
9678 
9679  //Cache the helper size
9680  this._cacheHelperProportions();
9681 
9682  //If ddmanager is used for droppables, set the global draggable
9683  if ( $.ui.ddmanager ) {
9684  $.ui.ddmanager.current = this;
9685  }
9686 
9687  /*
9688  * - Position generation -
9689  * This block generates everything position related - it's the core of draggables.
9690  */
9691 
9692  //Cache the margins of the original element
9693  this._cacheMargins();
9694 
9695  //Store the helper's css position
9696  this.cssPosition = this.helper.css( "position" );
9697  this.scrollParent = this.helper.scrollParent( true );
9698  this.offsetParent = this.helper.offsetParent();
9699  this.hasFixedAncestor = this.helper.parents().filter( function() {
9700  return $( this ).css( "position" ) === "fixed";
9701  } ).length > 0;
9702 
9703  //The element's absolute position on the page minus margins
9704  this.positionAbs = this.element.offset();
9705  this._refreshOffsets( event );
9706 
9707  //Generate the original position
9708  this.originalPosition = this.position = this._generatePosition( event, false );
9709  this.originalPageX = event.pageX;
9710  this.originalPageY = event.pageY;
9711 
9712  //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
9713  ( o.cursorAt && this._adjustOffsetFromHelper( o.cursorAt ) );
9714 
9715  //Set a containment if given in the options
9716  this._setContainment();
9717 
9718  //Trigger event + callbacks
9719  if ( this._trigger( "start", event ) === false ) {
9720  this._clear();
9721  return false;
9722  }
9723 
9724  //Recache the helper size
9725  this._cacheHelperProportions();
9726 
9727  //Prepare the droppable offsets
9728  if ( $.ui.ddmanager && !o.dropBehaviour ) {
9729  $.ui.ddmanager.prepareOffsets( this, event );
9730  }
9731 
9732  // Execute the drag once - this causes the helper not to be visible before getting its
9733  // correct position
9734  this._mouseDrag( event, true );
9735 
9736  // If the ddmanager is used for droppables, inform the manager that dragging has started
9737  // (see #5003)
9738  if ( $.ui.ddmanager ) {
9739  $.ui.ddmanager.dragStart( this, event );
9740  }
9741 
9742  return true;
9743  },
9744 
9745  _refreshOffsets: function( event ) {
9746  this.offset = {
9747  top: this.positionAbs.top - this.margins.top,
9748  left: this.positionAbs.left - this.margins.left,
9749  scroll: false,
9750  parent: this._getParentOffset(),
9751  relative: this._getRelativeOffset()
9752  };
9753 
9754  this.offset.click = {
9755  left: event.pageX - this.offset.left,
9756  top: event.pageY - this.offset.top
9757  };
9758  },
9759 
9760  _mouseDrag: function( event, noPropagation ) {
9761 
9762  // reset any necessary cached properties (see #5009)
9763  if ( this.hasFixedAncestor ) {
9764  this.offset.parent = this._getParentOffset();
9765  }
9766 
9767  //Compute the helpers position
9768  this.position = this._generatePosition( event, true );
9769  this.positionAbs = this._convertPositionTo( "absolute" );
9770 
9771  //Call plugins and callbacks and use the resulting position if something is returned
9772  if ( !noPropagation ) {
9773  var ui = this._uiHash();
9774  if ( this._trigger( "drag", event, ui ) === false ) {
9775  this._mouseUp( new $.Event( "mouseup", event ) );
9776  return false;
9777  }
9778  this.position = ui.position;
9779  }
9780 
9781  this.helper[ 0 ].style.left = this.position.left + "px";
9782  this.helper[ 0 ].style.top = this.position.top + "px";
9783 
9784  if ( $.ui.ddmanager ) {
9785  $.ui.ddmanager.drag( this, event );
9786  }
9787 
9788  return false;
9789  },
9790 
9791  _mouseStop: function( event ) {
9792 
9793  //If we are using droppables, inform the manager about the drop
9794  var that = this,
9795  dropped = false;
9796  if ( $.ui.ddmanager && !this.options.dropBehaviour ) {
9797  dropped = $.ui.ddmanager.drop( this, event );
9798  }
9799 
9800  //if a drop comes from outside (a sortable)
9801  if ( this.dropped ) {
9802  dropped = this.dropped;
9803  this.dropped = false;
9804  }
9805 
9806  if ( ( this.options.revert === "invalid" && !dropped ) ||
9807  ( this.options.revert === "valid" && dropped ) ||
9808  this.options.revert === true || ( $.isFunction( this.options.revert ) &&
9809  this.options.revert.call( this.element, dropped ) )
9810  ) {
9811  $( this.helper ).animate(
9812  this.originalPosition,
9813  parseInt( this.options.revertDuration, 10 ),
9814  function() {
9815  if ( that._trigger( "stop", event ) !== false ) {
9816  that._clear();
9817  }
9818  }
9819  );
9820  } else {
9821  if ( this._trigger( "stop", event ) !== false ) {
9822  this._clear();
9823  }
9824  }
9825 
9826  return false;
9827  },
9828 
9829  _mouseUp: function( event ) {
9830  this._unblockFrames();
9831 
9832  // If the ddmanager is used for droppables, inform the manager that dragging has stopped
9833  // (see #5003)
9834  if ( $.ui.ddmanager ) {
9835  $.ui.ddmanager.dragStop( this, event );
9836  }
9837 
9838  // Only need to focus if the event occurred on the draggable itself, see #10527
9839  if ( this.handleElement.is( event.target ) ) {
9840 
9841  // The interaction is over; whether or not the click resulted in a drag,
9842  // focus the element
9843  this.element.trigger( "focus" );
9844  }
9845 
9846  return $.ui.mouse.prototype._mouseUp.call( this, event );
9847  },
9848 
9849  cancel: function() {
9850 
9851  if ( this.helper.is( ".ui-draggable-dragging" ) ) {
9852  this._mouseUp( new $.Event( "mouseup", { target: this.element[ 0 ] } ) );
9853  } else {
9854  this._clear();
9855  }
9856 
9857  return this;
9858 
9859  },
9860 
9861  _getHandle: function( event ) {
9862  return this.options.handle ?
9863  !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
9864  true;
9865  },
9866 
9867  _setHandleClassName: function() {
9868  this.handleElement = this.options.handle ?
9869  this.element.find( this.options.handle ) : this.element;
9870  this._addClass( this.handleElement, "ui-draggable-handle" );
9871  },
9872 
9873  _removeHandleClassName: function() {
9874  this._removeClass( this.handleElement, "ui-draggable-handle" );
9875  },
9876 
9877  _createHelper: function( event ) {
9878 
9879  var o = this.options,
9880  helperIsFunction = $.isFunction( o.helper ),
9881  helper = helperIsFunction ?
9882  $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
9883  ( o.helper === "clone" ?
9884  this.element.clone().removeAttr( "id" ) :
9885  this.element );
9886 
9887  if ( !helper.parents( "body" ).length ) {
9888  helper.appendTo( ( o.appendTo === "parent" ?
9889  this.element[ 0 ].parentNode :
9890  o.appendTo ) );
9891  }
9892 
9893  // Http://bugs.jqueryui.com/ticket/9446
9894  // a helper function can return the original element
9895  // which wouldn't have been set to relative in _create
9896  if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
9897  this._setPositionRelative();
9898  }
9899 
9900  if ( helper[ 0 ] !== this.element[ 0 ] &&
9901  !( /(fixed|absolute)/ ).test( helper.css( "position" ) ) ) {
9902  helper.css( "position", "absolute" );
9903  }
9904 
9905  return helper;
9906 
9907  },
9908 
9909  _setPositionRelative: function() {
9910  if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
9911  this.element[ 0 ].style.position = "relative";
9912  }
9913  },
9914 
9915  _adjustOffsetFromHelper: function( obj ) {
9916  if ( typeof obj === "string" ) {
9917  obj = obj.split( " " );
9918  }
9919  if ( $.isArray( obj ) ) {
9920  obj = { left: +obj[ 0 ], top: +obj[ 1 ] || 0 };
9921  }
9922  if ( "left" in obj ) {
9923  this.offset.click.left = obj.left + this.margins.left;
9924  }
9925  if ( "right" in obj ) {
9926  this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
9927  }
9928  if ( "top" in obj ) {
9929  this.offset.click.top = obj.top + this.margins.top;
9930  }
9931  if ( "bottom" in obj ) {
9932  this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
9933  }
9934  },
9935 
9936  _isRootNode: function( element ) {
9937  return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
9938  },
9939 
9940  _getParentOffset: function() {
9941 
9942  //Get the offsetParent and cache its position
9943  var po = this.offsetParent.offset(),
9944  document = this.document[ 0 ];
9945 
9946  // This is a special case where we need to modify a offset calculated on start, since the
9947  // following happened:
9948  // 1. The position of the helper is absolute, so it's position is calculated based on the
9949  // next positioned parent
9950  // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
9951  // the document, which means that the scroll is included in the initial calculation of the
9952  // offset of the parent, and never recalculated upon drag
9953  if ( this.cssPosition === "absolute" && this.scrollParent[ 0 ] !== document &&
9954  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) {
9955  po.left += this.scrollParent.scrollLeft();
9956  po.top += this.scrollParent.scrollTop();
9957  }
9958 
9959  if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
9960  po = { top: 0, left: 0 };
9961  }
9962 
9963  return {
9964  top: po.top + ( parseInt( this.offsetParent.css( "borderTopWidth" ), 10 ) || 0 ),
9965  left: po.left + ( parseInt( this.offsetParent.css( "borderLeftWidth" ), 10 ) || 0 )
9966  };
9967 
9968  },
9969 
9970  _getRelativeOffset: function() {
9971  if ( this.cssPosition !== "relative" ) {
9972  return { top: 0, left: 0 };
9973  }
9974 
9975  var p = this.element.position(),
9976  scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
9977 
9978  return {
9979  top: p.top - ( parseInt( this.helper.css( "top" ), 10 ) || 0 ) +
9980  ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
9981  left: p.left - ( parseInt( this.helper.css( "left" ), 10 ) || 0 ) +
9982  ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
9983  };
9984 
9985  },
9986 
9987  _cacheMargins: function() {
9988  this.margins = {
9989  left: ( parseInt( this.element.css( "marginLeft" ), 10 ) || 0 ),
9990  top: ( parseInt( this.element.css( "marginTop" ), 10 ) || 0 ),
9991  right: ( parseInt( this.element.css( "marginRight" ), 10 ) || 0 ),
9992  bottom: ( parseInt( this.element.css( "marginBottom" ), 10 ) || 0 )
9993  };
9994  },
9995 
9996  _cacheHelperProportions: function() {
9997  this.helperProportions = {
9998  width: this.helper.outerWidth(),
9999  height: this.helper.outerHeight()
10000  };
10001  },
10002 
10003  _setContainment: function() {
10004 
10005  var isUserScrollable, c, ce,
10006  o = this.options,
10007  document = this.document[ 0 ];
10008 
10009  this.relativeContainer = null;
10010 
10011  if ( !o.containment ) {
10012  this.containment = null;
10013  return;
10014  }
10015 
10016  if ( o.containment === "window" ) {
10017  this.containment = [
10018  $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
10019  $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
10020  $( window ).scrollLeft() + $( window ).width() -
10021  this.helperProportions.width - this.margins.left,
10022  $( window ).scrollTop() +
10023  ( $( window ).height() || document.body.parentNode.scrollHeight ) -
10024  this.helperProportions.height - this.margins.top
10025  ];
10026  return;
10027  }
10028 
10029  if ( o.containment === "document" ) {
10030  this.containment = [
10031  0,
10032  0,
10033  $( document ).width() - this.helperProportions.width - this.margins.left,
10034  ( $( document ).height() || document.body.parentNode.scrollHeight ) -
10035  this.helperProportions.height - this.margins.top
10036  ];
10037  return;
10038  }
10039 
10040  if ( o.containment.constructor === Array ) {
10041  this.containment = o.containment;
10042  return;
10043  }
10044 
10045  if ( o.containment === "parent" ) {
10046  o.containment = this.helper[ 0 ].parentNode;
10047  }
10048 
10049  c = $( o.containment );
10050  ce = c[ 0 ];
10051 
10052  if ( !ce ) {
10053  return;
10054  }
10055 
10056  isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
10057 
10058  this.containment = [
10059  ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) +
10060  ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
10061  ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) +
10062  ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
10063  ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
10064  ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
10065  ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
10066  this.helperProportions.width -
10067  this.margins.left -
10068  this.margins.right,
10069  ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
10070  ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
10071  ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
10072  this.helperProportions.height -
10073  this.margins.top -
10074  this.margins.bottom
10075  ];
10076  this.relativeContainer = c;
10077  },
10078 
10079  _convertPositionTo: function( d, pos ) {
10080 
10081  if ( !pos ) {
10082  pos = this.position;
10083  }
10084 
10085  var mod = d === "absolute" ? 1 : -1,
10086  scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
10087 
10088  return {
10089  top: (
10090 
10091  // The absolute mouse position
10092  pos.top +
10093 
10094  // Only for relative positioned nodes: Relative offset from element to offset parent
10095  this.offset.relative.top * mod +
10096 
10097  // The offsetParent's offset without borders (offset + border)
10098  this.offset.parent.top * mod -
10099  ( ( this.cssPosition === "fixed" ?
10100  -this.offset.scroll.top :
10101  ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod )
10102  ),
10103  left: (
10104 
10105  // The absolute mouse position
10106  pos.left +
10107 
10108  // Only for relative positioned nodes: Relative offset from element to offset parent
10109  this.offset.relative.left * mod +
10110 
10111  // The offsetParent's offset without borders (offset + border)
10112  this.offset.parent.left * mod -
10113  ( ( this.cssPosition === "fixed" ?
10114  -this.offset.scroll.left :
10115  ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod )
10116  )
10117  };
10118 
10119  },
10120 
10121  _generatePosition: function( event, constrainPosition ) {
10122 
10123  var containment, co, top, left,
10124  o = this.options,
10125  scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
10126  pageX = event.pageX,
10127  pageY = event.pageY;
10128 
10129  // Cache the scroll
10130  if ( !scrollIsRootNode || !this.offset.scroll ) {
10131  this.offset.scroll = {
10132  top: this.scrollParent.scrollTop(),
10133  left: this.scrollParent.scrollLeft()
10134  };
10135  }
10136 
10137  /*
10138  * - Position constraining -
10139  * Constrain the position to a mix of grid, containment.
10140  */
10141 
10142  // If we are not dragging yet, we won't check for options
10143  if ( constrainPosition ) {
10144  if ( this.containment ) {
10145  if ( this.relativeContainer ) {
10146  co = this.relativeContainer.offset();
10147  containment = [
10148  this.containment[ 0 ] + co.left,
10149  this.containment[ 1 ] + co.top,
10150  this.containment[ 2 ] + co.left,
10151  this.containment[ 3 ] + co.top
10152  ];
10153  } else {
10154  containment = this.containment;
10155  }
10156 
10157  if ( event.pageX - this.offset.click.left < containment[ 0 ] ) {
10158  pageX = containment[ 0 ] + this.offset.click.left;
10159  }
10160  if ( event.pageY - this.offset.click.top < containment[ 1 ] ) {
10161  pageY = containment[ 1 ] + this.offset.click.top;
10162  }
10163  if ( event.pageX - this.offset.click.left > containment[ 2 ] ) {
10164  pageX = containment[ 2 ] + this.offset.click.left;
10165  }
10166  if ( event.pageY - this.offset.click.top > containment[ 3 ] ) {
10167  pageY = containment[ 3 ] + this.offset.click.top;
10168  }
10169  }
10170 
10171  if ( o.grid ) {
10172 
10173  //Check for grid elements set to 0 to prevent divide by 0 error causing invalid
10174  // argument errors in IE (see ticket #6950)
10175  top = o.grid[ 1 ] ? this.originalPageY + Math.round( ( pageY -
10176  this.originalPageY ) / o.grid[ 1 ] ) * o.grid[ 1 ] : this.originalPageY;
10177  pageY = containment ? ( ( top - this.offset.click.top >= containment[ 1 ] ||
10178  top - this.offset.click.top > containment[ 3 ] ) ?
10179  top :
10180  ( ( top - this.offset.click.top >= containment[ 1 ] ) ?
10181  top - o.grid[ 1 ] : top + o.grid[ 1 ] ) ) : top;
10182 
10183  left = o.grid[ 0 ] ? this.originalPageX +
10184  Math.round( ( pageX - this.originalPageX ) / o.grid[ 0 ] ) * o.grid[ 0 ] :
10185  this.originalPageX;
10186  pageX = containment ? ( ( left - this.offset.click.left >= containment[ 0 ] ||
10187  left - this.offset.click.left > containment[ 2 ] ) ?
10188  left :
10189  ( ( left - this.offset.click.left >= containment[ 0 ] ) ?
10190  left - o.grid[ 0 ] : left + o.grid[ 0 ] ) ) : left;
10191  }
10192 
10193  if ( o.axis === "y" ) {
10194  pageX = this.originalPageX;
10195  }
10196 
10197  if ( o.axis === "x" ) {
10198  pageY = this.originalPageY;
10199  }
10200  }
10201 
10202  return {
10203  top: (
10204 
10205  // The absolute mouse position
10206  pageY -
10207 
10208  // Click offset (relative to the element)
10209  this.offset.click.top -
10210 
10211  // Only for relative positioned nodes: Relative offset from element to offset parent
10212  this.offset.relative.top -
10213 
10214  // The offsetParent's offset without borders (offset + border)
10215  this.offset.parent.top +
10216  ( this.cssPosition === "fixed" ?
10217  -this.offset.scroll.top :
10218  ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
10219  ),
10220  left: (
10221 
10222  // The absolute mouse position
10223  pageX -
10224 
10225  // Click offset (relative to the element)
10226  this.offset.click.left -
10227 
10228  // Only for relative positioned nodes: Relative offset from element to offset parent
10229  this.offset.relative.left -
10230 
10231  // The offsetParent's offset without borders (offset + border)
10232  this.offset.parent.left +
10233  ( this.cssPosition === "fixed" ?
10234  -this.offset.scroll.left :
10235  ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
10236  )
10237  };
10238 
10239  },
10240 
10241  _clear: function() {
10242  this._removeClass( this.helper, "ui-draggable-dragging" );
10243  if ( this.helper[ 0 ] !== this.element[ 0 ] && !this.cancelHelperRemoval ) {
10244  this.helper.remove();
10245  }
10246  this.helper = null;
10247  this.cancelHelperRemoval = false;
10248  if ( this.destroyOnClear ) {
10249  this.destroy();
10250  }
10251  },
10252 
10253  // From now on bulk stuff - mainly helpers
10254 
10255  _trigger: function( type, event, ui ) {
10256  ui = ui || this._uiHash();
10257  $.ui.plugin.call( this, type, [ event, ui, this ], true );
10258 
10259  // Absolute position and offset (see #6884 ) have to be recalculated after plugins
10260  if ( /^(drag|start|stop)/.test( type ) ) {
10261  this.positionAbs = this._convertPositionTo( "absolute" );
10262  ui.offset = this.positionAbs;
10263  }
10264  return $.Widget.prototype._trigger.call( this, type, event, ui );
10265  },
10266 
10267  plugins: {},
10268 
10269  _uiHash: function() {
10270  return {
10271  helper: this.helper,
10272  position: this.position,
10273  originalPosition: this.originalPosition,
10274  offset: this.positionAbs
10275  };
10276  }
10277 
10278 } );
10279 
10280 $.ui.plugin.add( "draggable", "connectToSortable", {
10281  start: function( event, ui, draggable ) {
10282  var uiSortable = $.extend( {}, ui, {
10283  item: draggable.element
10284  } );
10285 
10286  draggable.sortables = [];
10287  $( draggable.options.connectToSortable ).each( function() {
10288  var sortable = $( this ).sortable( "instance" );
10289 
10290  if ( sortable && !sortable.options.disabled ) {
10291  draggable.sortables.push( sortable );
10292 
10293  // RefreshPositions is called at drag start to refresh the containerCache
10294  // which is used in drag. This ensures it's initialized and synchronized
10295  // with any changes that might have happened on the page since initialization.
10296  sortable.refreshPositions();
10297  sortable._trigger( "activate", event, uiSortable );
10298  }
10299  } );
10300  },
10301  stop: function( event, ui, draggable ) {
10302  var uiSortable = $.extend( {}, ui, {
10303  item: draggable.element
10304  } );
10305 
10306  draggable.cancelHelperRemoval = false;
10307 
10308  $.each( draggable.sortables, function() {
10309  var sortable = this;
10310 
10311  if ( sortable.isOver ) {
10312  sortable.isOver = 0;
10313 
10314  // Allow this sortable to handle removing the helper
10315  draggable.cancelHelperRemoval = true;
10316  sortable.cancelHelperRemoval = false;
10317 
10318  // Use _storedCSS To restore properties in the sortable,
10319  // as this also handles revert (#9675) since the draggable
10320  // may have modified them in unexpected ways (#8809)
10321  sortable._storedCSS = {
10322  position: sortable.placeholder.css( "position" ),
10323  top: sortable.placeholder.css( "top" ),
10324  left: sortable.placeholder.css( "left" )
10325  };
10326 
10327  sortable._mouseStop( event );
10328 
10329  // Once drag has ended, the sortable should return to using
10330  // its original helper, not the shared helper from draggable
10331  sortable.options.helper = sortable.options._helper;
10332  } else {
10333 
10334  // Prevent this Sortable from removing the helper.
10335  // However, don't set the draggable to remove the helper
10336  // either as another connected Sortable may yet handle the removal.
10337  sortable.cancelHelperRemoval = true;
10338 
10339  sortable._trigger( "deactivate", event, uiSortable );
10340  }
10341  } );
10342  },
10343  drag: function( event, ui, draggable ) {
10344  $.each( draggable.sortables, function() {
10345  var innermostIntersecting = false,
10346  sortable = this;
10347 
10348  // Copy over variables that sortable's _intersectsWith uses
10349  sortable.positionAbs = draggable.positionAbs;
10350  sortable.helperProportions = draggable.helperProportions;
10351  sortable.offset.click = draggable.offset.click;
10352 
10353  if ( sortable._intersectsWith( sortable.containerCache ) ) {
10354  innermostIntersecting = true;
10355 
10356  $.each( draggable.sortables, function() {
10357 
10358  // Copy over variables that sortable's _intersectsWith uses
10359  this.positionAbs = draggable.positionAbs;
10360  this.helperProportions = draggable.helperProportions;
10361  this.offset.click = draggable.offset.click;
10362 
10363  if ( this !== sortable &&
10364  this._intersectsWith( this.containerCache ) &&
10365  $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
10366  innermostIntersecting = false;
10367  }
10368 
10369  return innermostIntersecting;
10370  } );
10371  }
10372 
10373  if ( innermostIntersecting ) {
10374 
10375  // If it intersects, we use a little isOver variable and set it once,
10376  // so that the move-in stuff gets fired only once.
10377  if ( !sortable.isOver ) {
10378  sortable.isOver = 1;
10379 
10380  // Store draggable's parent in case we need to reappend to it later.
10381  draggable._parent = ui.helper.parent();
10382 
10383  sortable.currentItem = ui.helper
10384  .appendTo( sortable.element )
10385  .data( "ui-sortable-item", true );
10386 
10387  // Store helper option to later restore it
10388  sortable.options._helper = sortable.options.helper;
10389 
10390  sortable.options.helper = function() {
10391  return ui.helper[ 0 ];
10392  };
10393 
10394  // Fire the start events of the sortable with our passed browser event,
10395  // and our own helper (so it doesn't create a new one)
10396  event.target = sortable.currentItem[ 0 ];
10397  sortable._mouseCapture( event, true );
10398  sortable._mouseStart( event, true, true );
10399 
10400  // Because the browser event is way off the new appended portlet,
10401  // modify necessary variables to reflect the changes
10402  sortable.offset.click.top = draggable.offset.click.top;
10403  sortable.offset.click.left = draggable.offset.click.left;
10404  sortable.offset.parent.left -= draggable.offset.parent.left -
10405  sortable.offset.parent.left;
10406  sortable.offset.parent.top -= draggable.offset.parent.top -
10407  sortable.offset.parent.top;
10408 
10409  draggable._trigger( "toSortable", event );
10410 
10411  // Inform draggable that the helper is in a valid drop zone,
10412  // used solely in the revert option to handle "valid/invalid".
10413  draggable.dropped = sortable.element;
10414 
10415  // Need to refreshPositions of all sortables in the case that
10416  // adding to one sortable changes the location of the other sortables (#9675)
10417  $.each( draggable.sortables, function() {
10418  this.refreshPositions();
10419  } );
10420 
10421  // Hack so receive/update callbacks work (mostly)
10422  draggable.currentItem = draggable.element;
10423  sortable.fromOutside = draggable;
10424  }
10425 
10426  if ( sortable.currentItem ) {
10427  sortable._mouseDrag( event );
10428 
10429  // Copy the sortable's position because the draggable's can potentially reflect
10430  // a relative position, while sortable is always absolute, which the dragged
10431  // element has now become. (#8809)
10432  ui.position = sortable.position;
10433  }
10434  } else {
10435 
10436  // If it doesn't intersect with the sortable, and it intersected before,
10437  // we fake the drag stop of the sortable, but make sure it doesn't remove
10438  // the helper by using cancelHelperRemoval.
10439  if ( sortable.isOver ) {
10440 
10441  sortable.isOver = 0;
10442  sortable.cancelHelperRemoval = true;
10443 
10444  // Calling sortable's mouseStop would trigger a revert,
10445  // so revert must be temporarily false until after mouseStop is called.
10446  sortable.options._revert = sortable.options.revert;
10447  sortable.options.revert = false;
10448 
10449  sortable._trigger( "out", event, sortable._uiHash( sortable ) );
10450  sortable._mouseStop( event, true );
10451 
10452  // Restore sortable behaviors that were modfied
10453  // when the draggable entered the sortable area (#9481)
10454  sortable.options.revert = sortable.options._revert;
10455  sortable.options.helper = sortable.options._helper;
10456 
10457  if ( sortable.placeholder ) {
10458  sortable.placeholder.remove();
10459  }
10460 
10461  // Restore and recalculate the draggable's offset considering the sortable
10462  // may have modified them in unexpected ways. (#8809, #10669)
10463  ui.helper.appendTo( draggable._parent );
10464  draggable._refreshOffsets( event );
10465  ui.position = draggable._generatePosition( event, true );
10466 
10467  draggable._trigger( "fromSortable", event );
10468 
10469  // Inform draggable that the helper is no longer in a valid drop zone
10470  draggable.dropped = false;
10471 
10472  // Need to refreshPositions of all sortables just in case removing
10473  // from one sortable changes the location of other sortables (#9675)
10474  $.each( draggable.sortables, function() {
10475  this.refreshPositions();
10476  } );
10477  }
10478  }
10479  } );
10480  }
10481 } );
10482 
10483 $.ui.plugin.add( "draggable", "cursor", {
10484  start: function( event, ui, instance ) {
10485  var t = $( "body" ),
10486  o = instance.options;
10487 
10488  if ( t.css( "cursor" ) ) {
10489  o._cursor = t.css( "cursor" );
10490  }
10491  t.css( "cursor", o.cursor );
10492  },
10493  stop: function( event, ui, instance ) {
10494  var o = instance.options;
10495  if ( o._cursor ) {
10496  $( "body" ).css( "cursor", o._cursor );
10497  }
10498  }
10499 } );
10500 
10501 $.ui.plugin.add( "draggable", "opacity", {
10502  start: function( event, ui, instance ) {
10503  var t = $( ui.helper ),
10504  o = instance.options;
10505  if ( t.css( "opacity" ) ) {
10506  o._opacity = t.css( "opacity" );
10507  }
10508  t.css( "opacity", o.opacity );
10509  },
10510  stop: function( event, ui, instance ) {
10511  var o = instance.options;
10512  if ( o._opacity ) {
10513  $( ui.helper ).css( "opacity", o._opacity );
10514  }
10515  }
10516 } );
10517 
10518 $.ui.plugin.add( "draggable", "scroll", {
10519  start: function( event, ui, i ) {
10520  if ( !i.scrollParentNotHidden ) {
10521  i.scrollParentNotHidden = i.helper.scrollParent( false );
10522  }
10523 
10524  if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] &&
10525  i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
10526  i.overflowOffset = i.scrollParentNotHidden.offset();
10527  }
10528  },
10529  drag: function( event, ui, i ) {
10530 
10531  var o = i.options,
10532  scrolled = false,
10533  scrollParent = i.scrollParentNotHidden[ 0 ],
10534  document = i.document[ 0 ];
10535 
10536  if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
10537  if ( !o.axis || o.axis !== "x" ) {
10538  if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY <
10539  o.scrollSensitivity ) {
10540  scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
10541  } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
10542  scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
10543  }
10544  }
10545 
10546  if ( !o.axis || o.axis !== "y" ) {
10547  if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX <
10548  o.scrollSensitivity ) {
10549  scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
10550  } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
10551  scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
10552  }
10553  }
10554 
10555  } else {
10556 
10557  if ( !o.axis || o.axis !== "x" ) {
10558  if ( event.pageY - $( document ).scrollTop() < o.scrollSensitivity ) {
10559  scrolled = $( document ).scrollTop( $( document ).scrollTop() - o.scrollSpeed );
10560  } else if ( $( window ).height() - ( event.pageY - $( document ).scrollTop() ) <
10561  o.scrollSensitivity ) {
10562  scrolled = $( document ).scrollTop( $( document ).scrollTop() + o.scrollSpeed );
10563  }
10564  }
10565 
10566  if ( !o.axis || o.axis !== "y" ) {
10567  if ( event.pageX - $( document ).scrollLeft() < o.scrollSensitivity ) {
10568  scrolled = $( document ).scrollLeft(
10569  $( document ).scrollLeft() - o.scrollSpeed
10570  );
10571  } else if ( $( window ).width() - ( event.pageX - $( document ).scrollLeft() ) <
10572  o.scrollSensitivity ) {
10573  scrolled = $( document ).scrollLeft(
10574  $( document ).scrollLeft() + o.scrollSpeed
10575  );
10576  }
10577  }
10578 
10579  }
10580 
10581  if ( scrolled !== false && $.ui.ddmanager && !o.dropBehaviour ) {
10582  $.ui.ddmanager.prepareOffsets( i, event );
10583  }
10584 
10585  }
10586 } );
10587 
10588 $.ui.plugin.add( "draggable", "snap", {
10589  start: function( event, ui, i ) {
10590 
10591  var o = i.options;
10592 
10593  i.snapElements = [];
10594 
10595  $( o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap )
10596  .each( function() {
10597  var $t = $( this ),
10598  $o = $t.offset();
10599  if ( this !== i.element[ 0 ] ) {
10600  i.snapElements.push( {
10601  item: this,
10602  width: $t.outerWidth(), height: $t.outerHeight(),
10603  top: $o.top, left: $o.left
10604  } );
10605  }
10606  } );
10607 
10608  },
10609  drag: function( event, ui, inst ) {
10610 
10611  var ts, bs, ls, rs, l, r, t, b, i, first,
10612  o = inst.options,
10613  d = o.snapTolerance,
10614  x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
10615  y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
10616 
10617  for ( i = inst.snapElements.length - 1; i >= 0; i-- ) {
10618 
10619  l = inst.snapElements[ i ].left - inst.margins.left;
10620  r = l + inst.snapElements[ i ].width;
10621  t = inst.snapElements[ i ].top - inst.margins.top;
10622  b = t + inst.snapElements[ i ].height;
10623 
10624  if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d ||
10625  !$.contains( inst.snapElements[ i ].item.ownerDocument,
10626  inst.snapElements[ i ].item ) ) {
10627  if ( inst.snapElements[ i ].snapping ) {
10628  ( inst.options.snap.release &&
10629  inst.options.snap.release.call(
10630  inst.element,
10631  event,
10632  $.extend( inst._uiHash(), { snapItem: inst.snapElements[ i ].item } )
10633  ) );
10634  }
10635  inst.snapElements[ i ].snapping = false;
10636  continue;
10637  }
10638 
10639  if ( o.snapMode !== "inner" ) {
10640  ts = Math.abs( t - y2 ) <= d;
10641  bs = Math.abs( b - y1 ) <= d;
10642  ls = Math.abs( l - x2 ) <= d;
10643  rs = Math.abs( r - x1 ) <= d;
10644  if ( ts ) {
10645  ui.position.top = inst._convertPositionTo( "relative", {
10646  top: t - inst.helperProportions.height,
10647  left: 0
10648  } ).top;
10649  }
10650  if ( bs ) {
10651  ui.position.top = inst._convertPositionTo( "relative", {
10652  top: b,
10653  left: 0
10654  } ).top;
10655  }
10656  if ( ls ) {
10657  ui.position.left = inst._convertPositionTo( "relative", {
10658  top: 0,
10659  left: l - inst.helperProportions.width
10660  } ).left;
10661  }
10662  if ( rs ) {
10663  ui.position.left = inst._convertPositionTo( "relative", {
10664  top: 0,
10665  left: r
10666  } ).left;
10667  }
10668  }
10669 
10670  first = ( ts || bs || ls || rs );
10671 
10672  if ( o.snapMode !== "outer" ) {
10673  ts = Math.abs( t - y1 ) <= d;
10674  bs = Math.abs( b - y2 ) <= d;
10675  ls = Math.abs( l - x1 ) <= d;
10676  rs = Math.abs( r - x2 ) <= d;
10677  if ( ts ) {
10678  ui.position.top = inst._convertPositionTo( "relative", {
10679  top: t,
10680  left: 0
10681  } ).top;
10682  }
10683  if ( bs ) {
10684  ui.position.top = inst._convertPositionTo( "relative", {
10685  top: b - inst.helperProportions.height,
10686  left: 0
10687  } ).top;
10688  }
10689  if ( ls ) {
10690  ui.position.left = inst._convertPositionTo( "relative", {
10691  top: 0,
10692  left: l
10693  } ).left;
10694  }
10695  if ( rs ) {
10696  ui.position.left = inst._convertPositionTo( "relative", {
10697  top: 0,
10698  left: r - inst.helperProportions.width
10699  } ).left;
10700  }
10701  }
10702 
10703  if ( !inst.snapElements[ i ].snapping && ( ts || bs || ls || rs || first ) ) {
10704  ( inst.options.snap.snap &&
10705  inst.options.snap.snap.call(
10706  inst.element,
10707  event,
10708  $.extend( inst._uiHash(), {
10709  snapItem: inst.snapElements[ i ].item
10710  } ) ) );
10711  }
10712  inst.snapElements[ i ].snapping = ( ts || bs || ls || rs || first );
10713 
10714  }
10715 
10716  }
10717 } );
10718 
10719 $.ui.plugin.add( "draggable", "stack", {
10720  start: function( event, ui, instance ) {
10721  var min,
10722  o = instance.options,
10723  group = $.makeArray( $( o.stack ) ).sort( function( a, b ) {
10724  return ( parseInt( $( a ).css( "zIndex" ), 10 ) || 0 ) -
10725  ( parseInt( $( b ).css( "zIndex" ), 10 ) || 0 );
10726  } );
10727 
10728  if ( !group.length ) { return; }
10729 
10730  min = parseInt( $( group[ 0 ] ).css( "zIndex" ), 10 ) || 0;
10731  $( group ).each( function( i ) {
10732  $( this ).css( "zIndex", min + i );
10733  } );
10734  this.css( "zIndex", ( min + group.length ) );
10735  }
10736 } );
10737 
10738 $.ui.plugin.add( "draggable", "zIndex", {
10739  start: function( event, ui, instance ) {
10740  var t = $( ui.helper ),
10741  o = instance.options;
10742 
10743  if ( t.css( "zIndex" ) ) {
10744  o._zIndex = t.css( "zIndex" );
10745  }
10746  t.css( "zIndex", o.zIndex );
10747  },
10748  stop: function( event, ui, instance ) {
10749  var o = instance.options;
10750 
10751  if ( o._zIndex ) {
10752  $( ui.helper ).css( "zIndex", o._zIndex );
10753  }
10754  }
10755 } );
10756 
10757 var widgetsDraggable = $.ui.draggable;
10758 
10759 
10760 /*!
10761  * jQuery UI Resizable 1.12.1
10762  * http://jqueryui.com
10763  *
10764  * Copyright jQuery Foundation and other contributors
10765  * Released under the MIT license.
10766  * http://jquery.org/license
10767  */
10768 
10769 //>>label: Resizable
10770 //>>group: Interactions
10771 //>>description: Enables resize functionality for any element.
10772 //>>docs: http://api.jqueryui.com/resizable/
10773 //>>demos: http://jqueryui.com/resizable/
10774 //>>css.structure: ../../themes/base/core.css
10775 //>>css.structure: ../../themes/base/resizable.css
10776 //>>css.theme: ../../themes/base/theme.css
10777 
10778 
10779 
10780 $.widget( "ui.resizable", $.ui.mouse, {
10781  version: "1.12.1",
10782  widgetEventPrefix: "resize",
10783  options: {
10784  alsoResize: false,
10785  animate: false,
10786  animateDuration: "slow",
10787  animateEasing: "swing",
10788  aspectRatio: false,
10789  autoHide: false,
10790  classes: {
10791  "ui-resizable-se": "ui-icon ui-icon-gripsmall-diagonal-se"
10792  },
10793  containment: false,
10794  ghost: false,
10795  grid: false,
10796  handles: "e,s,se",
10797  helper: false,
10798  maxHeight: null,
10799  maxWidth: null,
10800  minHeight: 10,
10801  minWidth: 10,
10802 
10803  // See #7960
10804  zIndex: 90,
10805 
10806  // Callbacks
10807  resize: null,
10808  start: null,
10809  stop: null
10810  },
10811 
10812  _num: function( value ) {
10813  return parseFloat( value ) || 0;
10814  },
10815 
10816  _isNumber: function( value ) {
10817  return !isNaN( parseFloat( value ) );
10818  },
10819 
10820  _hasScroll: function( el, a ) {
10821 
10822  if ( $( el ).css( "overflow" ) === "hidden" ) {
10823  return false;
10824  }
10825 
10826  var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
10827  has = false;
10828 
10829  if ( el[ scroll ] > 0 ) {
10830  return true;
10831  }
10832 
10833  // TODO: determine which cases actually cause this to happen
10834  // if the element doesn't have the scroll set, see if it's possible to
10835  // set the scroll
10836  el[ scroll ] = 1;
10837  has = ( el[ scroll ] > 0 );
10838  el[ scroll ] = 0;
10839  return has;
10840  },
10841 
10842  _create: function() {
10843 
10844  var margins,
10845  o = this.options,
10846  that = this;
10847  this._addClass( "ui-resizable" );
10848 
10849  $.extend( this, {
10850  _aspectRatio: !!( o.aspectRatio ),
10851  aspectRatio: o.aspectRatio,
10852  originalElement: this.element,
10853  _proportionallyResizeElements: [],
10854  _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
10855  } );
10856 
10857  // Wrap the element if it cannot hold child nodes
10858  if ( this.element[ 0 ].nodeName.match( /^(canvas|textarea|input|select|button|img)$/i ) ) {
10859 
10860  this.element.wrap(
10861  $( "<div class='ui-wrapper' style='overflow: hidden;'></div>" ).css( {
10862  position: this.element.css( "position" ),
10863  width: this.element.outerWidth(),
10864  height: this.element.outerHeight(),
10865  top: this.element.css( "top" ),
10866  left: this.element.css( "left" )
10867  } )
10868  );
10869 
10870  this.element = this.element.parent().data(
10871  "ui-resizable", this.element.resizable( "instance" )
10872  );
10873 
10874  this.elementIsWrapper = true;
10875 
10876  margins = {
10877  marginTop: this.originalElement.css( "marginTop" ),
10878  marginRight: this.originalElement.css( "marginRight" ),
10879  marginBottom: this.originalElement.css( "marginBottom" ),
10880  marginLeft: this.originalElement.css( "marginLeft" )
10881  };
10882 
10883  this.element.css( margins );
10884  this.originalElement.css( "margin", 0 );
10885 
10886  // support: Safari
10887  // Prevent Safari textarea resize
10888  this.originalResizeStyle = this.originalElement.css( "resize" );
10889  this.originalElement.css( "resize", "none" );
10890 
10891  this._proportionallyResizeElements.push( this.originalElement.css( {
10892  position: "static",
10893  zoom: 1,
10894  display: "block"
10895  } ) );
10896 
10897  // Support: IE9
10898  // avoid IE jump (hard set the margin)
10899  this.originalElement.css( margins );
10900 
10901  this._proportionallyResize();
10902  }
10903 
10904  this._setupHandles();
10905 
10906  if ( o.autoHide ) {
10907  $( this.element )
10908  .on( "mouseenter", function() {
10909  if ( o.disabled ) {
10910  return;
10911  }
10912  that._removeClass( "ui-resizable-autohide" );
10913  that._handles.show();
10914  } )
10915  .on( "mouseleave", function() {
10916  if ( o.disabled ) {
10917  return;
10918  }
10919  if ( !that.resizing ) {
10920  that._addClass( "ui-resizable-autohide" );
10921  that._handles.hide();
10922  }
10923  } );
10924  }
10925 
10926  this._mouseInit();
10927  },
10928 
10929  _destroy: function() {
10930 
10931  this._mouseDestroy();
10932 
10933  var wrapper,
10934  _destroy = function( exp ) {
10935  $( exp )
10936  .removeData( "resizable" )
10937  .removeData( "ui-resizable" )
10938  .off( ".resizable" )
10939  .find( ".ui-resizable-handle" )
10940  .remove();
10941  };
10942 
10943  // TODO: Unwrap at same DOM position
10944  if ( this.elementIsWrapper ) {
10945  _destroy( this.element );
10946  wrapper = this.element;
10947  this.originalElement.css( {
10948  position: wrapper.css( "position" ),
10949  width: wrapper.outerWidth(),
10950  height: wrapper.outerHeight(),
10951  top: wrapper.css( "top" ),
10952  left: wrapper.css( "left" )
10953  } ).insertAfter( wrapper );
10954  wrapper.remove();
10955  }
10956 
10957  this.originalElement.css( "resize", this.originalResizeStyle );
10958  _destroy( this.originalElement );
10959 
10960  return this;
10961  },
10962 
10963  _setOption: function( key, value ) {
10964  this._super( key, value );
10965 
10966  switch ( key ) {
10967  case "handles":
10968  this._removeHandles();
10969  this._setupHandles();
10970  break;
10971  default:
10972  break;
10973  }
10974  },
10975 
10976  _setupHandles: function() {
10977  var o = this.options, handle, i, n, hname, axis, that = this;
10978  this.handles = o.handles ||
10979  ( !$( ".ui-resizable-handle", this.element ).length ?
10980  "e,s,se" : {
10981  n: ".ui-resizable-n",
10982  e: ".ui-resizable-e",
10983  s: ".ui-resizable-s",
10984  w: ".ui-resizable-w",
10985  se: ".ui-resizable-se",
10986  sw: ".ui-resizable-sw",
10987  ne: ".ui-resizable-ne",
10988  nw: ".ui-resizable-nw"
10989  } );
10990 
10991  this._handles = $();
10992  if ( this.handles.constructor === String ) {
10993 
10994  if ( this.handles === "all" ) {
10995  this.handles = "n,e,s,w,se,sw,ne,nw";
10996  }
10997 
10998  n = this.handles.split( "," );
10999  this.handles = {};
11000 
11001  for ( i = 0; i < n.length; i++ ) {
11002 
11003  handle = $.trim( n[ i ] );
11004  hname = "ui-resizable-" + handle;
11005  axis = $( "<div>" );
11006  this._addClass( axis, "ui-resizable-handle " + hname );
11007 
11008  axis.css( { zIndex: o.zIndex } );
11009 
11010  this.handles[ handle ] = ".ui-resizable-" + handle;
11011  this.element.append( axis );
11012  }
11013 
11014  }
11015 
11016  this._renderAxis = function( target ) {
11017 
11018  var i, axis, padPos, padWrapper;
11019 
11020  target = target || this.element;
11021 
11022  for ( i in this.handles ) {
11023 
11024  if ( this.handles[ i ].constructor === String ) {
11025  this.handles[ i ] = this.element.children( this.handles[ i ] ).first().show();
11026  } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
11027  this.handles[ i ] = $( this.handles[ i ] );
11028  this._on( this.handles[ i ], { "mousedown": that._mouseDown } );
11029  }
11030 
11031  if ( this.elementIsWrapper &&
11032  this.originalElement[ 0 ]
11033  .nodeName
11034  .match( /^(textarea|input|select|button)$/i ) ) {
11035  axis = $( this.handles[ i ], this.element );
11036 
11037  padWrapper = /sw|ne|nw|se|n|s/.test( i ) ?
11038  axis.outerHeight() :
11039  axis.outerWidth();
11040 
11041  padPos = [ "padding",
11042  /ne|nw|n/.test( i ) ? "Top" :
11043  /se|sw|s/.test( i ) ? "Bottom" :
11044  /^e$/.test( i ) ? "Right" : "Left" ].join( "" );
11045 
11046  target.css( padPos, padWrapper );
11047 
11048  this._proportionallyResize();
11049  }
11050 
11051  this._handles = this._handles.add( this.handles[ i ] );
11052  }
11053  };
11054 
11055  // TODO: make renderAxis a prototype function
11056  this._renderAxis( this.element );
11057 
11058  this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
11059  this._handles.disableSelection();
11060 
11061  this._handles.on( "mouseover", function() {
11062  if ( !that.resizing ) {
11063  if ( this.className ) {
11064  axis = this.className.match( /ui-resizable-(se|sw|ne|nw|n|e|s|w)/i );
11065  }
11066  that.axis = axis && axis[ 1 ] ? axis[ 1 ] : "se";
11067  }
11068  } );
11069 
11070  if ( o.autoHide ) {
11071  this._handles.hide();
11072  this._addClass( "ui-resizable-autohide" );
11073  }
11074  },
11075 
11076  _removeHandles: function() {
11077  this._handles.remove();
11078  },
11079 
11080  _mouseCapture: function( event ) {
11081  var i, handle,
11082  capture = false;
11083 
11084  for ( i in this.handles ) {
11085  handle = $( this.handles[ i ] )[ 0 ];
11086  if ( handle === event.target || $.contains( handle, event.target ) ) {
11087  capture = true;
11088  }
11089  }
11090 
11091  return !this.options.disabled && capture;
11092  },
11093 
11094  _mouseStart: function( event ) {
11095 
11096  var curleft, curtop, cursor,
11097  o = this.options,
11098  el = this.element;
11099 
11100  this.resizing = true;
11101 
11102  this._renderProxy();
11103 
11104  curleft = this._num( this.helper.css( "left" ) );
11105  curtop = this._num( this.helper.css( "top" ) );
11106 
11107  if ( o.containment ) {
11108  curleft += $( o.containment ).scrollLeft() || 0;
11109  curtop += $( o.containment ).scrollTop() || 0;
11110  }
11111 
11112  this.offset = this.helper.offset();
11113  this.position = { left: curleft, top: curtop };
11114 
11115  this.size = this._helper ? {
11116  width: this.helper.width(),
11117  height: this.helper.height()
11118  } : {
11119  width: el.width(),
11120  height: el.height()
11121  };
11122 
11123  this.originalSize = this._helper ? {
11124  width: el.outerWidth(),
11125  height: el.outerHeight()
11126  } : {
11127  width: el.width(),
11128  height: el.height()
11129  };
11130 
11131  this.sizeDiff = {
11132  width: el.outerWidth() - el.width(),
11133  height: el.outerHeight() - el.height()
11134  };
11135 
11136  this.originalPosition = { left: curleft, top: curtop };
11137  this.originalMousePosition = { left: event.pageX, top: event.pageY };
11138 
11139  this.aspectRatio = ( typeof o.aspectRatio === "number" ) ?
11140  o.aspectRatio :
11141  ( ( this.originalSize.width / this.originalSize.height ) || 1 );
11142 
11143  cursor = $( ".ui-resizable-" + this.axis ).css( "cursor" );
11144  $( "body" ).css( "cursor", cursor === "auto" ? this.axis + "-resize" : cursor );
11145 
11146  this._addClass( "ui-resizable-resizing" );
11147  this._propagate( "start", event );
11148  return true;
11149  },
11150 
11151  _mouseDrag: function( event ) {
11152 
11153  var data, props,
11154  smp = this.originalMousePosition,
11155  a = this.axis,
11156  dx = ( event.pageX - smp.left ) || 0,
11157  dy = ( event.pageY - smp.top ) || 0,
11158  trigger = this._change[ a ];
11159 
11160  this._updatePrevProperties();
11161 
11162  if ( !trigger ) {
11163  return false;
11164  }
11165 
11166  data = trigger.apply( this, [ event, dx, dy ] );
11167 
11168  this._updateVirtualBoundaries( event.shiftKey );
11169  if ( this._aspectRatio || event.shiftKey ) {
11170  data = this._updateRatio( data, event );
11171  }
11172 
11173  data = this._respectSize( data, event );
11174 
11175  this._updateCache( data );
11176 
11177  this._propagate( "resize", event );
11178 
11179  props = this._applyChanges();
11180 
11181  if ( !this._helper && this._proportionallyResizeElements.length ) {
11182  this._proportionallyResize();
11183  }
11184 
11185  if ( !$.isEmptyObject( props ) ) {
11186  this._updatePrevProperties();
11187  this._trigger( "resize", event, this.ui() );
11188  this._applyChanges();
11189  }
11190 
11191  return false;
11192  },
11193 
11194  _mouseStop: function( event ) {
11195 
11196  this.resizing = false;
11197  var pr, ista, soffseth, soffsetw, s, left, top,
11198  o = this.options, that = this;
11199 
11200  if ( this._helper ) {
11201 
11202  pr = this._proportionallyResizeElements;
11203  ista = pr.length && ( /textarea/i ).test( pr[ 0 ].nodeName );
11204  soffseth = ista && this._hasScroll( pr[ 0 ], "left" ) ? 0 : that.sizeDiff.height;
11205  soffsetw = ista ? 0 : that.sizeDiff.width;
11206 
11207  s = {
11208  width: ( that.helper.width() - soffsetw ),
11209  height: ( that.helper.height() - soffseth )
11210  };
11211  left = ( parseFloat( that.element.css( "left" ) ) +
11212  ( that.position.left - that.originalPosition.left ) ) || null;
11213  top = ( parseFloat( that.element.css( "top" ) ) +
11214  ( that.position.top - that.originalPosition.top ) ) || null;
11215 
11216  if ( !o.animate ) {
11217  this.element.css( $.extend( s, { top: top, left: left } ) );
11218  }
11219 
11220  that.helper.height( that.size.height );
11221  that.helper.width( that.size.width );
11222 
11223  if ( this._helper && !o.animate ) {
11224  this._proportionallyResize();
11225  }
11226  }
11227 
11228  $( "body" ).css( "cursor", "auto" );
11229 
11230  this._removeClass( "ui-resizable-resizing" );
11231 
11232  this._propagate( "stop", event );
11233 
11234  if ( this._helper ) {
11235  this.helper.remove();
11236  }
11237 
11238  return false;
11239 
11240  },
11241 
11242  _updatePrevProperties: function() {
11243  this.prevPosition = {
11244  top: this.position.top,
11245  left: this.position.left
11246  };
11247  this.prevSize = {
11248  width: this.size.width,
11249  height: this.size.height
11250  };
11251  },
11252 
11253  _applyChanges: function() {
11254  var props = {};
11255 
11256  if ( this.position.top !== this.prevPosition.top ) {
11257  props.top = this.position.top + "px";
11258  }
11259  if ( this.position.left !== this.prevPosition.left ) {
11260  props.left = this.position.left + "px";
11261  }
11262  if ( this.size.width !== this.prevSize.width ) {
11263  props.width = this.size.width + "px";
11264  }
11265  if ( this.size.height !== this.prevSize.height ) {
11266  props.height = this.size.height + "px";
11267  }
11268 
11269  this.helper.css( props );
11270 
11271  return props;
11272  },
11273 
11274  _updateVirtualBoundaries: function( forceAspectRatio ) {
11275  var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
11276  o = this.options;
11277 
11278  b = {
11279  minWidth: this._isNumber( o.minWidth ) ? o.minWidth : 0,
11280  maxWidth: this._isNumber( o.maxWidth ) ? o.maxWidth : Infinity,
11281  minHeight: this._isNumber( o.minHeight ) ? o.minHeight : 0,
11282  maxHeight: this._isNumber( o.maxHeight ) ? o.maxHeight : Infinity
11283  };
11284 
11285  if ( this._aspectRatio || forceAspectRatio ) {
11286  pMinWidth = b.minHeight * this.aspectRatio;
11287  pMinHeight = b.minWidth / this.aspectRatio;
11288  pMaxWidth = b.maxHeight * this.aspectRatio;
11289  pMaxHeight = b.maxWidth / this.aspectRatio;
11290 
11291  if ( pMinWidth > b.minWidth ) {
11292  b.minWidth = pMinWidth;
11293  }
11294  if ( pMinHeight > b.minHeight ) {
11295  b.minHeight = pMinHeight;
11296  }
11297  if ( pMaxWidth < b.maxWidth ) {
11298  b.maxWidth = pMaxWidth;
11299  }
11300  if ( pMaxHeight < b.maxHeight ) {
11301  b.maxHeight = pMaxHeight;
11302  }
11303  }
11304  this._vBoundaries = b;
11305  },
11306 
11307  _updateCache: function( data ) {
11308  this.offset = this.helper.offset();
11309  if ( this._isNumber( data.left ) ) {
11310  this.position.left = data.left;
11311  }
11312  if ( this._isNumber( data.top ) ) {
11313  this.position.top = data.top;
11314  }
11315  if ( this._isNumber( data.height ) ) {
11316  this.size.height = data.height;
11317  }
11318  if ( this._isNumber( data.width ) ) {
11319  this.size.width = data.width;
11320  }
11321  },
11322 
11323  _updateRatio: function( data ) {
11324 
11325  var cpos = this.position,
11326  csize = this.size,
11327  a = this.axis;
11328 
11329  if ( this._isNumber( data.height ) ) {
11330  data.width = ( data.height * this.aspectRatio );
11331  } else if ( this._isNumber( data.width ) ) {
11332  data.height = ( data.width / this.aspectRatio );
11333  }
11334 
11335  if ( a === "sw" ) {
11336  data.left = cpos.left + ( csize.width - data.width );
11337  data.top = null;
11338  }
11339  if ( a === "nw" ) {
11340  data.top = cpos.top + ( csize.height - data.height );
11341  data.left = cpos.left + ( csize.width - data.width );
11342  }
11343 
11344  return data;
11345  },
11346 
11347  _respectSize: function( data ) {
11348 
11349  var o = this._vBoundaries,
11350  a = this.axis,
11351  ismaxw = this._isNumber( data.width ) && o.maxWidth && ( o.maxWidth < data.width ),
11352  ismaxh = this._isNumber( data.height ) && o.maxHeight && ( o.maxHeight < data.height ),
11353  isminw = this._isNumber( data.width ) && o.minWidth && ( o.minWidth > data.width ),
11354  isminh = this._isNumber( data.height ) && o.minHeight && ( o.minHeight > data.height ),
11355  dw = this.originalPosition.left + this.originalSize.width,
11356  dh = this.originalPosition.top + this.originalSize.height,
11357  cw = /sw|nw|w/.test( a ), ch = /nw|ne|n/.test( a );
11358  if ( isminw ) {
11359  data.width = o.minWidth;
11360  }
11361  if ( isminh ) {
11362  data.height = o.minHeight;
11363  }
11364  if ( ismaxw ) {
11365  data.width = o.maxWidth;
11366  }
11367  if ( ismaxh ) {
11368  data.height = o.maxHeight;
11369  }
11370 
11371  if ( isminw && cw ) {
11372  data.left = dw - o.minWidth;
11373  }
11374  if ( ismaxw && cw ) {
11375  data.left = dw - o.maxWidth;
11376  }
11377  if ( isminh && ch ) {
11378  data.top = dh - o.minHeight;
11379  }
11380  if ( ismaxh && ch ) {
11381  data.top = dh - o.maxHeight;
11382  }
11383 
11384  // Fixing jump error on top/left - bug #2330
11385  if ( !data.width && !data.height && !data.left && data.top ) {
11386  data.top = null;
11387  } else if ( !data.width && !data.height && !data.top && data.left ) {
11388  data.left = null;
11389  }
11390 
11391  return data;
11392  },
11393 
11394  _getPaddingPlusBorderDimensions: function( element ) {
11395  var i = 0,
11396  widths = [],
11397  borders = [
11398  element.css( "borderTopWidth" ),
11399  element.css( "borderRightWidth" ),
11400  element.css( "borderBottomWidth" ),
11401  element.css( "borderLeftWidth" )
11402  ],
11403  paddings = [
11404  element.css( "paddingTop" ),
11405  element.css( "paddingRight" ),
11406  element.css( "paddingBottom" ),
11407  element.css( "paddingLeft" )
11408  ];
11409 
11410  for ( ; i < 4; i++ ) {
11411  widths[ i ] = ( parseFloat( borders[ i ] ) || 0 );
11412  widths[ i ] += ( parseFloat( paddings[ i ] ) || 0 );
11413  }
11414 
11415  return {
11416  height: widths[ 0 ] + widths[ 2 ],
11417  width: widths[ 1 ] + widths[ 3 ]
11418  };
11419  },
11420 
11421  _proportionallyResize: function() {
11422 
11423  if ( !this._proportionallyResizeElements.length ) {
11424  return;
11425  }
11426 
11427  var prel,
11428  i = 0,
11429  element = this.helper || this.element;
11430 
11431  for ( ; i < this._proportionallyResizeElements.length; i++ ) {
11432 
11433  prel = this._proportionallyResizeElements[ i ];
11434 
11435  // TODO: Seems like a bug to cache this.outerDimensions
11436  // considering that we are in a loop.
11437  if ( !this.outerDimensions ) {
11438  this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
11439  }
11440 
11441  prel.css( {
11442  height: ( element.height() - this.outerDimensions.height ) || 0,
11443  width: ( element.width() - this.outerDimensions.width ) || 0
11444  } );
11445 
11446  }
11447 
11448  },
11449 
11450  _renderProxy: function() {
11451 
11452  var el = this.element, o = this.options;
11453  this.elementOffset = el.offset();
11454 
11455  if ( this._helper ) {
11456 
11457  this.helper = this.helper || $( "<div style='overflow:hidden;'></div>" );
11458 
11459  this._addClass( this.helper, this._helper );
11460  this.helper.css( {
11461  width: this.element.outerWidth(),
11462  height: this.element.outerHeight(),
11463  position: "absolute",
11464  left: this.elementOffset.left + "px",
11465  top: this.elementOffset.top + "px",
11466  zIndex: ++o.zIndex //TODO: Don't modify option
11467  } );
11468 
11469  this.helper
11470  .appendTo( "body" )
11471  .disableSelection();
11472 
11473  } else {
11474  this.helper = this.element;
11475  }
11476 
11477  },
11478 
11479  _change: {
11480  e: function( event, dx ) {
11481  return { width: this.originalSize.width + dx };
11482  },
11483  w: function( event, dx ) {
11484  var cs = this.originalSize, sp = this.originalPosition;
11485  return { left: sp.left + dx, width: cs.width - dx };
11486  },
11487  n: function( event, dx, dy ) {
11488  var cs = this.originalSize, sp = this.originalPosition;
11489  return { top: sp.top + dy, height: cs.height - dy };
11490  },
11491  s: function( event, dx, dy ) {
11492  return { height: this.originalSize.height + dy };
11493  },
11494  se: function( event, dx, dy ) {
11495  return $.extend( this._change.s.apply( this, arguments ),
11496  this._change.e.apply( this, [ event, dx, dy ] ) );
11497  },
11498  sw: function( event, dx, dy ) {
11499  return $.extend( this._change.s.apply( this, arguments ),
11500  this._change.w.apply( this, [ event, dx, dy ] ) );
11501  },
11502  ne: function( event, dx, dy ) {
11503  return $.extend( this._change.n.apply( this, arguments ),
11504  this._change.e.apply( this, [ event, dx, dy ] ) );
11505  },
11506  nw: function( event, dx, dy ) {
11507  return $.extend( this._change.n.apply( this, arguments ),
11508  this._change.w.apply( this, [ event, dx, dy ] ) );
11509  }
11510  },
11511 
11512  _propagate: function( n, event ) {
11513  $.ui.plugin.call( this, n, [ event, this.ui() ] );
11514  ( n !== "resize" && this._trigger( n, event, this.ui() ) );
11515  },
11516 
11517  plugins: {},
11518 
11519  ui: function() {
11520  return {
11521  originalElement: this.originalElement,
11522  element: this.element,
11523  helper: this.helper,
11524  position: this.position,
11525  size: this.size,
11526  originalSize: this.originalSize,
11527  originalPosition: this.originalPosition
11528  };
11529  }
11530 
11531 } );
11532 
11533 /*
11534  * Resizable Extensions
11535  */
11536 
11537 $.ui.plugin.add( "resizable", "animate", {
11538 
11539  stop: function( event ) {
11540  var that = $( this ).resizable( "instance" ),
11541  o = that.options,
11542  pr = that._proportionallyResizeElements,
11543  ista = pr.length && ( /textarea/i ).test( pr[ 0 ].nodeName ),
11544  soffseth = ista && that._hasScroll( pr[ 0 ], "left" ) ? 0 : that.sizeDiff.height,
11545  soffsetw = ista ? 0 : that.sizeDiff.width,
11546  style = {
11547  width: ( that.size.width - soffsetw ),
11548  height: ( that.size.height - soffseth )
11549  },
11550  left = ( parseFloat( that.element.css( "left" ) ) +
11551  ( that.position.left - that.originalPosition.left ) ) || null,
11552  top = ( parseFloat( that.element.css( "top" ) ) +
11553  ( that.position.top - that.originalPosition.top ) ) || null;
11554 
11555  that.element.animate(
11556  $.extend( style, top && left ? { top: top, left: left } : {} ), {
11557  duration: o.animateDuration,
11558  easing: o.animateEasing,
11559  step: function() {
11560 
11561  var data = {
11562  width: parseFloat( that.element.css( "width" ) ),
11563  height: parseFloat( that.element.css( "height" ) ),
11564  top: parseFloat( that.element.css( "top" ) ),
11565  left: parseFloat( that.element.css( "left" ) )
11566  };
11567 
11568  if ( pr && pr.length ) {
11569  $( pr[ 0 ] ).css( { width: data.width, height: data.height } );
11570  }
11571 
11572  // Propagating resize, and updating values for each animation step
11573  that._updateCache( data );
11574  that._propagate( "resize", event );
11575 
11576  }
11577  }
11578  );
11579  }
11580 
11581 } );
11582 
11583 $.ui.plugin.add( "resizable", "containment", {
11584 
11585  start: function() {
11586  var element, p, co, ch, cw, width, height,
11587  that = $( this ).resizable( "instance" ),
11588  o = that.options,
11589  el = that.element,
11590  oc = o.containment,
11591  ce = ( oc instanceof $ ) ?
11592  oc.get( 0 ) :
11593  ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
11594 
11595  if ( !ce ) {
11596  return;
11597  }
11598 
11599  that.containerElement = $( ce );
11600 
11601  if ( /document/.test( oc ) || oc === document ) {
11602  that.containerOffset = {
11603  left: 0,
11604  top: 0
11605  };
11606  that.containerPosition = {
11607  left: 0,
11608  top: 0
11609  };
11610 
11611  that.parentData = {
11612  element: $( document ),
11613  left: 0,
11614  top: 0,
11615  width: $( document ).width(),
11616  height: $( document ).height() || document.body.parentNode.scrollHeight
11617  };
11618  } else {
11619  element = $( ce );
11620  p = [];
11621  $( [ "Top", "Right", "Left", "Bottom" ] ).each( function( i, name ) {
11622  p[ i ] = that._num( element.css( "padding" + name ) );
11623  } );
11624 
11625  that.containerOffset = element.offset();
11626  that.containerPosition = element.position();
11627  that.containerSize = {
11628  height: ( element.innerHeight() - p[ 3 ] ),
11629  width: ( element.innerWidth() - p[ 1 ] )
11630  };
11631 
11632  co = that.containerOffset;
11633  ch = that.containerSize.height;
11634  cw = that.containerSize.width;
11635  width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
11636  height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
11637 
11638  that.parentData = {
11639  element: ce,
11640  left: co.left,
11641  top: co.top,
11642  width: width,
11643  height: height
11644  };
11645  }
11646  },
11647 
11648  resize: function( event ) {
11649  var woset, hoset, isParent, isOffsetRelative,
11650  that = $( this ).resizable( "instance" ),
11651  o = that.options,
11652  co = that.containerOffset,
11653  cp = that.position,
11654  pRatio = that._aspectRatio || event.shiftKey,
11655  cop = {
11656  top: 0,
11657  left: 0
11658  },
11659  ce = that.containerElement,
11660  continueResize = true;
11661 
11662  if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
11663  cop = co;
11664  }
11665 
11666  if ( cp.left < ( that._helper ? co.left : 0 ) ) {
11667  that.size.width = that.size.width +
11668  ( that._helper ?
11669  ( that.position.left - co.left ) :
11670  ( that.position.left - cop.left ) );
11671 
11672  if ( pRatio ) {
11673  that.size.height = that.size.width / that.aspectRatio;
11674  continueResize = false;
11675  }
11676  that.position.left = o.helper ? co.left : 0;
11677  }
11678 
11679  if ( cp.top < ( that._helper ? co.top : 0 ) ) {
11680  that.size.height = that.size.height +
11681  ( that._helper ?
11682  ( that.position.top - co.top ) :
11683  that.position.top );
11684 
11685  if ( pRatio ) {
11686  that.size.width = that.size.height * that.aspectRatio;
11687  continueResize = false;
11688  }
11689  that.position.top = that._helper ? co.top : 0;
11690  }
11691 
11692  isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
11693  isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
11694 
11695  if ( isParent && isOffsetRelative ) {
11696  that.offset.left = that.parentData.left + that.position.left;
11697  that.offset.top = that.parentData.top + that.position.top;
11698  } else {
11699  that.offset.left = that.element.offset().left;
11700  that.offset.top = that.element.offset().top;
11701  }
11702 
11703  woset = Math.abs( that.sizeDiff.width +
11704  ( that._helper ?
11705  that.offset.left - cop.left :
11706  ( that.offset.left - co.left ) ) );
11707 
11708  hoset = Math.abs( that.sizeDiff.height +
11709  ( that._helper ?
11710  that.offset.top - cop.top :
11711  ( that.offset.top - co.top ) ) );
11712 
11713  if ( woset + that.size.width >= that.parentData.width ) {
11714  that.size.width = that.parentData.width - woset;
11715  if ( pRatio ) {
11716  that.size.height = that.size.width / that.aspectRatio;
11717  continueResize = false;
11718  }
11719  }
11720 
11721  if ( hoset + that.size.height >= that.parentData.height ) {
11722  that.size.height = that.parentData.height - hoset;
11723  if ( pRatio ) {
11724  that.size.width = that.size.height * that.aspectRatio;
11725  continueResize = false;
11726  }
11727  }
11728 
11729  if ( !continueResize ) {
11730  that.position.left = that.prevPosition.left;
11731  that.position.top = that.prevPosition.top;
11732  that.size.width = that.prevSize.width;
11733  that.size.height = that.prevSize.height;
11734  }
11735  },
11736 
11737  stop: function() {
11738  var that = $( this ).resizable( "instance" ),
11739  o = that.options,
11740  co = that.containerOffset,
11741  cop = that.containerPosition,
11742  ce = that.containerElement,
11743  helper = $( that.helper ),
11744  ho = helper.offset(),
11745  w = helper.outerWidth() - that.sizeDiff.width,
11746  h = helper.outerHeight() - that.sizeDiff.height;
11747 
11748  if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
11749  $( this ).css( {
11750  left: ho.left - cop.left - co.left,
11751  width: w,
11752  height: h
11753  } );
11754  }
11755 
11756  if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
11757  $( this ).css( {
11758  left: ho.left - cop.left - co.left,
11759  width: w,
11760  height: h
11761  } );
11762  }
11763  }
11764 } );
11765 
11766 $.ui.plugin.add( "resizable", "alsoResize", {
11767 
11768  start: function() {
11769  var that = $( this ).resizable( "instance" ),
11770  o = that.options;
11771 
11772  $( o.alsoResize ).each( function() {
11773  var el = $( this );
11774  el.data( "ui-resizable-alsoresize", {
11775  width: parseFloat( el.width() ), height: parseFloat( el.height() ),
11776  left: parseFloat( el.css( "left" ) ), top: parseFloat( el.css( "top" ) )
11777  } );
11778  } );
11779  },
11780 
11781  resize: function( event, ui ) {
11782  var that = $( this ).resizable( "instance" ),
11783  o = that.options,
11784  os = that.originalSize,
11785  op = that.originalPosition,
11786  delta = {
11787  height: ( that.size.height - os.height ) || 0,
11788  width: ( that.size.width - os.width ) || 0,
11789  top: ( that.position.top - op.top ) || 0,
11790  left: ( that.position.left - op.left ) || 0
11791  };
11792 
11793  $( o.alsoResize ).each( function() {
11794  var el = $( this ), start = $( this ).data( "ui-resizable-alsoresize" ), style = {},
11795  css = el.parents( ui.originalElement[ 0 ] ).length ?
11796  [ "width", "height" ] :
11797  [ "width", "height", "top", "left" ];
11798 
11799  $.each( css, function( i, prop ) {
11800  var sum = ( start[ prop ] || 0 ) + ( delta[ prop ] || 0 );
11801  if ( sum && sum >= 0 ) {
11802  style[ prop ] = sum || null;
11803  }
11804  } );
11805 
11806  el.css( style );
11807  } );
11808  },
11809 
11810  stop: function() {
11811  $( this ).removeData( "ui-resizable-alsoresize" );
11812  }
11813 } );
11814 
11815 $.ui.plugin.add( "resizable", "ghost", {
11816 
11817  start: function() {
11818 
11819  var that = $( this ).resizable( "instance" ), cs = that.size;
11820 
11821  that.ghost = that.originalElement.clone();
11822  that.ghost.css( {
11823  opacity: 0.25,
11824  display: "block",
11825  position: "relative",
11826  height: cs.height,
11827  width: cs.width,
11828  margin: 0,
11829  left: 0,
11830  top: 0
11831  } );
11832 
11833  that._addClass( that.ghost, "ui-resizable-ghost" );
11834 
11835  // DEPRECATED
11836  // TODO: remove after 1.12
11837  if ( $.uiBackCompat !== false && typeof that.options.ghost === "string" ) {
11838 
11839  // Ghost option
11840  that.ghost.addClass( this.options.ghost );
11841  }
11842 
11843  that.ghost.appendTo( that.helper );
11844 
11845  },
11846 
11847  resize: function() {
11848  var that = $( this ).resizable( "instance" );
11849  if ( that.ghost ) {
11850  that.ghost.css( {
11851  position: "relative",
11852  height: that.size.height,
11853  width: that.size.width
11854  } );
11855  }
11856  },
11857 
11858  stop: function() {
11859  var that = $( this ).resizable( "instance" );
11860  if ( that.ghost && that.helper ) {
11861  that.helper.get( 0 ).removeChild( that.ghost.get( 0 ) );
11862  }
11863  }
11864 
11865 } );
11866 
11867 $.ui.plugin.add( "resizable", "grid", {
11868 
11869  resize: function() {
11870  var outerDimensions,
11871  that = $( this ).resizable( "instance" ),
11872  o = that.options,
11873  cs = that.size,
11874  os = that.originalSize,
11875  op = that.originalPosition,
11876  a = that.axis,
11877  grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
11878  gridX = ( grid[ 0 ] || 1 ),
11879  gridY = ( grid[ 1 ] || 1 ),
11880  ox = Math.round( ( cs.width - os.width ) / gridX ) * gridX,
11881  oy = Math.round( ( cs.height - os.height ) / gridY ) * gridY,
11882  newWidth = os.width + ox,
11883  newHeight = os.height + oy,
11884  isMaxWidth = o.maxWidth && ( o.maxWidth < newWidth ),
11885  isMaxHeight = o.maxHeight && ( o.maxHeight < newHeight ),
11886  isMinWidth = o.minWidth && ( o.minWidth > newWidth ),
11887  isMinHeight = o.minHeight && ( o.minHeight > newHeight );
11888 
11889  o.grid = grid;
11890 
11891  if ( isMinWidth ) {
11892  newWidth += gridX;
11893  }
11894  if ( isMinHeight ) {
11895  newHeight += gridY;
11896  }
11897  if ( isMaxWidth ) {
11898  newWidth -= gridX;
11899  }
11900  if ( isMaxHeight ) {
11901  newHeight -= gridY;
11902  }
11903 
11904  if ( /^(se|s|e)$/.test( a ) ) {
11905  that.size.width = newWidth;
11906  that.size.height = newHeight;
11907  } else if ( /^(ne)$/.test( a ) ) {
11908  that.size.width = newWidth;
11909  that.size.height = newHeight;
11910  that.position.top = op.top - oy;
11911  } else if ( /^(sw)$/.test( a ) ) {
11912  that.size.width = newWidth;
11913  that.size.height = newHeight;
11914  that.position.left = op.left - ox;
11915  } else {
11916  if ( newHeight - gridY <= 0 || newWidth - gridX <= 0 ) {
11917  outerDimensions = that._getPaddingPlusBorderDimensions( this );
11918  }
11919 
11920  if ( newHeight - gridY > 0 ) {
11921  that.size.height = newHeight;
11922  that.position.top = op.top - oy;
11923  } else {
11924  newHeight = gridY - outerDimensions.height;
11925  that.size.height = newHeight;
11926  that.position.top = op.top + os.height - newHeight;
11927  }
11928  if ( newWidth - gridX > 0 ) {
11929  that.size.width = newWidth;
11930  that.position.left = op.left - ox;
11931  } else {
11932  newWidth = gridX - outerDimensions.width;
11933  that.size.width = newWidth;
11934  that.position.left = op.left + os.width - newWidth;
11935  }
11936  }
11937  }
11938 
11939 } );
11940 
11941 var widgetsResizable = $.ui.resizable;
11942 
11943 
11944 /*!
11945  * jQuery UI Dialog 1.12.1
11946  * http://jqueryui.com
11947  *
11948  * Copyright jQuery Foundation and other contributors
11949  * Released under the MIT license.
11950  * http://jquery.org/license
11951  */
11952 
11953 //>>label: Dialog
11954 //>>group: Widgets
11955 //>>description: Displays customizable dialog windows.
11956 //>>docs: http://api.jqueryui.com/dialog/
11957 //>>demos: http://jqueryui.com/dialog/
11958 //>>css.structure: ../../themes/base/core.css
11959 //>>css.structure: ../../themes/base/dialog.css
11960 //>>css.theme: ../../themes/base/theme.css
11961 
11962 
11963 
11964 $.widget( "ui.dialog", {
11965  version: "1.12.1",
11966  options: {
11967  appendTo: "body",
11968  autoOpen: true,
11969  buttons: [],
11970  classes: {
11971  "ui-dialog": "ui-corner-all",
11972  "ui-dialog-titlebar": "ui-corner-all"
11973  },
11974  closeOnEscape: true,
11975  closeText: "Close",
11976  draggable: true,
11977  hide: null,
11978  height: "auto",
11979  maxHeight: null,
11980  maxWidth: null,
11981  minHeight: 150,
11982  minWidth: 150,
11983  modal: false,
11984  position: {
11985  my: "center",
11986  at: "center",
11987  of: window,
11988  collision: "fit",
11989 
11990  // Ensure the titlebar is always visible
11991  using: function( pos ) {
11992  var topOffset = $( this ).css( pos ).offset().top;
11993  if ( topOffset < 0 ) {
11994  $( this ).css( "top", pos.top - topOffset );
11995  }
11996  }
11997  },
11998  resizable: true,
11999  show: null,
12000  title: null,
12001  width: 300,
12002 
12003  // Callbacks
12004  beforeClose: null,
12005  close: null,
12006  drag: null,
12007  dragStart: null,
12008  dragStop: null,
12009  focus: null,
12010  open: null,
12011  resize: null,
12012  resizeStart: null,
12013  resizeStop: null
12014  },
12015 
12016  sizeRelatedOptions: {
12017  buttons: true,
12018  height: true,
12019  maxHeight: true,
12020  maxWidth: true,
12021  minHeight: true,
12022  minWidth: true,
12023  width: true
12024  },
12025 
12026  resizableRelatedOptions: {
12027  maxHeight: true,
12028  maxWidth: true,
12029  minHeight: true,
12030  minWidth: true
12031  },
12032 
12033  _create: function() {
12034  this.originalCss = {
12035  display: this.element[ 0 ].style.display,
12036  width: this.element[ 0 ].style.width,
12037  minHeight: this.element[ 0 ].style.minHeight,
12038  maxHeight: this.element[ 0 ].style.maxHeight,
12039  height: this.element[ 0 ].style.height
12040  };
12041  this.originalPosition = {
12042  parent: this.element.parent(),
12043  index: this.element.parent().children().index( this.element )
12044  };
12045  this.originalTitle = this.element.attr( "title" );
12046  if ( this.options.title == null && this.originalTitle != null ) {
12047  this.options.title = this.originalTitle;
12048  }
12049 
12050  // Dialogs can't be disabled
12051  if ( this.options.disabled ) {
12052  this.options.disabled = false;
12053  }
12054 
12055  this._createWrapper();
12056 
12057  this.element
12058  .show()
12059  .removeAttr( "title" )
12060  .appendTo( this.uiDialog );
12061 
12062  this._addClass( "ui-dialog-content", "ui-widget-content" );
12063 
12064  this._createTitlebar();
12065  this._createButtonPane();
12066 
12067  if ( this.options.draggable && $.fn.draggable ) {
12068  this._makeDraggable();
12069  }
12070  if ( this.options.resizable && $.fn.resizable ) {
12071  this._makeResizable();
12072  }
12073 
12074  this._isOpen = false;
12075 
12076  this._trackFocus();
12077  },
12078 
12079  _init: function() {
12080  if ( this.options.autoOpen ) {
12081  this.open();
12082  }
12083  },
12084 
12085  _appendTo: function() {
12086  var element = this.options.appendTo;
12087  if ( element && ( element.jquery || element.nodeType ) ) {
12088  return $( element );
12089  }
12090  return this.document.find( element || "body" ).eq( 0 );
12091  },
12092 
12093  _destroy: function() {
12094  var next,
12095  originalPosition = this.originalPosition;
12096 
12097  this._untrackInstance();
12098  this._destroyOverlay();
12099 
12100  this.element
12101  .removeUniqueId()
12102  .css( this.originalCss )
12103 
12104  // Without detaching first, the following becomes really slow
12105  .detach();
12106 
12107  this.uiDialog.remove();
12108 
12109  if ( this.originalTitle ) {
12110  this.element.attr( "title", this.originalTitle );
12111  }
12112 
12113  next = originalPosition.parent.children().eq( originalPosition.index );
12114 
12115  // Don't try to place the dialog next to itself (#8613)
12116  if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {
12117  next.before( this.element );
12118  } else {
12119  originalPosition.parent.append( this.element );
12120  }
12121  },
12122 
12123  widget: function() {
12124  return this.uiDialog;
12125  },
12126 
12127  disable: $.noop,
12128  enable: $.noop,
12129 
12130  close: function( event ) {
12131  var that = this;
12132 
12133  if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
12134  return;
12135  }
12136 
12137  this._isOpen = false;
12138  this._focusedElement = null;
12139  this._destroyOverlay();
12140  this._untrackInstance();
12141 
12142  if ( !this.opener.filter( ":focusable" ).trigger( "focus" ).length ) {
12143 
12144  // Hiding a focused element doesn't trigger blur in WebKit
12145  // so in case we have nothing to focus on, explicitly blur the active element
12146  // https://bugs.webkit.org/show_bug.cgi?id=47182
12147  $.ui.safeBlur( $.ui.safeActiveElement( this.document[ 0 ] ) );
12148  }
12149 
12150  this._hide( this.uiDialog, this.options.hide, function() {
12151  that._trigger( "close", event );
12152  } );
12153  },
12154 
12155  isOpen: function() {
12156  return this._isOpen;
12157  },
12158 
12159  moveToTop: function() {
12160  this._moveToTop();
12161  },
12162 
12163  _moveToTop: function( event, silent ) {
12164  var moved = false,
12165  zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map( function() {
12166  return +$( this ).css( "z-index" );
12167  } ).get(),
12168  zIndexMax = Math.max.apply( null, zIndices );
12169 
12170  if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {
12171  this.uiDialog.css( "z-index", zIndexMax + 1 );
12172  moved = true;
12173  }
12174 
12175  if ( moved && !silent ) {
12176  this._trigger( "focus", event );
12177  }
12178  return moved;
12179  },
12180 
12181  open: function() {
12182  var that = this;
12183  if ( this._isOpen ) {
12184  if ( this._moveToTop() ) {
12185  this._focusTabbable();
12186  }
12187  return;
12188  }
12189 
12190  this._isOpen = true;
12191  this.opener = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
12192 
12193  this._size();
12194  this._position();
12195  this._createOverlay();
12196  this._moveToTop( null, true );
12197 
12198  // Ensure the overlay is moved to the top with the dialog, but only when
12199  // opening. The overlay shouldn't move after the dialog is open so that
12200  // modeless dialogs opened after the modal dialog stack properly.
12201  if ( this.overlay ) {
12202  this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
12203  }
12204 
12205  this._show( this.uiDialog, this.options.show, function() {
12206  that._focusTabbable();
12207  that._trigger( "focus" );
12208  } );
12209 
12210  // Track the dialog immediately upon openening in case a focus event
12211  // somehow occurs outside of the dialog before an element inside the
12212  // dialog is focused (#10152)
12213  this._makeFocusTarget();
12214 
12215  this._trigger( "open" );
12216  },
12217 
12218  _focusTabbable: function() {
12219 
12220  // Set focus to the first match:
12221  // 1. An element that was focused previously
12222  // 2. First element inside the dialog matching [autofocus]
12223  // 3. Tabbable element inside the content element
12224  // 4. Tabbable element inside the buttonpane
12225  // 5. The close button
12226  // 6. The dialog itself
12227  var hasFocus = this._focusedElement;
12228  if ( !hasFocus ) {
12229  hasFocus = this.element.find( "[autofocus]" );
12230  }
12231  if ( !hasFocus.length ) {
12232  hasFocus = this.element.find( ":tabbable" );
12233  }
12234  if ( !hasFocus.length ) {
12235  hasFocus = this.uiDialogButtonPane.find( ":tabbable" );
12236  }
12237  if ( !hasFocus.length ) {
12238  hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );
12239  }
12240  if ( !hasFocus.length ) {
12241  hasFocus = this.uiDialog;
12242  }
12243  hasFocus.eq( 0 ).trigger( "focus" );
12244  },
12245 
12246  _keepFocus: function( event ) {
12247  function checkFocus() {
12248  var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),
12249  isActive = this.uiDialog[ 0 ] === activeElement ||
12250  $.contains( this.uiDialog[ 0 ], activeElement );
12251  if ( !isActive ) {
12252  this._focusTabbable();
12253  }
12254  }
12255  event.preventDefault();
12256  checkFocus.call( this );
12257 
12258  // support: IE
12259  // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
12260  // so we check again later
12261  this._delay( checkFocus );
12262  },
12263 
12264  _createWrapper: function() {
12265  this.uiDialog = $( "<div>" )
12266  .hide()
12267  .attr( {
12268 
12269  // Setting tabIndex makes the div focusable
12270  tabIndex: -1,
12271  role: "dialog"
12272  } )
12273  .appendTo( this._appendTo() );
12274 
12275  this._addClass( this.uiDialog, "ui-dialog", "ui-widget ui-widget-content ui-front" );
12276  this._on( this.uiDialog, {
12277  keydown: function( event ) {
12278  if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
12279  event.keyCode === $.ui.keyCode.ESCAPE ) {
12280  event.preventDefault();
12281  this.close( event );
12282  return;
12283  }
12284 
12285  // Prevent tabbing out of dialogs
12286  if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) {
12287  return;
12288  }
12289  var tabbables = this.uiDialog.find( ":tabbable" ),
12290  first = tabbables.filter( ":first" ),
12291  last = tabbables.filter( ":last" );
12292 
12293  if ( ( event.target === last[ 0 ] || event.target === this.uiDialog[ 0 ] ) &&
12294  !event.shiftKey ) {
12295  this._delay( function() {
12296  first.trigger( "focus" );
12297  } );
12298  event.preventDefault();
12299  } else if ( ( event.target === first[ 0 ] ||
12300  event.target === this.uiDialog[ 0 ] ) && event.shiftKey ) {
12301  this._delay( function() {
12302  last.trigger( "focus" );
12303  } );
12304  event.preventDefault();
12305  }
12306  },
12307  mousedown: function( event ) {
12308  if ( this._moveToTop( event ) ) {
12309  this._focusTabbable();
12310  }
12311  }
12312  } );
12313 
12314  // We assume that any existing aria-describedby attribute means
12315  // that the dialog content is marked up properly
12316  // otherwise we brute force the content as the description
12317  if ( !this.element.find( "[aria-describedby]" ).length ) {
12318  this.uiDialog.attr( {
12319  "aria-describedby": this.element.uniqueId().attr( "id" )
12320  } );
12321  }
12322  },
12323 
12324  _createTitlebar: function() {
12325  var uiDialogTitle;
12326 
12327  this.uiDialogTitlebar = $( "<div>" );
12328  this._addClass( this.uiDialogTitlebar,
12329  "ui-dialog-titlebar", "ui-widget-header ui-helper-clearfix" );
12330  this._on( this.uiDialogTitlebar, {
12331  mousedown: function( event ) {
12332 
12333  // Don't prevent click on close button (#8838)
12334  // Focusing a dialog that is partially scrolled out of view
12335  // causes the browser to scroll it into view, preventing the click event
12336  if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) {
12337 
12338  // Dialog isn't getting focus when dragging (#8063)
12339  this.uiDialog.trigger( "focus" );
12340  }
12341  }
12342  } );
12343 
12344  // Support: IE
12345  // Use type="button" to prevent enter keypresses in textboxes from closing the
12346  // dialog in IE (#9312)
12347  this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
12348  .button( {
12349  label: $( "<a>" ).text( this.options.closeText ).html(),
12350  icon: "ui-icon-closethick",
12351  showLabel: false
12352  } )
12353  .appendTo( this.uiDialogTitlebar );
12354 
12355  this._addClass( this.uiDialogTitlebarClose, "ui-dialog-titlebar-close" );
12356  this._on( this.uiDialogTitlebarClose, {
12357  click: function( event ) {
12358  event.preventDefault();
12359  this.close( event );
12360  }
12361  } );
12362 
12363  uiDialogTitle = $( "<span>" ).uniqueId().prependTo( this.uiDialogTitlebar );
12364  this._addClass( uiDialogTitle, "ui-dialog-title" );
12365  this._title( uiDialogTitle );
12366 
12367  this.uiDialogTitlebar.prependTo( this.uiDialog );
12368 
12369  this.uiDialog.attr( {
12370  "aria-labelledby": uiDialogTitle.attr( "id" )
12371  } );
12372  },
12373 
12374  _title: function( title ) {
12375  if ( this.options.title ) {
12376  title.text( this.options.title );
12377  } else {
12378  title.html( "&#160;" );
12379  }
12380  },
12381 
12382  _createButtonPane: function() {
12383  this.uiDialogButtonPane = $( "<div>" );
12384  this._addClass( this.uiDialogButtonPane, "ui-dialog-buttonpane",
12385  "ui-widget-content ui-helper-clearfix" );
12386 
12387  this.uiButtonSet = $( "<div>" )
12388  .appendTo( this.uiDialogButtonPane );
12389  this._addClass( this.uiButtonSet, "ui-dialog-buttonset" );
12390 
12391  this._createButtons();
12392  },
12393 
12394  _createButtons: function() {
12395  var that = this,
12396  buttons = this.options.buttons;
12397 
12398  // If we already have a button pane, remove it
12399  this.uiDialogButtonPane.remove();
12400  this.uiButtonSet.empty();
12401 
12402  if ( $.isEmptyObject( buttons ) || ( $.isArray( buttons ) && !buttons.length ) ) {
12403  this._removeClass( this.uiDialog, "ui-dialog-buttons" );
12404  return;
12405  }
12406 
12407  $.each( buttons, function( name, props ) {
12408  var click, buttonOptions;
12409  props = $.isFunction( props ) ?
12410  { click: props, text: name } :
12411  props;
12412 
12413  // Default to a non-submitting button
12414  props = $.extend( { type: "button" }, props );
12415 
12416  // Change the context for the click callback to be the main element
12417  click = props.click;
12418  buttonOptions = {
12419  icon: props.icon,
12420  iconPosition: props.iconPosition,
12421  showLabel: props.showLabel,
12422 
12423  // Deprecated options
12424  icons: props.icons,
12425  text: props.text
12426  };
12427 
12428  delete props.click;
12429  delete props.icon;
12430  delete props.iconPosition;
12431  delete props.showLabel;
12432 
12433  // Deprecated options
12434  delete props.icons;
12435  if ( typeof props.text === "boolean" ) {
12436  delete props.text;
12437  }
12438 
12439  $( "<button></button>", props )
12440  .button( buttonOptions )
12441  .appendTo( that.uiButtonSet )
12442  .on( "click", function() {
12443  click.apply( that.element[ 0 ], arguments );
12444  } );
12445  } );
12446  this._addClass( this.uiDialog, "ui-dialog-buttons" );
12447  this.uiDialogButtonPane.appendTo( this.uiDialog );
12448  },
12449 
12450  _makeDraggable: function() {
12451  var that = this,
12452  options = this.options;
12453 
12454  function filteredUi( ui ) {
12455  return {
12456  position: ui.position,
12457  offset: ui.offset
12458  };
12459  }
12460 
12461  this.uiDialog.draggable( {
12462  cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
12463  handle: ".ui-dialog-titlebar",
12464  containment: "document",
12465  start: function( event, ui ) {
12466  that._addClass( $( this ), "ui-dialog-dragging" );
12467  that._blockFrames();
12468  that._trigger( "dragStart", event, filteredUi( ui ) );
12469  },
12470  drag: function( event, ui ) {
12471  that._trigger( "drag", event, filteredUi( ui ) );
12472  },
12473  stop: function( event, ui ) {
12474  var left = ui.offset.left - that.document.scrollLeft(),
12475  top = ui.offset.top - that.document.scrollTop();
12476 
12477  options.position = {
12478  my: "left top",
12479  at: "left" + ( left >= 0 ? "+" : "" ) + left + " " +
12480  "top" + ( top >= 0 ? "+" : "" ) + top,
12481  of: that.window
12482  };
12483  that._removeClass( $( this ), "ui-dialog-dragging" );
12484  that._unblockFrames();
12485  that._trigger( "dragStop", event, filteredUi( ui ) );
12486  }
12487  } );
12488  },
12489 
12490  _makeResizable: function() {
12491  var that = this,
12492  options = this.options,
12493  handles = options.resizable,
12494 
12495  // .ui-resizable has position: relative defined in the stylesheet
12496  // but dialogs have to use absolute or fixed positioning
12497  position = this.uiDialog.css( "position" ),
12498  resizeHandles = typeof handles === "string" ?
12499  handles :
12500  "n,e,s,w,se,sw,ne,nw";
12501 
12502  function filteredUi( ui ) {
12503  return {
12504  originalPosition: ui.originalPosition,
12505  originalSize: ui.originalSize,
12506  position: ui.position,
12507  size: ui.size
12508  };
12509  }
12510 
12511  this.uiDialog.resizable( {
12512  cancel: ".ui-dialog-content",
12513  containment: "document",
12514  alsoResize: this.element,
12515  maxWidth: options.maxWidth,
12516  maxHeight: options.maxHeight,
12517  minWidth: options.minWidth,
12518  minHeight: this._minHeight(),
12519  handles: resizeHandles,
12520  start: function( event, ui ) {
12521  that._addClass( $( this ), "ui-dialog-resizing" );
12522  that._blockFrames();
12523  that._trigger( "resizeStart", event, filteredUi( ui ) );
12524  },
12525  resize: function( event, ui ) {
12526  that._trigger( "resize", event, filteredUi( ui ) );
12527  },
12528  stop: function( event, ui ) {
12529  var offset = that.uiDialog.offset(),
12530  left = offset.left - that.document.scrollLeft(),
12531  top = offset.top - that.document.scrollTop();
12532 
12533  options.height = that.uiDialog.height();
12534  options.width = that.uiDialog.width();
12535  options.position = {
12536  my: "left top",
12537  at: "left" + ( left >= 0 ? "+" : "" ) + left + " " +
12538  "top" + ( top >= 0 ? "+" : "" ) + top,
12539  of: that.window
12540  };
12541  that._removeClass( $( this ), "ui-dialog-resizing" );
12542  that._unblockFrames();
12543  that._trigger( "resizeStop", event, filteredUi( ui ) );
12544  }
12545  } )
12546  .css( "position", position );
12547  },
12548 
12549  _trackFocus: function() {
12550  this._on( this.widget(), {
12551  focusin: function( event ) {
12552  this._makeFocusTarget();
12553  this._focusedElement = $( event.target );
12554  }
12555  } );
12556  },
12557 
12558  _makeFocusTarget: function() {
12559  this._untrackInstance();
12560  this._trackingInstances().unshift( this );
12561  },
12562 
12563  _untrackInstance: function() {
12564  var instances = this._trackingInstances(),
12565  exists = $.inArray( this, instances );
12566  if ( exists !== -1 ) {
12567  instances.splice( exists, 1 );
12568  }
12569  },
12570 
12571  _trackingInstances: function() {
12572  var instances = this.document.data( "ui-dialog-instances" );
12573  if ( !instances ) {
12574  instances = [];
12575  this.document.data( "ui-dialog-instances", instances );
12576  }
12577  return instances;
12578  },
12579 
12580  _minHeight: function() {
12581  var options = this.options;
12582 
12583  return options.height === "auto" ?
12584  options.minHeight :
12585  Math.min( options.minHeight, options.height );
12586  },
12587 
12588  _position: function() {
12589 
12590  // Need to show the dialog to get the actual offset in the position plugin
12591  var isVisible = this.uiDialog.is( ":visible" );
12592  if ( !isVisible ) {
12593  this.uiDialog.show();
12594  }
12595  this.uiDialog.position( this.options.position );
12596  if ( !isVisible ) {
12597  this.uiDialog.hide();
12598  }
12599  },
12600 
12601  _setOptions: function( options ) {
12602  var that = this,
12603  resize = false,
12604  resizableOptions = {};
12605 
12606  $.each( options, function( key, value ) {
12607  that._setOption( key, value );
12608 
12609  if ( key in that.sizeRelatedOptions ) {
12610  resize = true;
12611  }
12612  if ( key in that.resizableRelatedOptions ) {
12613  resizableOptions[ key ] = value;
12614  }
12615  } );
12616 
12617  if ( resize ) {
12618  this._size();
12619  this._position();
12620  }
12621  if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
12622  this.uiDialog.resizable( "option", resizableOptions );
12623  }
12624  },
12625 
12626  _setOption: function( key, value ) {
12627  var isDraggable, isResizable,
12628  uiDialog = this.uiDialog;
12629 
12630  if ( key === "disabled" ) {
12631  return;
12632  }
12633 
12634  this._super( key, value );
12635 
12636  if ( key === "appendTo" ) {
12637  this.uiDialog.appendTo( this._appendTo() );
12638  }
12639 
12640  if ( key === "buttons" ) {
12641  this._createButtons();
12642  }
12643 
12644  if ( key === "closeText" ) {
12645  this.uiDialogTitlebarClose.button( {
12646 
12647  // Ensure that we always pass a string
12648  label: $( "<a>" ).text( "" + this.options.closeText ).html()
12649  } );
12650  }
12651 
12652  if ( key === "draggable" ) {
12653  isDraggable = uiDialog.is( ":data(ui-draggable)" );
12654  if ( isDraggable && !value ) {
12655  uiDialog.draggable( "destroy" );
12656  }
12657 
12658  if ( !isDraggable && value ) {
12659  this._makeDraggable();
12660  }
12661  }
12662 
12663  if ( key === "position" ) {
12664  this._position();
12665  }
12666 
12667  if ( key === "resizable" ) {
12668 
12669  // currently resizable, becoming non-resizable
12670  isResizable = uiDialog.is( ":data(ui-resizable)" );
12671  if ( isResizable && !value ) {
12672  uiDialog.resizable( "destroy" );
12673  }
12674 
12675  // Currently resizable, changing handles
12676  if ( isResizable && typeof value === "string" ) {
12677  uiDialog.resizable( "option", "handles", value );
12678  }
12679 
12680  // Currently non-resizable, becoming resizable
12681  if ( !isResizable && value !== false ) {
12682  this._makeResizable();
12683  }
12684  }
12685 
12686  if ( key === "title" ) {
12687  this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
12688  }
12689  },
12690 
12691  _size: function() {
12692 
12693  // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
12694  // divs will both have width and height set, so we need to reset them
12695  var nonContentHeight, minContentHeight, maxContentHeight,
12696  options = this.options;
12697 
12698  // Reset content sizing
12699  this.element.show().css( {
12700  width: "auto",
12701  minHeight: 0,
12702  maxHeight: "none",
12703  height: 0
12704  } );
12705 
12706  if ( options.minWidth > options.width ) {
12707  options.width = options.minWidth;
12708  }
12709 
12710  // Reset wrapper sizing
12711  // determine the height of all the non-content elements
12712  nonContentHeight = this.uiDialog.css( {
12713  height: "auto",
12714  width: options.width
12715  } )
12716  .outerHeight();
12717  minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
12718  maxContentHeight = typeof options.maxHeight === "number" ?
12719  Math.max( 0, options.maxHeight - nonContentHeight ) :
12720  "none";
12721 
12722  if ( options.height === "auto" ) {
12723  this.element.css( {
12724  minHeight: minContentHeight,
12725  maxHeight: maxContentHeight,
12726  height: "auto"
12727  } );
12728  } else {
12729  this.element.height( Math.max( 0, options.height - nonContentHeight ) );
12730  }
12731 
12732  if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
12733  this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
12734  }
12735  },
12736 
12737  _blockFrames: function() {
12738  this.iframeBlocks = this.document.find( "iframe" ).map( function() {
12739  var iframe = $( this );
12740 
12741  return $( "<div>" )
12742  .css( {
12743  position: "absolute",
12744  width: iframe.outerWidth(),
12745  height: iframe.outerHeight()
12746  } )
12747  .appendTo( iframe.parent() )
12748  .offset( iframe.offset() )[ 0 ];
12749  } );
12750  },
12751 
12752  _unblockFrames: function() {
12753  if ( this.iframeBlocks ) {
12754  this.iframeBlocks.remove();
12755  delete this.iframeBlocks;
12756  }
12757  },
12758 
12759  _allowInteraction: function( event ) {
12760  if ( $( event.target ).closest( ".ui-dialog" ).length ) {
12761  return true;
12762  }
12763 
12764  // TODO: Remove hack when datepicker implements
12765  // the .ui-front logic (#8989)
12766  return !!$( event.target ).closest( ".ui-datepicker" ).length;
12767  },
12768 
12769  _createOverlay: function() {
12770  if ( !this.options.modal ) {
12771  return;
12772  }
12773 
12774  // We use a delay in case the overlay is created from an
12775  // event that we're going to be cancelling (#2804)
12776  var isOpening = true;
12777  this._delay( function() {
12778  isOpening = false;
12779  } );
12780 
12781  if ( !this.document.data( "ui-dialog-overlays" ) ) {
12782 
12783  // Prevent use of anchors and inputs
12784  // Using _on() for an event handler shared across many instances is
12785  // safe because the dialogs stack and must be closed in reverse order
12786  this._on( this.document, {
12787  focusin: function( event ) {
12788  if ( isOpening ) {
12789  return;
12790  }
12791 
12792  if ( !this._allowInteraction( event ) ) {
12793  event.preventDefault();
12794  this._trackingInstances()[ 0 ]._focusTabbable();
12795  }
12796  }
12797  } );
12798  }
12799 
12800  this.overlay = $( "<div>" )
12801  .appendTo( this._appendTo() );
12802 
12803  this._addClass( this.overlay, null, "ui-widget-overlay ui-front" );
12804  this._on( this.overlay, {
12805  mousedown: "_keepFocus"
12806  } );
12807  this.document.data( "ui-dialog-overlays",
12808  ( this.document.data( "ui-dialog-overlays" ) || 0 ) + 1 );
12809  },
12810 
12811  _destroyOverlay: function() {
12812  if ( !this.options.modal ) {
12813  return;
12814  }
12815 
12816  if ( this.overlay ) {
12817  var overlays = this.document.data( "ui-dialog-overlays" ) - 1;
12818 
12819  if ( !overlays ) {
12820  this._off( this.document, "focusin" );
12821  this.document.removeData( "ui-dialog-overlays" );
12822  } else {
12823  this.document.data( "ui-dialog-overlays", overlays );
12824  }
12825 
12826  this.overlay.remove();
12827  this.overlay = null;
12828  }
12829  }
12830 } );
12831 
12832 // DEPRECATED
12833 // TODO: switch return back to widget declaration at top of file when this is removed
12834 if ( $.uiBackCompat !== false ) {
12835 
12836  // Backcompat for dialogClass option
12837  $.widget( "ui.dialog", $.ui.dialog, {
12838  options: {
12839  dialogClass: ""
12840  },
12841  _createWrapper: function() {
12842  this._super();
12843  this.uiDialog.addClass( this.options.dialogClass );
12844  },
12845  _setOption: function( key, value ) {
12846  if ( key === "dialogClass" ) {
12847  this.uiDialog
12848  .removeClass( this.options.dialogClass )
12849  .addClass( value );
12850  }
12851  this._superApply( arguments );
12852  }
12853  } );
12854 }
12855 
12856 var widgetsDialog = $.ui.dialog;
12857 
12858 
12859 /*!
12860  * jQuery UI Droppable 1.12.1
12861  * http://jqueryui.com
12862  *
12863  * Copyright jQuery Foundation and other contributors
12864  * Released under the MIT license.
12865  * http://jquery.org/license
12866  */
12867 
12868 //>>label: Droppable
12869 //>>group: Interactions
12870 //>>description: Enables drop targets for draggable elements.
12871 //>>docs: http://api.jqueryui.com/droppable/
12872 //>>demos: http://jqueryui.com/droppable/
12873 
12874 
12875 
12876 $.widget( "ui.droppable", {
12877  version: "1.12.1",
12878  widgetEventPrefix: "drop",
12879  options: {
12880  accept: "*",
12881  addClasses: true,
12882  greedy: false,
12883  scope: "default",
12884  tolerance: "intersect",
12885 
12886  // Callbacks
12887  activate: null,
12888  deactivate: null,
12889  drop: null,
12890  out: null,
12891  over: null
12892  },
12893  _create: function() {
12894 
12895  var proportions,
12896  o = this.options,
12897  accept = o.accept;
12898 
12899  this.isover = false;
12900  this.isout = true;
12901 
12902  this.accept = $.isFunction( accept ) ? accept : function( d ) {
12903  return d.is( accept );
12904  };
12905 
12906  this.proportions = function( /* valueToWrite */ ) {
12907  if ( arguments.length ) {
12908 
12909  // Store the droppable's proportions
12910  proportions = arguments[ 0 ];
12911  } else {
12912 
12913  // Retrieve or derive the droppable's proportions
12914  return proportions ?
12915  proportions :
12916  proportions = {
12917  width: this.element[ 0 ].offsetWidth,
12918  height: this.element[ 0 ].offsetHeight
12919  };
12920  }
12921  };
12922 
12923  this._addToManager( o.scope );
12924 
12925  o.addClasses && this._addClass( "ui-droppable" );
12926 
12927  },
12928 
12929  _addToManager: function( scope ) {
12930 
12931  // Add the reference and positions to the manager
12932  $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
12933  $.ui.ddmanager.droppables[ scope ].push( this );
12934  },
12935 
12936  _splice: function( drop ) {
12937  var i = 0;
12938  for ( ; i < drop.length; i++ ) {
12939  if ( drop[ i ] === this ) {
12940  drop.splice( i, 1 );
12941  }
12942  }
12943  },
12944 
12945  _destroy: function() {
12946  var drop = $.ui.ddmanager.droppables[ this.options.scope ];
12947 
12948  this._splice( drop );
12949  },
12950 
12951  _setOption: function( key, value ) {
12952 
12953  if ( key === "accept" ) {
12954  this.accept = $.isFunction( value ) ? value : function( d ) {
12955  return d.is( value );
12956  };
12957  } else if ( key === "scope" ) {
12958  var drop = $.ui.ddmanager.droppables[ this.options.scope ];
12959 
12960  this._splice( drop );
12961  this._addToManager( value );
12962  }
12963 
12964  this._super( key, value );
12965  },
12966 
12967  _activate: function( event ) {
12968  var draggable = $.ui.ddmanager.current;
12969 
12970  this._addActiveClass();
12971  if ( draggable ) {
12972  this._trigger( "activate", event, this.ui( draggable ) );
12973  }
12974  },
12975 
12976  _deactivate: function( event ) {
12977  var draggable = $.ui.ddmanager.current;
12978 
12979  this._removeActiveClass();
12980  if ( draggable ) {
12981  this._trigger( "deactivate", event, this.ui( draggable ) );
12982  }
12983  },
12984 
12985  _over: function( event ) {
12986 
12987  var draggable = $.ui.ddmanager.current;
12988 
12989  // Bail if draggable and droppable are same element
12990  if ( !draggable || ( draggable.currentItem ||
12991  draggable.element )[ 0 ] === this.element[ 0 ] ) {
12992  return;
12993  }
12994 
12995  if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem ||
12996  draggable.element ) ) ) {
12997  this._addHoverClass();
12998  this._trigger( "over", event, this.ui( draggable ) );
12999  }
13000 
13001  },
13002 
13003  _out: function( event ) {
13004 
13005  var draggable = $.ui.ddmanager.current;
13006 
13007  // Bail if draggable and droppable are same element
13008  if ( !draggable || ( draggable.currentItem ||
13009  draggable.element )[ 0 ] === this.element[ 0 ] ) {
13010  return;
13011  }
13012 
13013  if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem ||
13014  draggable.element ) ) ) {
13015  this._removeHoverClass();
13016  this._trigger( "out", event, this.ui( draggable ) );
13017  }
13018 
13019  },
13020 
13021  _drop: function( event, custom ) {
13022 
13023  var draggable = custom || $.ui.ddmanager.current,
13024  childrenIntersection = false;
13025 
13026  // Bail if draggable and droppable are same element
13027  if ( !draggable || ( draggable.currentItem ||
13028  draggable.element )[ 0 ] === this.element[ 0 ] ) {
13029  return false;
13030  }
13031 
13032  this.element
13033  .find( ":data(ui-droppable)" )
13034  .not( ".ui-draggable-dragging" )
13035  .each( function() {
13036  var inst = $( this ).droppable( "instance" );
13037  if (
13038  inst.options.greedy &&
13039  !inst.options.disabled &&
13040  inst.options.scope === draggable.options.scope &&
13041  inst.accept.call(
13042  inst.element[ 0 ], ( draggable.currentItem || draggable.element )
13043  ) &&
13044  intersect(
13045  draggable,
13046  $.extend( inst, { offset: inst.element.offset() } ),
13047  inst.options.tolerance, event
13048  )
13049  ) {
13050  childrenIntersection = true;
13051  return false; }
13052  } );
13053  if ( childrenIntersection ) {
13054  return false;
13055  }
13056 
13057  if ( this.accept.call( this.element[ 0 ],
13058  ( draggable.currentItem || draggable.element ) ) ) {
13059  this._removeActiveClass();
13060  this._removeHoverClass();
13061 
13062  this._trigger( "drop", event, this.ui( draggable ) );
13063  return this.element;
13064  }
13065 
13066  return false;
13067 
13068  },
13069 
13070  ui: function( c ) {
13071  return {
13072  draggable: ( c.currentItem || c.element ),
13073  helper: c.helper,
13074  position: c.position,
13075  offset: c.positionAbs
13076  };
13077  },
13078 
13079  // Extension points just to make backcompat sane and avoid duplicating logic
13080  // TODO: Remove in 1.13 along with call to it below
13081  _addHoverClass: function() {
13082  this._addClass( "ui-droppable-hover" );
13083  },
13084 
13085  _removeHoverClass: function() {
13086  this._removeClass( "ui-droppable-hover" );
13087  },
13088 
13089  _addActiveClass: function() {
13090  this._addClass( "ui-droppable-active" );
13091  },
13092 
13093  _removeActiveClass: function() {
13094  this._removeClass( "ui-droppable-active" );
13095  }
13096 } );
13097 
13098 var intersect = $.ui.intersect = ( function() {
13099  function isOverAxis( x, reference, size ) {
13100  return ( x >= reference ) && ( x < ( reference + size ) );
13101  }
13102 
13103  return function( draggable, droppable, toleranceMode, event ) {
13104 
13105  if ( !droppable.offset ) {
13106  return false;
13107  }
13108 
13109  var x1 = ( draggable.positionAbs ||
13110  draggable.position.absolute ).left + draggable.margins.left,
13111  y1 = ( draggable.positionAbs ||
13112  draggable.position.absolute ).top + draggable.margins.top,
13113  x2 = x1 + draggable.helperProportions.width,
13114  y2 = y1 + draggable.helperProportions.height,
13115  l = droppable.offset.left,
13116  t = droppable.offset.top,
13117  r = l + droppable.proportions().width,
13118  b = t + droppable.proportions().height;
13119 
13120  switch ( toleranceMode ) {
13121  case "fit":
13122  return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
13123  case "intersect":
13124  return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
13125  x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
13126  t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
13127  y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
13128  case "pointer":
13129  return isOverAxis( event.pageY, t, droppable.proportions().height ) &&
13130  isOverAxis( event.pageX, l, droppable.proportions().width );
13131  case "touch":
13132  return (
13133  ( y1 >= t && y1 <= b ) || // Top edge touching
13134  ( y2 >= t && y2 <= b ) || // Bottom edge touching
13135  ( y1 < t && y2 > b ) // Surrounded vertically
13136  ) && (
13137  ( x1 >= l && x1 <= r ) || // Left edge touching
13138  ( x2 >= l && x2 <= r ) || // Right edge touching
13139  ( x1 < l && x2 > r ) // Surrounded horizontally
13140  );
13141  default:
13142  return false;
13143  }
13144  };
13145 } )();
13146 
13147 /*
13148  This manager tracks offsets of draggables and droppables
13149 */
13150 $.ui.ddmanager = {
13151  current: null,
13152  droppables: { "default": [] },
13153  prepareOffsets: function( t, event ) {
13154 
13155  var i, j,
13156  m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
13157  type = event ? event.type : null, // workaround for #2317
13158  list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
13159 
13160  droppablesLoop: for ( i = 0; i < m.length; i++ ) {
13161 
13162  // No disabled and non-accepted
13163  if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ],
13164  ( t.currentItem || t.element ) ) ) ) {
13165  continue;
13166  }
13167 
13168  // Filter out elements in the current dragged item
13169  for ( j = 0; j < list.length; j++ ) {
13170  if ( list[ j ] === m[ i ].element[ 0 ] ) {
13171  m[ i ].proportions().height = 0;
13172  continue droppablesLoop;
13173  }
13174  }
13175 
13176  m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
13177  if ( !m[ i ].visible ) {
13178  continue;
13179  }
13180 
13181  // Activate the droppable if used directly from draggables
13182  if ( type === "mousedown" ) {
13183  m[ i ]._activate.call( m[ i ], event );
13184  }
13185 
13186  m[ i ].offset = m[ i ].element.offset();
13187  m[ i ].proportions( {
13188  width: m[ i ].element[ 0 ].offsetWidth,
13189  height: m[ i ].element[ 0 ].offsetHeight
13190  } );
13191 
13192  }
13193 
13194  },
13195  drop: function( draggable, event ) {
13196 
13197  var dropped = false;
13198 
13199  // Create a copy of the droppables in case the list changes during the drop (#9116)
13200  $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
13201 
13202  if ( !this.options ) {
13203  return;
13204  }
13205  if ( !this.options.disabled && this.visible &&
13206  intersect( draggable, this, this.options.tolerance, event ) ) {
13207  dropped = this._drop.call( this, event ) || dropped;
13208  }
13209 
13210  if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ],
13211  ( draggable.currentItem || draggable.element ) ) ) {
13212  this.isout = true;
13213  this.isover = false;
13214  this._deactivate.call( this, event );
13215  }
13216 
13217  } );
13218  return dropped;
13219 
13220  },
13221  dragStart: function( draggable, event ) {
13222 
13223  // Listen for scrolling so that if the dragging causes scrolling the position of the
13224  // droppables can be recalculated (see #5003)
13225  draggable.element.parentsUntil( "body" ).on( "scroll.droppable", function() {
13226  if ( !draggable.options.refreshPositions ) {
13227  $.ui.ddmanager.prepareOffsets( draggable, event );
13228  }
13229  } );
13230  },
13231  drag: function( draggable, event ) {
13232 
13233  // If you have a highly dynamic page, you might try this option. It renders positions
13234  // every time you move the mouse.
13235  if ( draggable.options.refreshPositions ) {
13236  $.ui.ddmanager.prepareOffsets( draggable, event );
13237  }
13238 
13239  // Run through all droppables and check their positions based on specific tolerance options
13240  $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
13241 
13242  if ( this.options.disabled || this.greedyChild || !this.visible ) {
13243  return;
13244  }
13245 
13246  var parentInstance, scope, parent,
13247  intersects = intersect( draggable, this, this.options.tolerance, event ),
13248  c = !intersects && this.isover ?
13249  "isout" :
13250  ( intersects && !this.isover ? "isover" : null );
13251  if ( !c ) {
13252  return;
13253  }
13254 
13255  if ( this.options.greedy ) {
13256 
13257  // find droppable parents with same scope
13258  scope = this.options.scope;
13259  parent = this.element.parents( ":data(ui-droppable)" ).filter( function() {
13260  return $( this ).droppable( "instance" ).options.scope === scope;
13261  } );
13262 
13263  if ( parent.length ) {
13264  parentInstance = $( parent[ 0 ] ).droppable( "instance" );
13265  parentInstance.greedyChild = ( c === "isover" );
13266  }
13267  }
13268 
13269  // We just moved into a greedy child
13270  if ( parentInstance && c === "isover" ) {
13271  parentInstance.isover = false;
13272  parentInstance.isout = true;
13273  parentInstance._out.call( parentInstance, event );
13274  }
13275 
13276  this[ c ] = true;
13277  this[ c === "isout" ? "isover" : "isout" ] = false;
13278  this[ c === "isover" ? "_over" : "_out" ].call( this, event );
13279 
13280  // We just moved out of a greedy child
13281  if ( parentInstance && c === "isout" ) {
13282  parentInstance.isout = false;
13283  parentInstance.isover = true;
13284  parentInstance._over.call( parentInstance, event );
13285  }
13286  } );
13287 
13288  },
13289  dragStop: function( draggable, event ) {
13290  draggable.element.parentsUntil( "body" ).off( "scroll.droppable" );
13291 
13292  // Call prepareOffsets one final time since IE does not fire return scroll events when
13293  // overflow was caused by drag (see #5003)
13294  if ( !draggable.options.refreshPositions ) {
13295  $.ui.ddmanager.prepareOffsets( draggable, event );
13296  }
13297  }
13298 };
13299 
13300 // DEPRECATED
13301 // TODO: switch return back to widget declaration at top of file when this is removed
13302 if ( $.uiBackCompat !== false ) {
13303 
13304  // Backcompat for activeClass and hoverClass options
13305  $.widget( "ui.droppable", $.ui.droppable, {
13306  options: {
13307  hoverClass: false,
13308  activeClass: false
13309  },
13310  _addActiveClass: function() {
13311  this._super();
13312  if ( this.options.activeClass ) {
13313  this.element.addClass( this.options.activeClass );
13314  }
13315  },
13316  _removeActiveClass: function() {
13317  this._super();
13318  if ( this.options.activeClass ) {
13319  this.element.removeClass( this.options.activeClass );
13320  }
13321  },
13322  _addHoverClass: function() {
13323  this._super();
13324  if ( this.options.hoverClass ) {
13325  this.element.addClass( this.options.hoverClass );
13326  }
13327  },
13328  _removeHoverClass: function() {
13329  this._super();
13330  if ( this.options.hoverClass ) {
13331  this.element.removeClass( this.options.hoverClass );
13332  }
13333  }
13334  } );
13335 }
13336 
13337 var widgetsDroppable = $.ui.droppable;
13338 
13339 
13340 /*!
13341  * jQuery UI Progressbar 1.12.1
13342  * http://jqueryui.com
13343  *
13344  * Copyright jQuery Foundation and other contributors
13345  * Released under the MIT license.
13346  * http://jquery.org/license
13347  */
13348 
13349 //>>label: Progressbar
13350 //>>group: Widgets
13351 // jscs:disable maximumLineLength
13352 //>>description: Displays a status indicator for loading state, standard percentage, and other progress indicators.
13353 // jscs:enable maximumLineLength
13354 //>>docs: http://api.jqueryui.com/progressbar/
13355 //>>demos: http://jqueryui.com/progressbar/
13356 //>>css.structure: ../../themes/base/core.css
13357 //>>css.structure: ../../themes/base/progressbar.css
13358 //>>css.theme: ../../themes/base/theme.css
13359 
13360 
13361 
13362 var widgetsProgressbar = $.widget( "ui.progressbar", {
13363  version: "1.12.1",
13364  options: {
13365  classes: {
13366  "ui-progressbar": "ui-corner-all",
13367  "ui-progressbar-value": "ui-corner-left",
13368  "ui-progressbar-complete": "ui-corner-right"
13369  },
13370  max: 100,
13371  value: 0,
13372 
13373  change: null,
13374  complete: null
13375  },
13376 
13377  min: 0,
13378 
13379  _create: function() {
13380 
13381  // Constrain initial value
13382  this.oldValue = this.options.value = this._constrainedValue();
13383 
13384  this.element.attr( {
13385 
13386  // Only set static values; aria-valuenow and aria-valuemax are
13387  // set inside _refreshValue()
13388  role: "progressbar",
13389  "aria-valuemin": this.min
13390  } );
13391  this._addClass( "ui-progressbar", "ui-widget ui-widget-content" );
13392 
13393  this.valueDiv = $( "<div>" ).appendTo( this.element );
13394  this._addClass( this.valueDiv, "ui-progressbar-value", "ui-widget-header" );
13395  this._refreshValue();
13396  },
13397 
13398  _destroy: function() {
13399  this.element.removeAttr( "role aria-valuemin aria-valuemax aria-valuenow" );
13400 
13401  this.valueDiv.remove();
13402  },
13403 
13404  value: function( newValue ) {
13405  if ( newValue === undefined ) {
13406  return this.options.value;
13407  }
13408 
13409  this.options.value = this._constrainedValue( newValue );
13410  this._refreshValue();
13411  },
13412 
13413  _constrainedValue: function( newValue ) {
13414  if ( newValue === undefined ) {
13415  newValue = this.options.value;
13416  }
13417 
13418  this.indeterminate = newValue === false;
13419 
13420  // Sanitize value
13421  if ( typeof newValue !== "number" ) {
13422  newValue = 0;
13423  }
13424 
13425  return this.indeterminate ? false :
13426  Math.min( this.options.max, Math.max( this.min, newValue ) );
13427  },
13428 
13429  _setOptions: function( options ) {
13430 
13431  // Ensure "value" option is set after other values (like max)
13432  var value = options.value;
13433  delete options.value;
13434 
13435  this._super( options );
13436 
13437  this.options.value = this._constrainedValue( value );
13438  this._refreshValue();
13439  },
13440 
13441  _setOption: function( key, value ) {
13442  if ( key === "max" ) {
13443 
13444  // Don't allow a max less than min
13445  value = Math.max( this.min, value );
13446  }
13447  this._super( key, value );
13448  },
13449 
13450  _setOptionDisabled: function( value ) {
13451  this._super( value );
13452 
13453  this.element.attr( "aria-disabled", value );
13454  this._toggleClass( null, "ui-state-disabled", !!value );
13455  },
13456 
13457  _percentage: function() {
13458  return this.indeterminate ?
13459  100 :
13460  100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
13461  },
13462 
13463  _refreshValue: function() {
13464  var value = this.options.value,
13465  percentage = this._percentage();
13466 
13467  this.valueDiv
13468  .toggle( this.indeterminate || value > this.min )
13469  .width( percentage.toFixed( 0 ) + "%" );
13470 
13471  this
13472  ._toggleClass( this.valueDiv, "ui-progressbar-complete", null,
13473  value === this.options.max )
13474  ._toggleClass( "ui-progressbar-indeterminate", null, this.indeterminate );
13475 
13476  if ( this.indeterminate ) {
13477  this.element.removeAttr( "aria-valuenow" );
13478  if ( !this.overlayDiv ) {
13479  this.overlayDiv = $( "<div>" ).appendTo( this.valueDiv );
13480  this._addClass( this.overlayDiv, "ui-progressbar-overlay" );
13481  }
13482  } else {
13483  this.element.attr( {
13484  "aria-valuemax": this.options.max,
13485  "aria-valuenow": value
13486  } );
13487  if ( this.overlayDiv ) {
13488  this.overlayDiv.remove();
13489  this.overlayDiv = null;
13490  }
13491  }
13492 
13493  if ( this.oldValue !== value ) {
13494  this.oldValue = value;
13495  this._trigger( "change" );
13496  }
13497  if ( value === this.options.max ) {
13498  this._trigger( "complete" );
13499  }
13500  }
13501 } );
13502 
13503 
13504 /*!
13505  * jQuery UI Selectable 1.12.1
13506  * http://jqueryui.com
13507  *
13508  * Copyright jQuery Foundation and other contributors
13509  * Released under the MIT license.
13510  * http://jquery.org/license
13511  */
13512 
13513 //>>label: Selectable
13514 //>>group: Interactions
13515 //>>description: Allows groups of elements to be selected with the mouse.
13516 //>>docs: http://api.jqueryui.com/selectable/
13517 //>>demos: http://jqueryui.com/selectable/
13518 //>>css.structure: ../../themes/base/selectable.css
13519 
13520 
13521 
13522 var widgetsSelectable = $.widget( "ui.selectable", $.ui.mouse, {
13523  version: "1.12.1",
13524  options: {
13525  appendTo: "body",
13526  autoRefresh: true,
13527  distance: 0,
13528  filter: "*",
13529  tolerance: "touch",
13530 
13531  // Callbacks
13532  selected: null,
13533  selecting: null,
13534  start: null,
13535  stop: null,
13536  unselected: null,
13537  unselecting: null
13538  },
13539  _create: function() {
13540  var that = this;
13541 
13542  this._addClass( "ui-selectable" );
13543 
13544  this.dragged = false;
13545 
13546  // Cache selectee children based on filter
13547  this.refresh = function() {
13548  that.elementPos = $( that.element[ 0 ] ).offset();
13549  that.selectees = $( that.options.filter, that.element[ 0 ] );
13550  that._addClass( that.selectees, "ui-selectee" );
13551  that.selectees.each( function() {
13552  var $this = $( this ),
13553  selecteeOffset = $this.offset(),
13554  pos = {
13555  left: selecteeOffset.left - that.elementPos.left,
13556  top: selecteeOffset.top - that.elementPos.top
13557  };
13558  $.data( this, "selectable-item", {
13559  element: this,
13560  $element: $this,
13561  left: pos.left,
13562  top: pos.top,
13563  right: pos.left + $this.outerWidth(),
13564  bottom: pos.top + $this.outerHeight(),
13565  startselected: false,
13566  selected: $this.hasClass( "ui-selected" ),
13567  selecting: $this.hasClass( "ui-selecting" ),
13568  unselecting: $this.hasClass( "ui-unselecting" )
13569  } );
13570  } );
13571  };
13572  this.refresh();
13573 
13574  this._mouseInit();
13575 
13576  this.helper = $( "<div>" );
13577  this._addClass( this.helper, "ui-selectable-helper" );
13578  },
13579 
13580  _destroy: function() {
13581  this.selectees.removeData( "selectable-item" );
13582  this._mouseDestroy();
13583  },
13584 
13585  _mouseStart: function( event ) {
13586  var that = this,
13587  options = this.options;
13588 
13589  this.opos = [ event.pageX, event.pageY ];
13590  this.elementPos = $( this.element[ 0 ] ).offset();
13591 
13592  if ( this.options.disabled ) {
13593  return;
13594  }
13595 
13596  this.selectees = $( options.filter, this.element[ 0 ] );
13597 
13598  this._trigger( "start", event );
13599 
13600  $( options.appendTo ).append( this.helper );
13601 
13602  // position helper (lasso)
13603  this.helper.css( {
13604  "left": event.pageX,
13605  "top": event.pageY,
13606  "width": 0,
13607  "height": 0
13608  } );
13609 
13610  if ( options.autoRefresh ) {
13611  this.refresh();
13612  }
13613 
13614  this.selectees.filter( ".ui-selected" ).each( function() {
13615  var selectee = $.data( this, "selectable-item" );
13616  selectee.startselected = true;
13617  if ( !event.metaKey && !event.ctrlKey ) {
13618  that._removeClass( selectee.$element, "ui-selected" );
13619  selectee.selected = false;
13620  that._addClass( selectee.$element, "ui-unselecting" );
13621  selectee.unselecting = true;
13622 
13623  // selectable UNSELECTING callback
13624  that._trigger( "unselecting", event, {
13625  unselecting: selectee.element
13626  } );
13627  }
13628  } );
13629 
13630  $( event.target ).parents().addBack().each( function() {
13631  var doSelect,
13632  selectee = $.data( this, "selectable-item" );
13633  if ( selectee ) {
13634  doSelect = ( !event.metaKey && !event.ctrlKey ) ||
13635  !selectee.$element.hasClass( "ui-selected" );
13636  that._removeClass( selectee.$element, doSelect ? "ui-unselecting" : "ui-selected" )
13637  ._addClass( selectee.$element, doSelect ? "ui-selecting" : "ui-unselecting" );
13638  selectee.unselecting = !doSelect;
13639  selectee.selecting = doSelect;
13640  selectee.selected = doSelect;
13641 
13642  // selectable (UN)SELECTING callback
13643  if ( doSelect ) {
13644  that._trigger( "selecting", event, {
13645  selecting: selectee.element
13646  } );
13647  } else {
13648  that._trigger( "unselecting", event, {
13649  unselecting: selectee.element
13650  } );
13651  }
13652  return false;
13653  }
13654  } );
13655 
13656  },
13657 
13658  _mouseDrag: function( event ) {
13659 
13660  this.dragged = true;
13661 
13662  if ( this.options.disabled ) {
13663  return;
13664  }
13665 
13666  var tmp,
13667  that = this,
13668  options = this.options,
13669  x1 = this.opos[ 0 ],
13670  y1 = this.opos[ 1 ],
13671  x2 = event.pageX,
13672  y2 = event.pageY;
13673 
13674  if ( x1 > x2 ) { tmp = x2; x2 = x1; x1 = tmp; }
13675  if ( y1 > y2 ) { tmp = y2; y2 = y1; y1 = tmp; }
13676  this.helper.css( { left: x1, top: y1, width: x2 - x1, height: y2 - y1 } );
13677 
13678  this.selectees.each( function() {
13679  var selectee = $.data( this, "selectable-item" ),
13680  hit = false,
13681  offset = {};
13682 
13683  //prevent helper from being selected if appendTo: selectable
13684  if ( !selectee || selectee.element === that.element[ 0 ] ) {
13685  return;
13686  }
13687 
13688  offset.left = selectee.left + that.elementPos.left;
13689  offset.right = selectee.right + that.elementPos.left;
13690  offset.top = selectee.top + that.elementPos.top;
13691  offset.bottom = selectee.bottom + that.elementPos.top;
13692 
13693  if ( options.tolerance === "touch" ) {
13694  hit = ( !( offset.left > x2 || offset.right < x1 || offset.top > y2 ||
13695  offset.bottom < y1 ) );
13696  } else if ( options.tolerance === "fit" ) {
13697  hit = ( offset.left > x1 && offset.right < x2 && offset.top > y1 &&
13698  offset.bottom < y2 );
13699  }
13700 
13701  if ( hit ) {
13702 
13703  // SELECT
13704  if ( selectee.selected ) {
13705  that._removeClass( selectee.$element, "ui-selected" );
13706  selectee.selected = false;
13707  }
13708  if ( selectee.unselecting ) {
13709  that._removeClass( selectee.$element, "ui-unselecting" );
13710  selectee.unselecting = false;
13711  }
13712  if ( !selectee.selecting ) {
13713  that._addClass( selectee.$element, "ui-selecting" );
13714  selectee.selecting = true;
13715 
13716  // selectable SELECTING callback
13717  that._trigger( "selecting", event, {
13718  selecting: selectee.element
13719  } );
13720  }
13721  } else {
13722 
13723  // UNSELECT
13724  if ( selectee.selecting ) {
13725  if ( ( event.metaKey || event.ctrlKey ) && selectee.startselected ) {
13726  that._removeClass( selectee.$element, "ui-selecting" );
13727  selectee.selecting = false;
13728  that._addClass( selectee.$element, "ui-selected" );
13729  selectee.selected = true;
13730  } else {
13731  that._removeClass( selectee.$element, "ui-selecting" );
13732  selectee.selecting = false;
13733  if ( selectee.startselected ) {
13734  that._addClass( selectee.$element, "ui-unselecting" );
13735  selectee.unselecting = true;
13736  }
13737 
13738  // selectable UNSELECTING callback
13739  that._trigger( "unselecting", event, {
13740  unselecting: selectee.element
13741  } );
13742  }
13743  }
13744  if ( selectee.selected ) {
13745  if ( !event.metaKey && !event.ctrlKey && !selectee.startselected ) {
13746  that._removeClass( selectee.$element, "ui-selected" );
13747  selectee.selected = false;
13748 
13749  that._addClass( selectee.$element, "ui-unselecting" );
13750  selectee.unselecting = true;
13751 
13752  // selectable UNSELECTING callback
13753  that._trigger( "unselecting", event, {
13754  unselecting: selectee.element
13755  } );
13756  }
13757  }
13758  }
13759  } );
13760 
13761  return false;
13762  },
13763 
13764  _mouseStop: function( event ) {
13765  var that = this;
13766 
13767  this.dragged = false;
13768 
13769  $( ".ui-unselecting", this.element[ 0 ] ).each( function() {
13770  var selectee = $.data( this, "selectable-item" );
13771  that._removeClass( selectee.$element, "ui-unselecting" );
13772  selectee.unselecting = false;
13773  selectee.startselected = false;
13774  that._trigger( "unselected", event, {
13775  unselected: selectee.element
13776  } );
13777  } );
13778  $( ".ui-selecting", this.element[ 0 ] ).each( function() {
13779  var selectee = $.data( this, "selectable-item" );
13780  that._removeClass( selectee.$element, "ui-selecting" )
13781  ._addClass( selectee.$element, "ui-selected" );
13782  selectee.selecting = false;
13783  selectee.selected = true;
13784  selectee.startselected = true;
13785  that._trigger( "selected", event, {
13786  selected: selectee.element
13787  } );
13788  } );
13789  this._trigger( "stop", event );
13790 
13791  this.helper.remove();
13792 
13793  return false;
13794  }
13795 
13796 } );
13797 
13798 
13799 /*!
13800  * jQuery UI Selectmenu 1.12.1
13801  * http://jqueryui.com
13802  *
13803  * Copyright jQuery Foundation and other contributors
13804  * Released under the MIT license.
13805  * http://jquery.org/license
13806  */
13807 
13808 //>>label: Selectmenu
13809 //>>group: Widgets
13810 // jscs:disable maximumLineLength
13811 //>>description: Duplicates and extends the functionality of a native HTML select element, allowing it to be customizable in behavior and appearance far beyond the limitations of a native select.
13812 // jscs:enable maximumLineLength
13813 //>>docs: http://api.jqueryui.com/selectmenu/
13814 //>>demos: http://jqueryui.com/selectmenu/
13815 //>>css.structure: ../../themes/base/core.css
13816 //>>css.structure: ../../themes/base/selectmenu.css, ../../themes/base/button.css
13817 //>>css.theme: ../../themes/base/theme.css
13818 
13819 
13820 
13821 var widgetsSelectmenu = $.widget( "ui.selectmenu", [ $.ui.formResetMixin, {
13822  version: "1.12.1",
13823  defaultElement: "<select>",
13824  options: {
13825  appendTo: null,
13826  classes: {
13827  "ui-selectmenu-button-open": "ui-corner-top",
13828  "ui-selectmenu-button-closed": "ui-corner-all"
13829  },
13830  disabled: null,
13831  icons: {
13832  button: "ui-icon-triangle-1-s"
13833  },
13834  position: {
13835  my: "left top",
13836  at: "left bottom",
13837  collision: "none"
13838  },
13839  width: false,
13840 
13841  // Callbacks
13842  change: null,
13843  close: null,
13844  focus: null,
13845  open: null,
13846  select: null
13847  },
13848 
13849  _create: function() {
13850  var selectmenuId = this.element.uniqueId().attr( "id" );
13851  this.ids = {
13852  element: selectmenuId,
13853  button: selectmenuId + "-button",
13854  menu: selectmenuId + "-menu"
13855  };
13856 
13857  this._drawButton();
13858  this._drawMenu();
13859  this._bindFormResetHandler();
13860 
13861  this._rendered = false;
13862  this.menuItems = $();
13863  },
13864 
13865  _drawButton: function() {
13866  var icon,
13867  that = this,
13868  item = this._parseOption(
13869  this.element.find( "option:selected" ),
13870  this.element[ 0 ].selectedIndex
13871  );
13872 
13873  // Associate existing label with the new button
13874  this.labels = this.element.labels().attr( "for", this.ids.button );
13875  this._on( this.labels, {
13876  click: function( event ) {
13877  this.button.focus();
13878  event.preventDefault();
13879  }
13880  } );
13881 
13882  // Hide original select element
13883  this.element.hide();
13884 
13885  // Create button
13886  this.button = $( "<span>", {
13887  tabindex: this.options.disabled ? -1 : 0,
13888  id: this.ids.button,
13889  role: "combobox",
13890  "aria-expanded": "false",
13891  "aria-autocomplete": "list",
13892  "aria-owns": this.ids.menu,
13893  "aria-haspopup": "true",
13894  title: this.element.attr( "title" )
13895  } )
13896  .insertAfter( this.element );
13897 
13898  this._addClass( this.button, "ui-selectmenu-button ui-selectmenu-button-closed",
13899  "ui-button ui-widget" );
13900 
13901  icon = $( "<span>" ).appendTo( this.button );
13902  this._addClass( icon, "ui-selectmenu-icon", "ui-icon " + this.options.icons.button );
13903  this.buttonItem = this._renderButtonItem( item )
13904  .appendTo( this.button );
13905 
13906  if ( this.options.width !== false ) {
13907  this._resizeButton();
13908  }
13909 
13910  this._on( this.button, this._buttonEvents );
13911  this.button.one( "focusin", function() {
13912 
13913  // Delay rendering the menu items until the button receives focus.
13914  // The menu may have already been rendered via a programmatic open.
13915  if ( !that._rendered ) {
13916  that._refreshMenu();
13917  }
13918  } );
13919  },
13920 
13921  _drawMenu: function() {
13922  var that = this;
13923 
13924  // Create menu
13925  this.menu = $( "<ul>", {
13926  "aria-hidden": "true",
13927  "aria-labelledby": this.ids.button,
13928  id: this.ids.menu
13929  } );
13930 
13931  // Wrap menu
13932  this.menuWrap = $( "<div>" ).append( this.menu );
13933  this._addClass( this.menuWrap, "ui-selectmenu-menu", "ui-front" );
13934  this.menuWrap.appendTo( this._appendTo() );
13935 
13936  // Initialize menu widget
13937  this.menuInstance = this.menu
13938  .menu( {
13939  classes: {
13940  "ui-menu": "ui-corner-bottom"
13941  },
13942  role: "listbox",
13943  select: function( event, ui ) {
13944  event.preventDefault();
13945 
13946  // Support: IE8
13947  // If the item was selected via a click, the text selection
13948  // will be destroyed in IE
13949  that._setSelection();
13950 
13951  that._select( ui.item.data( "ui-selectmenu-item" ), event );
13952  },
13953  focus: function( event, ui ) {
13954  var item = ui.item.data( "ui-selectmenu-item" );
13955 
13956  // Prevent inital focus from firing and check if its a newly focused item
13957  if ( that.focusIndex != null && item.index !== that.focusIndex ) {
13958  that._trigger( "focus", event, { item: item } );
13959  if ( !that.isOpen ) {
13960  that._select( item, event );
13961  }
13962  }
13963  that.focusIndex = item.index;
13964 
13965  that.button.attr( "aria-activedescendant",
13966  that.menuItems.eq( item.index ).attr( "id" ) );
13967  }
13968  } )
13969  .menu( "instance" );
13970 
13971  // Don't close the menu on mouseleave
13972  this.menuInstance._off( this.menu, "mouseleave" );
13973 
13974  // Cancel the menu's collapseAll on document click
13975  this.menuInstance._closeOnDocumentClick = function() {
13976  return false;
13977  };
13978 
13979  // Selects often contain empty items, but never contain dividers
13980  this.menuInstance._isDivider = function() {
13981  return false;
13982  };
13983  },
13984 
13985  refresh: function() {
13986  this._refreshMenu();
13987  this.buttonItem.replaceWith(
13988  this.buttonItem = this._renderButtonItem(
13989 
13990  // Fall back to an empty object in case there are no options
13991  this._getSelectedItem().data( "ui-selectmenu-item" ) || {}
13992  )
13993  );
13994  if ( this.options.width === null ) {
13995  this._resizeButton();
13996  }
13997  },
13998 
13999  _refreshMenu: function() {
14000  var item,
14001  options = this.element.find( "option" );
14002 
14003  this.menu.empty();
14004 
14005  this._parseOptions( options );
14006  this._renderMenu( this.menu, this.items );
14007 
14008  this.menuInstance.refresh();
14009  this.menuItems = this.menu.find( "li" )
14010  .not( ".ui-selectmenu-optgroup" )
14011  .find( ".ui-menu-item-wrapper" );
14012 
14013  this._rendered = true;
14014 
14015  if ( !options.length ) {
14016  return;
14017  }
14018 
14019  item = this._getSelectedItem();
14020 
14021  // Update the menu to have the correct item focused
14022  this.menuInstance.focus( null, item );
14023  this._setAria( item.data( "ui-selectmenu-item" ) );
14024 
14025  // Set disabled state
14026  this._setOption( "disabled", this.element.prop( "disabled" ) );
14027  },
14028 
14029  open: function( event ) {
14030  if ( this.options.disabled ) {
14031  return;
14032  }
14033 
14034  // If this is the first time the menu is being opened, render the items
14035  if ( !this._rendered ) {
14036  this._refreshMenu();
14037  } else {
14038 
14039  // Menu clears focus on close, reset focus to selected item
14040  this._removeClass( this.menu.find( ".ui-state-active" ), null, "ui-state-active" );
14041  this.menuInstance.focus( null, this._getSelectedItem() );
14042  }
14043 
14044  // If there are no options, don't open the menu
14045  if ( !this.menuItems.length ) {
14046  return;
14047  }
14048 
14049  this.isOpen = true;
14050  this._toggleAttr();
14051  this._resizeMenu();
14052  this._position();
14053 
14054  this._on( this.document, this._documentClick );
14055 
14056  this._trigger( "open", event );
14057  },
14058 
14059  _position: function() {
14060  this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) );
14061  },
14062 
14063  close: function( event ) {
14064  if ( !this.isOpen ) {
14065  return;
14066  }
14067 
14068  this.isOpen = false;
14069  this._toggleAttr();
14070 
14071  this.range = null;
14072  this._off( this.document );
14073 
14074  this._trigger( "close", event );
14075  },
14076 
14077  widget: function() {
14078  return this.button;
14079  },
14080 
14081  menuWidget: function() {
14082  return this.menu;
14083  },
14084 
14085  _renderButtonItem: function( item ) {
14086  var buttonItem = $( "<span>" );
14087 
14088  this._setText( buttonItem, item.label );
14089  this._addClass( buttonItem, "ui-selectmenu-text" );
14090 
14091  return buttonItem;
14092  },
14093 
14094  _renderMenu: function( ul, items ) {
14095  var that = this,
14096  currentOptgroup = "";
14097 
14098  $.each( items, function( index, item ) {
14099  var li;
14100 
14101  if ( item.optgroup !== currentOptgroup ) {
14102  li = $( "<li>", {
14103  text: item.optgroup
14104  } );
14105  that._addClass( li, "ui-selectmenu-optgroup", "ui-menu-divider" +
14106  ( item.element.parent( "optgroup" ).prop( "disabled" ) ?
14107  " ui-state-disabled" :
14108  "" ) );
14109 
14110  li.appendTo( ul );
14111 
14112  currentOptgroup = item.optgroup;
14113  }
14114 
14115  that._renderItemData( ul, item );
14116  } );
14117  },
14118 
14119  _renderItemData: function( ul, item ) {
14120  return this._renderItem( ul, item ).data( "ui-selectmenu-item", item );
14121  },
14122 
14123  _renderItem: function( ul, item ) {
14124  var li = $( "<li>" ),
14125  wrapper = $( "<div>", {
14126  title: item.element.attr( "title" )
14127  } );
14128 
14129  if ( item.disabled ) {
14130  this._addClass( li, null, "ui-state-disabled" );
14131  }
14132  this._setText( wrapper, item.label );
14133 
14134  return li.append( wrapper ).appendTo( ul );
14135  },
14136 
14137  _setText: function( element, value ) {
14138  if ( value ) {
14139  element.text( value );
14140  } else {
14141  element.html( "&#160;" );
14142  }
14143  },
14144 
14145  _move: function( direction, event ) {
14146  var item, next,
14147  filter = ".ui-menu-item";
14148 
14149  if ( this.isOpen ) {
14150  item = this.menuItems.eq( this.focusIndex ).parent( "li" );
14151  } else {
14152  item = this.menuItems.eq( this.element[ 0 ].selectedIndex ).parent( "li" );
14153  filter += ":not(.ui-state-disabled)";
14154  }
14155 
14156  if ( direction === "first" || direction === "last" ) {
14157  next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 );
14158  } else {
14159  next = item[ direction + "All" ]( filter ).eq( 0 );
14160  }
14161 
14162  if ( next.length ) {
14163  this.menuInstance.focus( event, next );
14164  }
14165  },
14166 
14167  _getSelectedItem: function() {
14168  return this.menuItems.eq( this.element[ 0 ].selectedIndex ).parent( "li" );
14169  },
14170 
14171  _toggle: function( event ) {
14172  this[ this.isOpen ? "close" : "open" ]( event );
14173  },
14174 
14175  _setSelection: function() {
14176  var selection;
14177 
14178  if ( !this.range ) {
14179  return;
14180  }
14181 
14182  if ( window.getSelection ) {
14183  selection = window.getSelection();
14184  selection.removeAllRanges();
14185  selection.addRange( this.range );
14186 
14187  // Support: IE8
14188  } else {
14189  this.range.select();
14190  }
14191 
14192  // Support: IE
14193  // Setting the text selection kills the button focus in IE, but
14194  // restoring the focus doesn't kill the selection.
14195  this.button.focus();
14196  },
14197 
14198  _documentClick: {
14199  mousedown: function( event ) {
14200  if ( !this.isOpen ) {
14201  return;
14202  }
14203 
14204  if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" +
14205  $.ui.escapeSelector( this.ids.button ) ).length ) {
14206  this.close( event );
14207  }
14208  }
14209  },
14210 
14211  _buttonEvents: {
14212 
14213  // Prevent text selection from being reset when interacting with the selectmenu (#10144)
14214  mousedown: function() {
14215  var selection;
14216 
14217  if ( window.getSelection ) {
14218  selection = window.getSelection();
14219  if ( selection.rangeCount ) {
14220  this.range = selection.getRangeAt( 0 );
14221  }
14222 
14223  // Support: IE8
14224  } else {
14225  this.range = document.selection.createRange();
14226  }
14227  },
14228 
14229  click: function( event ) {
14230  this._setSelection();
14231  this._toggle( event );
14232  },
14233 
14234  keydown: function( event ) {
14235  var preventDefault = true;
14236  switch ( event.keyCode ) {
14237  case $.ui.keyCode.TAB:
14238  case $.ui.keyCode.ESCAPE:
14239  this.close( event );
14240  preventDefault = false;
14241  break;
14242  case $.ui.keyCode.ENTER:
14243  if ( this.isOpen ) {
14244  this._selectFocusedItem( event );
14245  }
14246  break;
14247  case $.ui.keyCode.UP:
14248  if ( event.altKey ) {
14249  this._toggle( event );
14250  } else {
14251  this._move( "prev", event );
14252  }
14253  break;
14254  case $.ui.keyCode.DOWN:
14255  if ( event.altKey ) {
14256  this._toggle( event );
14257  } else {
14258  this._move( "next", event );
14259  }
14260  break;
14261  case $.ui.keyCode.SPACE:
14262  if ( this.isOpen ) {
14263  this._selectFocusedItem( event );
14264  } else {
14265  this._toggle( event );
14266  }
14267  break;
14268  case $.ui.keyCode.LEFT:
14269  this._move( "prev", event );
14270  break;
14271  case $.ui.keyCode.RIGHT:
14272  this._move( "next", event );
14273  break;
14274  case $.ui.keyCode.HOME:
14275  case $.ui.keyCode.PAGE_UP:
14276  this._move( "first", event );
14277  break;
14278  case $.ui.keyCode.END:
14279  case $.ui.keyCode.PAGE_DOWN:
14280  this._move( "last", event );
14281  break;
14282  default:
14283  this.menu.trigger( event );
14284  preventDefault = false;
14285  }
14286 
14287  if ( preventDefault ) {
14288  event.preventDefault();
14289  }
14290  }
14291  },
14292 
14293  _selectFocusedItem: function( event ) {
14294  var item = this.menuItems.eq( this.focusIndex ).parent( "li" );
14295  if ( !item.hasClass( "ui-state-disabled" ) ) {
14296  this._select( item.data( "ui-selectmenu-item" ), event );
14297  }
14298  },
14299 
14300  _select: function( item, event ) {
14301  var oldIndex = this.element[ 0 ].selectedIndex;
14302 
14303  // Change native select element
14304  this.element[ 0 ].selectedIndex = item.index;
14305  this.buttonItem.replaceWith( this.buttonItem = this._renderButtonItem( item ) );
14306  this._setAria( item );
14307  this._trigger( "select", event, { item: item } );
14308 
14309  if ( item.index !== oldIndex ) {
14310  this._trigger( "change", event, { item: item } );
14311  }
14312 
14313  this.close( event );
14314  },
14315 
14316  _setAria: function( item ) {
14317  var id = this.menuItems.eq( item.index ).attr( "id" );
14318 
14319  this.button.attr( {
14320  "aria-labelledby": id,
14321  "aria-activedescendant": id
14322  } );
14323  this.menu.attr( "aria-activedescendant", id );
14324  },
14325 
14326  _setOption: function( key, value ) {
14327  if ( key === "icons" ) {
14328  var icon = this.button.find( "span.ui-icon" );
14329  this._removeClass( icon, null, this.options.icons.button )
14330  ._addClass( icon, null, value.button );
14331  }
14332 
14333  this._super( key, value );
14334 
14335  if ( key === "appendTo" ) {
14336  this.menuWrap.appendTo( this._appendTo() );
14337  }
14338 
14339  if ( key === "width" ) {
14340  this._resizeButton();
14341  }
14342  },
14343 
14344  _setOptionDisabled: function( value ) {
14345  this._super( value );
14346 
14347  this.menuInstance.option( "disabled", value );
14348  this.button.attr( "aria-disabled", value );
14349  this._toggleClass( this.button, null, "ui-state-disabled", value );
14350 
14351  this.element.prop( "disabled", value );
14352  if ( value ) {
14353  this.button.attr( "tabindex", -1 );
14354  this.close();
14355  } else {
14356  this.button.attr( "tabindex", 0 );
14357  }
14358  },
14359 
14360  _appendTo: function() {
14361  var element = this.options.appendTo;
14362 
14363  if ( element ) {
14364  element = element.jquery || element.nodeType ?
14365  $( element ) :
14366  this.document.find( element ).eq( 0 );
14367  }
14368 
14369  if ( !element || !element[ 0 ] ) {
14370  element = this.element.closest( ".ui-front, dialog" );
14371  }
14372 
14373  if ( !element.length ) {
14374  element = this.document[ 0 ].body;
14375  }
14376 
14377  return element;
14378  },
14379 
14380  _toggleAttr: function() {
14381  this.button.attr( "aria-expanded", this.isOpen );
14382 
14383  // We can't use two _toggleClass() calls here, because we need to make sure
14384  // we always remove classes first and add them second, otherwise if both classes have the
14385  // same theme class, it will be removed after we add it.
14386  this._removeClass( this.button, "ui-selectmenu-button-" +
14387  ( this.isOpen ? "closed" : "open" ) )
14388  ._addClass( this.button, "ui-selectmenu-button-" +
14389  ( this.isOpen ? "open" : "closed" ) )
14390  ._toggleClass( this.menuWrap, "ui-selectmenu-open", null, this.isOpen );
14391 
14392  this.menu.attr( "aria-hidden", !this.isOpen );
14393  },
14394 
14395  _resizeButton: function() {
14396  var width = this.options.width;
14397 
14398  // For `width: false`, just remove inline style and stop
14399  if ( width === false ) {
14400  this.button.css( "width", "" );
14401  return;
14402  }
14403 
14404  // For `width: null`, match the width of the original element
14405  if ( width === null ) {
14406  width = this.element.show().outerWidth();
14407  this.element.hide();
14408  }
14409 
14410  this.button.outerWidth( width );
14411  },
14412 
14413  _resizeMenu: function() {
14414  this.menu.outerWidth( Math.max(
14415  this.button.outerWidth(),
14416 
14417  // Support: IE10
14418  // IE10 wraps long text (possibly a rounding bug)
14419  // so we add 1px to avoid the wrapping
14420  this.menu.width( "" ).outerWidth() + 1
14421  ) );
14422  },
14423 
14424  _getCreateOptions: function() {
14425  var options = this._super();
14426 
14427  options.disabled = this.element.prop( "disabled" );
14428 
14429  return options;
14430  },
14431 
14432  _parseOptions: function( options ) {
14433  var that = this,
14434  data = [];
14435  options.each( function( index, item ) {
14436  data.push( that._parseOption( $( item ), index ) );
14437  } );
14438  this.items = data;
14439  },
14440 
14441  _parseOption: function( option, index ) {
14442  var optgroup = option.parent( "optgroup" );
14443 
14444  return {
14445  element: option,
14446  index: index,
14447  value: option.val(),
14448  label: option.text(),
14449  optgroup: optgroup.attr( "label" ) || "",
14450  disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" )
14451  };
14452  },
14453 
14454  _destroy: function() {
14455  this._unbindFormResetHandler();
14456  this.menuWrap.remove();
14457  this.button.remove();
14458  this.element.show();
14459  this.element.removeUniqueId();
14460  this.labels.attr( "for", this.ids.element );
14461  }
14462 } ] );
14463 
14464 
14465 /*!
14466  * jQuery UI Slider 1.12.1
14467  * http://jqueryui.com
14468  *
14469  * Copyright jQuery Foundation and other contributors
14470  * Released under the MIT license.
14471  * http://jquery.org/license
14472  */
14473 
14474 //>>label: Slider
14475 //>>group: Widgets
14476 //>>description: Displays a flexible slider with ranges and accessibility via keyboard.
14477 //>>docs: http://api.jqueryui.com/slider/
14478 //>>demos: http://jqueryui.com/slider/
14479 //>>css.structure: ../../themes/base/core.css
14480 //>>css.structure: ../../themes/base/slider.css
14481 //>>css.theme: ../../themes/base/theme.css
14482 
14483 
14484 
14485 var widgetsSlider = $.widget( "ui.slider", $.ui.mouse, {
14486  version: "1.12.1",
14487  widgetEventPrefix: "slide",
14488 
14489  options: {
14490  animate: false,
14491  classes: {
14492  "ui-slider": "ui-corner-all",
14493  "ui-slider-handle": "ui-corner-all",
14494 
14495  // Note: ui-widget-header isn't the most fittingly semantic framework class for this
14496  // element, but worked best visually with a variety of themes
14497  "ui-slider-range": "ui-corner-all ui-widget-header"
14498  },
14499  distance: 0,
14500  max: 100,
14501  min: 0,
14502  orientation: "horizontal",
14503  range: false,
14504  step: 1,
14505  value: 0,
14506  values: null,
14507 
14508  // Callbacks
14509  change: null,
14510  slide: null,
14511  start: null,
14512  stop: null
14513  },
14514 
14515  // Number of pages in a slider
14516  // (how many times can you page up/down to go through the whole range)
14517  numPages: 5,
14518 
14519  _create: function() {
14520  this._keySliding = false;
14521  this._mouseSliding = false;
14522  this._animateOff = true;
14523  this._handleIndex = null;
14524  this._detectOrientation();
14525  this._mouseInit();
14526  this._calculateNewMax();
14527 
14528  this._addClass( "ui-slider ui-slider-" + this.orientation,
14529  "ui-widget ui-widget-content" );
14530 
14531  this._refresh();
14532 
14533  this._animateOff = false;
14534  },
14535 
14536  _refresh: function() {
14537  this._createRange();
14538  this._createHandles();
14539  this._setupEvents();
14540  this._refreshValue();
14541  },
14542 
14543  _createHandles: function() {
14544  var i, handleCount,
14545  options = this.options,
14546  existingHandles = this.element.find( ".ui-slider-handle" ),
14547  handle = "<span tabindex='0'></span>",
14548  handles = [];
14549 
14550  handleCount = ( options.values && options.values.length ) || 1;
14551 
14552  if ( existingHandles.length > handleCount ) {
14553  existingHandles.slice( handleCount ).remove();
14554  existingHandles = existingHandles.slice( 0, handleCount );
14555  }
14556 
14557  for ( i = existingHandles.length; i < handleCount; i++ ) {
14558  handles.push( handle );
14559  }
14560 
14561  this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
14562 
14563  this._addClass( this.handles, "ui-slider-handle", "ui-state-default" );
14564 
14565  this.handle = this.handles.eq( 0 );
14566 
14567  this.handles.each( function( i ) {
14568  $( this )
14569  .data( "ui-slider-handle-index", i )
14570  .attr( "tabIndex", 0 );
14571  } );
14572  },
14573 
14574  _createRange: function() {
14575  var options = this.options;
14576 
14577  if ( options.range ) {
14578  if ( options.range === true ) {
14579  if ( !options.values ) {
14580  options.values = [ this._valueMin(), this._valueMin() ];
14581  } else if ( options.values.length && options.values.length !== 2 ) {
14582  options.values = [ options.values[ 0 ], options.values[ 0 ] ];
14583  } else if ( $.isArray( options.values ) ) {
14584  options.values = options.values.slice( 0 );
14585  }
14586  }
14587 
14588  if ( !this.range || !this.range.length ) {
14589  this.range = $( "<div>" )
14590  .appendTo( this.element );
14591 
14592  this._addClass( this.range, "ui-slider-range" );
14593  } else {
14594  this._removeClass( this.range, "ui-slider-range-min ui-slider-range-max" );
14595 
14596  // Handle range switching from true to min/max
14597  this.range.css( {
14598  "left": "",
14599  "bottom": ""
14600  } );
14601  }
14602  if ( options.range === "min" || options.range === "max" ) {
14603  this._addClass( this.range, "ui-slider-range-" + options.range );
14604  }
14605  } else {
14606  if ( this.range ) {
14607  this.range.remove();
14608  }
14609  this.range = null;
14610  }
14611  },
14612 
14613  _setupEvents: function() {
14614  this._off( this.handles );
14615  this._on( this.handles, this._handleEvents );
14616  this._hoverable( this.handles );
14617  this._focusable( this.handles );
14618  },
14619 
14620  _destroy: function() {
14621  this.handles.remove();
14622  if ( this.range ) {
14623  this.range.remove();
14624  }
14625 
14626  this._mouseDestroy();
14627  },
14628 
14629  _mouseCapture: function( event ) {
14630  var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
14631  that = this,
14632  o = this.options;
14633 
14634  if ( o.disabled ) {
14635  return false;
14636  }
14637 
14638  this.elementSize = {
14639  width: this.element.outerWidth(),
14640  height: this.element.outerHeight()
14641  };
14642  this.elementOffset = this.element.offset();
14643 
14644  position = { x: event.pageX, y: event.pageY };
14645  normValue = this._normValueFromMouse( position );
14646  distance = this._valueMax() - this._valueMin() + 1;
14647  this.handles.each( function( i ) {
14648  var thisDistance = Math.abs( normValue - that.values( i ) );
14649  if ( ( distance > thisDistance ) ||
14650  ( distance === thisDistance &&
14651  ( i === that._lastChangedValue || that.values( i ) === o.min ) ) ) {
14652  distance = thisDistance;
14653  closestHandle = $( this );
14654  index = i;
14655  }
14656  } );
14657 
14658  allowed = this._start( event, index );
14659  if ( allowed === false ) {
14660  return false;
14661  }
14662  this._mouseSliding = true;
14663 
14664  this._handleIndex = index;
14665 
14666  this._addClass( closestHandle, null, "ui-state-active" );
14667  closestHandle.trigger( "focus" );
14668 
14669  offset = closestHandle.offset();
14670  mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
14671  this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
14672  left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
14673  top: event.pageY - offset.top -
14674  ( closestHandle.height() / 2 ) -
14675  ( parseInt( closestHandle.css( "borderTopWidth" ), 10 ) || 0 ) -
14676  ( parseInt( closestHandle.css( "borderBottomWidth" ), 10 ) || 0 ) +
14677  ( parseInt( closestHandle.css( "marginTop" ), 10 ) || 0 )
14678  };
14679 
14680  if ( !this.handles.hasClass( "ui-state-hover" ) ) {
14681  this._slide( event, index, normValue );
14682  }
14683  this._animateOff = true;
14684  return true;
14685  },
14686 
14687  _mouseStart: function() {
14688  return true;
14689  },
14690 
14691  _mouseDrag: function( event ) {
14692  var position = { x: event.pageX, y: event.pageY },
14693  normValue = this._normValueFromMouse( position );
14694 
14695  this._slide( event, this._handleIndex, normValue );
14696 
14697  return false;
14698  },
14699 
14700  _mouseStop: function( event ) {
14701  this._removeClass( this.handles, null, "ui-state-active" );
14702  this._mouseSliding = false;
14703 
14704  this._stop( event, this._handleIndex );
14705  this._change( event, this._handleIndex );
14706 
14707  this._handleIndex = null;
14708  this._clickOffset = null;
14709  this._animateOff = false;
14710 
14711  return false;
14712  },
14713 
14714  _detectOrientation: function() {
14715  this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
14716  },
14717 
14718  _normValueFromMouse: function( position ) {
14719  var pixelTotal,
14720  pixelMouse,
14721  percentMouse,
14722  valueTotal,
14723  valueMouse;
14724 
14725  if ( this.orientation === "horizontal" ) {
14726  pixelTotal = this.elementSize.width;
14727  pixelMouse = position.x - this.elementOffset.left -
14728  ( this._clickOffset ? this._clickOffset.left : 0 );
14729  } else {
14730  pixelTotal = this.elementSize.height;
14731  pixelMouse = position.y - this.elementOffset.top -
14732  ( this._clickOffset ? this._clickOffset.top : 0 );
14733  }
14734 
14735  percentMouse = ( pixelMouse / pixelTotal );
14736  if ( percentMouse > 1 ) {
14737  percentMouse = 1;
14738  }
14739  if ( percentMouse < 0 ) {
14740  percentMouse = 0;
14741  }
14742  if ( this.orientation === "vertical" ) {
14743  percentMouse = 1 - percentMouse;
14744  }
14745 
14746  valueTotal = this._valueMax() - this._valueMin();
14747  valueMouse = this._valueMin() + percentMouse * valueTotal;
14748 
14749  return this._trimAlignValue( valueMouse );
14750  },
14751 
14752  _uiHash: function( index, value, values ) {
14753  var uiHash = {
14754  handle: this.handles[ index ],
14755  handleIndex: index,
14756  value: value !== undefined ? value : this.value()
14757  };
14758 
14759  if ( this._hasMultipleValues() ) {
14760  uiHash.value = value !== undefined ? value : this.values( index );
14761  uiHash.values = values || this.values();
14762  }
14763 
14764  return uiHash;
14765  },
14766 
14767  _hasMultipleValues: function() {
14768  return this.options.values && this.options.values.length;
14769  },
14770 
14771  _start: function( event, index ) {
14772  return this._trigger( "start", event, this._uiHash( index ) );
14773  },
14774 
14775  _slide: function( event, index, newVal ) {
14776  var allowed, otherVal,
14777  currentValue = this.value(),
14778  newValues = this.values();
14779 
14780  if ( this._hasMultipleValues() ) {
14781  otherVal = this.values( index ? 0 : 1 );
14782  currentValue = this.values( index );
14783 
14784  if ( this.options.values.length === 2 && this.options.range === true ) {
14785  newVal = index === 0 ? Math.min( otherVal, newVal ) : Math.max( otherVal, newVal );
14786  }
14787 
14788  newValues[ index ] = newVal;
14789  }
14790 
14791  if ( newVal === currentValue ) {
14792  return;
14793  }
14794 
14795  allowed = this._trigger( "slide", event, this._uiHash( index, newVal, newValues ) );
14796 
14797  // A slide can be canceled by returning false from the slide callback
14798  if ( allowed === false ) {
14799  return;
14800  }
14801 
14802  if ( this._hasMultipleValues() ) {
14803  this.values( index, newVal );
14804  } else {
14805  this.value( newVal );
14806  }
14807  },
14808 
14809  _stop: function( event, index ) {
14810  this._trigger( "stop", event, this._uiHash( index ) );
14811  },
14812 
14813  _change: function( event, index ) {
14814  if ( !this._keySliding && !this._mouseSliding ) {
14815 
14816  //store the last changed value index for reference when handles overlap
14817  this._lastChangedValue = index;
14818  this._trigger( "change", event, this._uiHash( index ) );
14819  }
14820  },
14821 
14822  value: function( newValue ) {
14823  if ( arguments.length ) {
14824  this.options.value = this._trimAlignValue( newValue );
14825  this._refreshValue();
14826  this._change( null, 0 );
14827  return;
14828  }
14829 
14830  return this._value();
14831  },
14832 
14833  values: function( index, newValue ) {
14834  var vals,
14835  newValues,
14836  i;
14837 
14838  if ( arguments.length > 1 ) {
14839  this.options.values[ index ] = this._trimAlignValue( newValue );
14840  this._refreshValue();
14841  this._change( null, index );
14842  return;
14843  }
14844 
14845  if ( arguments.length ) {
14846  if ( $.isArray( arguments[ 0 ] ) ) {
14847  vals = this.options.values;
14848  newValues = arguments[ 0 ];
14849  for ( i = 0; i < vals.length; i += 1 ) {
14850  vals[ i ] = this._trimAlignValue( newValues[ i ] );
14851  this._change( null, i );
14852  }
14853  this._refreshValue();
14854  } else {
14855  if ( this._hasMultipleValues() ) {
14856  return this._values( index );
14857  } else {
14858  return this.value();
14859  }
14860  }
14861  } else {
14862  return this._values();
14863  }
14864  },
14865 
14866  _setOption: function( key, value ) {
14867  var i,
14868  valsLength = 0;
14869 
14870  if ( key === "range" && this.options.range === true ) {
14871  if ( value === "min" ) {
14872  this.options.value = this._values( 0 );
14873  this.options.values = null;
14874  } else if ( value === "max" ) {
14875  this.options.value = this._values( this.options.values.length - 1 );
14876  this.options.values = null;
14877  }
14878  }
14879 
14880  if ( $.isArray( this.options.values ) ) {
14881  valsLength = this.options.values.length;
14882  }
14883 
14884  this._super( key, value );
14885 
14886  switch ( key ) {
14887  case "orientation":
14888  this._detectOrientation();
14889  this._removeClass( "ui-slider-horizontal ui-slider-vertical" )
14890  ._addClass( "ui-slider-" + this.orientation );
14891  this._refreshValue();
14892  if ( this.options.range ) {
14893  this._refreshRange( value );
14894  }
14895 
14896  // Reset positioning from previous orientation
14897  this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
14898  break;
14899  case "value":
14900  this._animateOff = true;
14901  this._refreshValue();
14902  this._change( null, 0 );
14903  this._animateOff = false;
14904  break;
14905  case "values":
14906  this._animateOff = true;
14907  this._refreshValue();
14908 
14909  // Start from the last handle to prevent unreachable handles (#9046)
14910  for ( i = valsLength - 1; i >= 0; i-- ) {
14911  this._change( null, i );
14912  }
14913  this._animateOff = false;
14914  break;
14915  case "step":
14916  case "min":
14917  case "max":
14918  this._animateOff = true;
14919  this._calculateNewMax();
14920  this._refreshValue();
14921  this._animateOff = false;
14922  break;
14923  case "range":
14924  this._animateOff = true;
14925  this._refresh();
14926  this._animateOff = false;
14927  break;
14928  }
14929  },
14930 
14931  _setOptionDisabled: function( value ) {
14932  this._super( value );
14933 
14934  this._toggleClass( null, "ui-state-disabled", !!value );
14935  },
14936 
14937  //internal value getter
14938  // _value() returns value trimmed by min and max, aligned by step
14939  _value: function() {
14940  var val = this.options.value;
14941  val = this._trimAlignValue( val );
14942 
14943  return val;
14944  },
14945 
14946  //internal values getter
14947  // _values() returns array of values trimmed by min and max, aligned by step
14948  // _values( index ) returns single value trimmed by min and max, aligned by step
14949  _values: function( index ) {
14950  var val,
14951  vals,
14952  i;
14953 
14954  if ( arguments.length ) {
14955  val = this.options.values[ index ];
14956  val = this._trimAlignValue( val );
14957 
14958  return val;
14959  } else if ( this._hasMultipleValues() ) {
14960 
14961  // .slice() creates a copy of the array
14962  // this copy gets trimmed by min and max and then returned
14963  vals = this.options.values.slice();
14964  for ( i = 0; i < vals.length; i += 1 ) {
14965  vals[ i ] = this._trimAlignValue( vals[ i ] );
14966  }
14967 
14968  return vals;
14969  } else {
14970  return [];
14971  }
14972  },
14973 
14974  // Returns the step-aligned value that val is closest to, between (inclusive) min and max
14975  _trimAlignValue: function( val ) {
14976  if ( val <= this._valueMin() ) {
14977  return this._valueMin();
14978  }
14979  if ( val >= this._valueMax() ) {
14980  return this._valueMax();
14981  }
14982  var step = ( this.options.step > 0 ) ? this.options.step : 1,
14983  valModStep = ( val - this._valueMin() ) % step,
14984  alignValue = val - valModStep;
14985 
14986  if ( Math.abs( valModStep ) * 2 >= step ) {
14987  alignValue += ( valModStep > 0 ) ? step : ( -step );
14988  }
14989 
14990  // Since JavaScript has problems with large floats, round
14991  // the final value to 5 digits after the decimal point (see #4124)
14992  return parseFloat( alignValue.toFixed( 5 ) );
14993  },
14994 
14995  _calculateNewMax: function() {
14996  var max = this.options.max,
14997  min = this._valueMin(),
14998  step = this.options.step,
14999  aboveMin = Math.round( ( max - min ) / step ) * step;
15000  max = aboveMin + min;
15001  if ( max > this.options.max ) {
15002 
15003  //If max is not divisible by step, rounding off may increase its value
15004  max -= step;
15005  }
15006  this.max = parseFloat( max.toFixed( this._precision() ) );
15007  },
15008 
15009  _precision: function() {
15010  var precision = this._precisionOf( this.options.step );
15011  if ( this.options.min !== null ) {
15012  precision = Math.max( precision, this._precisionOf( this.options.min ) );
15013  }
15014  return precision;
15015  },
15016 
15017  _precisionOf: function( num ) {
15018  var str = num.toString(),
15019  decimal = str.indexOf( "." );
15020  return decimal === -1 ? 0 : str.length - decimal - 1;
15021  },
15022 
15023  _valueMin: function() {
15024  return this.options.min;
15025  },
15026 
15027  _valueMax: function() {
15028  return this.max;
15029  },
15030 
15031  _refreshRange: function( orientation ) {
15032  if ( orientation === "vertical" ) {
15033  this.range.css( { "width": "", "left": "" } );
15034  }
15035  if ( orientation === "horizontal" ) {
15036  this.range.css( { "height": "", "bottom": "" } );
15037  }
15038  },
15039 
15040  _refreshValue: function() {
15041  var lastValPercent, valPercent, value, valueMin, valueMax,
15042  oRange = this.options.range,
15043  o = this.options,
15044  that = this,
15045  animate = ( !this._animateOff ) ? o.animate : false,
15046  _set = {};
15047 
15048  if ( this._hasMultipleValues() ) {
15049  this.handles.each( function( i ) {
15050  valPercent = ( that.values( i ) - that._valueMin() ) / ( that._valueMax() -
15051  that._valueMin() ) * 100;
15052  _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
15053  $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
15054  if ( that.options.range === true ) {
15055  if ( that.orientation === "horizontal" ) {
15056  if ( i === 0 ) {
15057  that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( {
15058  left: valPercent + "%"
15059  }, o.animate );
15060  }
15061  if ( i === 1 ) {
15062  that.range[ animate ? "animate" : "css" ]( {
15063  width: ( valPercent - lastValPercent ) + "%"
15064  }, {
15065  queue: false,
15066  duration: o.animate
15067  } );
15068  }
15069  } else {
15070  if ( i === 0 ) {
15071  that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( {
15072  bottom: ( valPercent ) + "%"
15073  }, o.animate );
15074  }
15075  if ( i === 1 ) {
15076  that.range[ animate ? "animate" : "css" ]( {
15077  height: ( valPercent - lastValPercent ) + "%"
15078  }, {
15079  queue: false,
15080  duration: o.animate
15081  } );
15082  }
15083  }
15084  }
15085  lastValPercent = valPercent;
15086  } );
15087  } else {
15088  value = this.value();
15089  valueMin = this._valueMin();
15090  valueMax = this._valueMax();
15091  valPercent = ( valueMax !== valueMin ) ?
15092  ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
15093  0;
15094  _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
15095  this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
15096 
15097  if ( oRange === "min" && this.orientation === "horizontal" ) {
15098  this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( {
15099  width: valPercent + "%"
15100  }, o.animate );
15101  }
15102  if ( oRange === "max" && this.orientation === "horizontal" ) {
15103  this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( {
15104  width: ( 100 - valPercent ) + "%"
15105  }, o.animate );
15106  }
15107  if ( oRange === "min" && this.orientation === "vertical" ) {
15108  this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( {
15109  height: valPercent + "%"
15110  }, o.animate );
15111  }
15112  if ( oRange === "max" && this.orientation === "vertical" ) {
15113  this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( {
15114  height: ( 100 - valPercent ) + "%"
15115  }, o.animate );
15116  }
15117  }
15118  },
15119 
15120  _handleEvents: {
15121  keydown: function( event ) {
15122  var allowed, curVal, newVal, step,
15123  index = $( event.target ).data( "ui-slider-handle-index" );
15124 
15125  switch ( event.keyCode ) {
15126  case $.ui.keyCode.HOME:
15127  case $.ui.keyCode.END:
15128  case $.ui.keyCode.PAGE_UP:
15129  case $.ui.keyCode.PAGE_DOWN:
15130  case $.ui.keyCode.UP:
15131  case $.ui.keyCode.RIGHT:
15132  case $.ui.keyCode.DOWN:
15133  case $.ui.keyCode.LEFT:
15134  event.preventDefault();
15135  if ( !this._keySliding ) {
15136  this._keySliding = true;
15137  this._addClass( $( event.target ), null, "ui-state-active" );
15138  allowed = this._start( event, index );
15139  if ( allowed === false ) {
15140  return;
15141  }
15142  }
15143  break;
15144  }
15145 
15146  step = this.options.step;
15147  if ( this._hasMultipleValues() ) {
15148  curVal = newVal = this.values( index );
15149  } else {
15150  curVal = newVal = this.value();
15151  }
15152 
15153  switch ( event.keyCode ) {
15154  case $.ui.keyCode.HOME:
15155  newVal = this._valueMin();
15156  break;
15157  case $.ui.keyCode.END:
15158  newVal = this._valueMax();
15159  break;
15160  case $.ui.keyCode.PAGE_UP:
15161  newVal = this._trimAlignValue(
15162  curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
15163  );
15164  break;
15165  case $.ui.keyCode.PAGE_DOWN:
15166  newVal = this._trimAlignValue(
15167  curVal - ( ( this._valueMax() - this._valueMin() ) / this.numPages ) );
15168  break;
15169  case $.ui.keyCode.UP:
15170  case $.ui.keyCode.RIGHT:
15171  if ( curVal === this._valueMax() ) {
15172  return;
15173  }
15174  newVal = this._trimAlignValue( curVal + step );
15175  break;
15176  case $.ui.keyCode.DOWN:
15177  case $.ui.keyCode.LEFT:
15178  if ( curVal === this._valueMin() ) {
15179  return;
15180  }
15181  newVal = this._trimAlignValue( curVal - step );
15182  break;
15183  }
15184 
15185  this._slide( event, index, newVal );
15186  },
15187  keyup: function( event ) {
15188  var index = $( event.target ).data( "ui-slider-handle-index" );
15189 
15190  if ( this._keySliding ) {
15191  this._keySliding = false;
15192  this._stop( event, index );
15193  this._change( event, index );
15194  this._removeClass( $( event.target ), null, "ui-state-active" );
15195  }
15196  }
15197  }
15198 } );
15199 
15200 
15201 /*!
15202  * jQuery UI Sortable 1.12.1
15203  * http://jqueryui.com
15204  *
15205  * Copyright jQuery Foundation and other contributors
15206  * Released under the MIT license.
15207  * http://jquery.org/license
15208  */
15209 
15210 //>>label: Sortable
15211 //>>group: Interactions
15212 //>>description: Enables items in a list to be sorted using the mouse.
15213 //>>docs: http://api.jqueryui.com/sortable/
15214 //>>demos: http://jqueryui.com/sortable/
15215 //>>css.structure: ../../themes/base/sortable.css
15216 
15217 
15218 
15219 var widgetsSortable = $.widget( "ui.sortable", $.ui.mouse, {
15220  version: "1.12.1",
15221  widgetEventPrefix: "sort",
15222  ready: false,
15223  options: {
15224  appendTo: "parent",
15225  axis: false,
15226  connectWith: false,
15227  containment: false,
15228  cursor: "auto",
15229  cursorAt: false,
15230  dropOnEmpty: true,
15231  forcePlaceholderSize: false,
15232  forceHelperSize: false,
15233  grid: false,
15234  handle: false,
15235  helper: "original",
15236  items: "> *",
15237  opacity: false,
15238  placeholder: false,
15239  revert: false,
15240  scroll: true,
15241  scrollSensitivity: 20,
15242  scrollSpeed: 20,
15243  scope: "default",
15244  tolerance: "intersect",
15245  zIndex: 1000,
15246 
15247  // Callbacks
15248  activate: null,
15249  beforeStop: null,
15250  change: null,
15251  deactivate: null,
15252  out: null,
15253  over: null,
15254  receive: null,
15255  remove: null,
15256  sort: null,
15257  start: null,
15258  stop: null,
15259  update: null
15260  },
15261 
15262  _isOverAxis: function( x, reference, size ) {
15263  return ( x >= reference ) && ( x < ( reference + size ) );
15264  },
15265 
15266  _isFloating: function( item ) {
15267  return ( /left|right/ ).test( item.css( "float" ) ) ||
15268  ( /inline|table-cell/ ).test( item.css( "display" ) );
15269  },
15270 
15271  _create: function() {
15272  this.containerCache = {};
15273  this._addClass( "ui-sortable" );
15274 
15275  //Get the items
15276  this.refresh();
15277 
15278  //Let's determine the parent's offset
15279  this.offset = this.element.offset();
15280 
15281  //Initialize mouse events for interaction
15282  this._mouseInit();
15283 
15284  this._setHandleClassName();
15285 
15286  //We're ready to go
15287  this.ready = true;
15288 
15289  },
15290 
15291  _setOption: function( key, value ) {
15292  this._super( key, value );
15293 
15294  if ( key === "handle" ) {
15295  this._setHandleClassName();
15296  }
15297  },
15298 
15299  _setHandleClassName: function() {
15300  var that = this;
15301  this._removeClass( this.element.find( ".ui-sortable-handle" ), "ui-sortable-handle" );
15302  $.each( this.items, function() {
15303  that._addClass(
15304  this.instance.options.handle ?
15305  this.item.find( this.instance.options.handle ) :
15306  this.item,
15307  "ui-sortable-handle"
15308  );
15309  } );
15310  },
15311 
15312  _destroy: function() {
15313  this._mouseDestroy();
15314 
15315  for ( var i = this.items.length - 1; i >= 0; i-- ) {
15316  this.items[ i ].item.removeData( this.widgetName + "-item" );
15317  }
15318 
15319  return this;
15320  },
15321 
15322  _mouseCapture: function( event, overrideHandle ) {
15323  var currentItem = null,
15324  validHandle = false,
15325  that = this;
15326 
15327  if ( this.reverting ) {
15328  return false;
15329  }
15330 
15331  if ( this.options.disabled || this.options.type === "static" ) {
15332  return false;
15333  }
15334 
15335  //We have to refresh the items data once first
15336  this._refreshItems( event );
15337 
15338  //Find out if the clicked node (or one of its parents) is a actual item in this.items
15339  $( event.target ).parents().each( function() {
15340  if ( $.data( this, that.widgetName + "-item" ) === that ) {
15341  currentItem = $( this );
15342  return false;
15343  }
15344  } );
15345  if ( $.data( event.target, that.widgetName + "-item" ) === that ) {
15346  currentItem = $( event.target );
15347  }
15348 
15349  if ( !currentItem ) {
15350  return false;
15351  }
15352  if ( this.options.handle && !overrideHandle ) {
15353  $( this.options.handle, currentItem ).find( "*" ).addBack().each( function() {
15354  if ( this === event.target ) {
15355  validHandle = true;
15356  }
15357  } );
15358  if ( !validHandle ) {
15359  return false;
15360  }
15361  }
15362 
15363  this.currentItem = currentItem;
15364  this._removeCurrentsFromItems();
15365  return true;
15366 
15367  },
15368 
15369  _mouseStart: function( event, overrideHandle, noActivation ) {
15370 
15371  var i, body,
15372  o = this.options;
15373 
15374  this.currentContainer = this;
15375 
15376  //We only need to call refreshPositions, because the refreshItems call has been moved to
15377  // mouseCapture
15378  this.refreshPositions();
15379 
15380  //Create and append the visible helper
15381  this.helper = this._createHelper( event );
15382 
15383  //Cache the helper size
15384  this._cacheHelperProportions();
15385 
15386  /*
15387  * - Position generation -
15388  * This block generates everything position related - it's the core of draggables.
15389  */
15390 
15391  //Cache the margins of the original element
15392  this._cacheMargins();
15393 
15394  //Get the next scrolling parent
15395  this.scrollParent = this.helper.scrollParent();
15396 
15397  //The element's absolute position on the page minus margins
15398  this.offset = this.currentItem.offset();
15399  this.offset = {
15400  top: this.offset.top - this.margins.top,
15401  left: this.offset.left - this.margins.left
15402  };
15403 
15404  $.extend( this.offset, {
15405  click: { //Where the click happened, relative to the element
15406  left: event.pageX - this.offset.left,
15407  top: event.pageY - this.offset.top
15408  },
15409  parent: this._getParentOffset(),
15410 
15411  // This is a relative to absolute position minus the actual position calculation -
15412  // only used for relative positioned helper
15413  relative: this._getRelativeOffset()
15414  } );
15415 
15416  // Only after we got the offset, we can change the helper's position to absolute
15417  // TODO: Still need to figure out a way to make relative sorting possible
15418  this.helper.css( "position", "absolute" );
15419  this.cssPosition = this.helper.css( "position" );
15420 
15421  //Generate the original position
15422  this.originalPosition = this._generatePosition( event );
15423  this.originalPageX = event.pageX;
15424  this.originalPageY = event.pageY;
15425 
15426  //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
15427  ( o.cursorAt && this._adjustOffsetFromHelper( o.cursorAt ) );
15428 
15429  //Cache the former DOM position
15430  this.domPosition = {
15431  prev: this.currentItem.prev()[ 0 ],
15432  parent: this.currentItem.parent()[ 0 ]
15433  };
15434 
15435  // If the helper is not the original, hide the original so it's not playing any role during
15436  // the drag, won't cause anything bad this way
15437  if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
15438  this.currentItem.hide();
15439  }
15440 
15441  //Create the placeholder
15442  this._createPlaceholder();
15443 
15444  //Set a containment if given in the options
15445  if ( o.containment ) {
15446  this._setContainment();
15447  }
15448 
15449  if ( o.cursor && o.cursor !== "auto" ) { // cursor option
15450  body = this.document.find( "body" );
15451 
15452  // Support: IE
15453  this.storedCursor = body.css( "cursor" );
15454  body.css( "cursor", o.cursor );
15455 
15456  this.storedStylesheet =
15457  $( "<style>*{ cursor: " + o.cursor + " !important; }</style>" ).appendTo( body );
15458  }
15459 
15460  if ( o.opacity ) { // opacity option
15461  if ( this.helper.css( "opacity" ) ) {
15462  this._storedOpacity = this.helper.css( "opacity" );
15463  }
15464  this.helper.css( "opacity", o.opacity );
15465  }
15466 
15467  if ( o.zIndex ) { // zIndex option
15468  if ( this.helper.css( "zIndex" ) ) {
15469  this._storedZIndex = this.helper.css( "zIndex" );
15470  }
15471  this.helper.css( "zIndex", o.zIndex );
15472  }
15473 
15474  //Prepare scrolling
15475  if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
15476  this.scrollParent[ 0 ].tagName !== "HTML" ) {
15477  this.overflowOffset = this.scrollParent.offset();
15478  }
15479 
15480  //Call callbacks
15481  this._trigger( "start", event, this._uiHash() );
15482 
15483  //Recache the helper size
15484  if ( !this._preserveHelperProportions ) {
15485  this._cacheHelperProportions();
15486  }
15487 
15488  //Post "activate" events to possible containers
15489  if ( !noActivation ) {
15490  for ( i = this.containers.length - 1; i >= 0; i-- ) {
15491  this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
15492  }
15493  }
15494 
15495  //Prepare possible droppables
15496  if ( $.ui.ddmanager ) {
15497  $.ui.ddmanager.current = this;
15498  }
15499 
15500  if ( $.ui.ddmanager && !o.dropBehaviour ) {
15501  $.ui.ddmanager.prepareOffsets( this, event );
15502  }
15503 
15504  this.dragging = true;
15505 
15506  this._addClass( this.helper, "ui-sortable-helper" );
15507 
15508  // Execute the drag once - this causes the helper not to be visiblebefore getting its
15509  // correct position
15510  this._mouseDrag( event );
15511  return true;
15512 
15513  },
15514 
15515  _mouseDrag: function( event ) {
15516  var i, item, itemElement, intersection,
15517  o = this.options,
15518  scrolled = false;
15519 
15520  //Compute the helpers position
15521  this.position = this._generatePosition( event );
15522  this.positionAbs = this._convertPositionTo( "absolute" );
15523 
15524  if ( !this.lastPositionAbs ) {
15525  this.lastPositionAbs = this.positionAbs;
15526  }
15527 
15528  //Do scrolling
15529  if ( this.options.scroll ) {
15530  if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
15531  this.scrollParent[ 0 ].tagName !== "HTML" ) {
15532 
15533  if ( ( this.overflowOffset.top + this.scrollParent[ 0 ].offsetHeight ) -
15534  event.pageY < o.scrollSensitivity ) {
15535  this.scrollParent[ 0 ].scrollTop =
15536  scrolled = this.scrollParent[ 0 ].scrollTop + o.scrollSpeed;
15537  } else if ( event.pageY - this.overflowOffset.top < o.scrollSensitivity ) {
15538  this.scrollParent[ 0 ].scrollTop =
15539  scrolled = this.scrollParent[ 0 ].scrollTop - o.scrollSpeed;
15540  }
15541 
15542  if ( ( this.overflowOffset.left + this.scrollParent[ 0 ].offsetWidth ) -
15543  event.pageX < o.scrollSensitivity ) {
15544  this.scrollParent[ 0 ].scrollLeft = scrolled =
15545  this.scrollParent[ 0 ].scrollLeft + o.scrollSpeed;
15546  } else if ( event.pageX - this.overflowOffset.left < o.scrollSensitivity ) {
15547  this.scrollParent[ 0 ].scrollLeft = scrolled =
15548  this.scrollParent[ 0 ].scrollLeft - o.scrollSpeed;
15549  }
15550 
15551  } else {
15552 
15553  if ( event.pageY - this.document.scrollTop() < o.scrollSensitivity ) {
15554  scrolled = this.document.scrollTop( this.document.scrollTop() - o.scrollSpeed );
15555  } else if ( this.window.height() - ( event.pageY - this.document.scrollTop() ) <
15556  o.scrollSensitivity ) {
15557  scrolled = this.document.scrollTop( this.document.scrollTop() + o.scrollSpeed );
15558  }
15559 
15560  if ( event.pageX - this.document.scrollLeft() < o.scrollSensitivity ) {
15561  scrolled = this.document.scrollLeft(
15562  this.document.scrollLeft() - o.scrollSpeed
15563  );
15564  } else if ( this.window.width() - ( event.pageX - this.document.scrollLeft() ) <
15565  o.scrollSensitivity ) {
15566  scrolled = this.document.scrollLeft(
15567  this.document.scrollLeft() + o.scrollSpeed
15568  );
15569  }
15570 
15571  }
15572 
15573  if ( scrolled !== false && $.ui.ddmanager && !o.dropBehaviour ) {
15574  $.ui.ddmanager.prepareOffsets( this, event );
15575  }
15576  }
15577 
15578  //Regenerate the absolute position used for position checks
15579  this.positionAbs = this._convertPositionTo( "absolute" );
15580 
15581  //Set the helper position
15582  if ( !this.options.axis || this.options.axis !== "y" ) {
15583  this.helper[ 0 ].style.left = this.position.left + "px";
15584  }
15585  if ( !this.options.axis || this.options.axis !== "x" ) {
15586  this.helper[ 0 ].style.top = this.position.top + "px";
15587  }
15588 
15589  //Rearrange
15590  for ( i = this.items.length - 1; i >= 0; i-- ) {
15591 
15592  //Cache variables and intersection, continue if no intersection
15593  item = this.items[ i ];
15594  itemElement = item.item[ 0 ];
15595  intersection = this._intersectsWithPointer( item );
15596  if ( !intersection ) {
15597  continue;
15598  }
15599 
15600  // Only put the placeholder inside the current Container, skip all
15601  // items from other containers. This works because when moving
15602  // an item from one container to another the
15603  // currentContainer is switched before the placeholder is moved.
15604  //
15605  // Without this, moving items in "sub-sortables" can cause
15606  // the placeholder to jitter between the outer and inner container.
15607  if ( item.instance !== this.currentContainer ) {
15608  continue;
15609  }
15610 
15611  // Cannot intersect with itself
15612  // no useless actions that have been done before
15613  // no action if the item moved is the parent of the item checked
15614  if ( itemElement !== this.currentItem[ 0 ] &&
15615  this.placeholder[ intersection === 1 ? "next" : "prev" ]()[ 0 ] !== itemElement &&
15616  !$.contains( this.placeholder[ 0 ], itemElement ) &&
15617  ( this.options.type === "semi-dynamic" ?
15618  !$.contains( this.element[ 0 ], itemElement ) :
15619  true
15620  )
15621  ) {
15622 
15623  this.direction = intersection === 1 ? "down" : "up";
15624 
15625  if ( this.options.tolerance === "pointer" || this._intersectsWithSides( item ) ) {
15626  this._rearrange( event, item );
15627  } else {
15628  break;
15629  }
15630 
15631  this._trigger( "change", event, this._uiHash() );
15632  break;
15633  }
15634  }
15635 
15636  //Post events to containers
15637  this._contactContainers( event );
15638 
15639  //Interconnect with droppables
15640  if ( $.ui.ddmanager ) {
15641  $.ui.ddmanager.drag( this, event );
15642  }
15643 
15644  //Call callbacks
15645  this._trigger( "sort", event, this._uiHash() );
15646 
15647  this.lastPositionAbs = this.positionAbs;
15648  return false;
15649 
15650  },
15651 
15652  _mouseStop: function( event, noPropagation ) {
15653 
15654  if ( !event ) {
15655  return;
15656  }
15657 
15658  //If we are using droppables, inform the manager about the drop
15659  if ( $.ui.ddmanager && !this.options.dropBehaviour ) {
15660  $.ui.ddmanager.drop( this, event );
15661  }
15662 
15663  if ( this.options.revert ) {
15664  var that = this,
15665  cur = this.placeholder.offset(),
15666  axis = this.options.axis,
15667  animation = {};
15668 
15669  if ( !axis || axis === "x" ) {
15670  animation.left = cur.left - this.offset.parent.left - this.margins.left +
15671  ( this.offsetParent[ 0 ] === this.document[ 0 ].body ?
15672  0 :
15673  this.offsetParent[ 0 ].scrollLeft
15674  );
15675  }
15676  if ( !axis || axis === "y" ) {
15677  animation.top = cur.top - this.offset.parent.top - this.margins.top +
15678  ( this.offsetParent[ 0 ] === this.document[ 0 ].body ?
15679  0 :
15680  this.offsetParent[ 0 ].scrollTop
15681  );
15682  }
15683  this.reverting = true;
15684  $( this.helper ).animate(
15685  animation,
15686  parseInt( this.options.revert, 10 ) || 500,
15687  function() {
15688  that._clear( event );
15689  }
15690  );
15691  } else {
15692  this._clear( event, noPropagation );
15693  }
15694 
15695  return false;
15696 
15697  },
15698 
15699  cancel: function() {
15700 
15701  if ( this.dragging ) {
15702 
15703  this._mouseUp( new $.Event( "mouseup", { target: null } ) );
15704 
15705  if ( this.options.helper === "original" ) {
15706  this.currentItem.css( this._storedCSS );
15707  this._removeClass( this.currentItem, "ui-sortable-helper" );
15708  } else {
15709  this.currentItem.show();
15710  }
15711 
15712  //Post deactivating events to containers
15713  for ( var i = this.containers.length - 1; i >= 0; i-- ) {
15714  this.containers[ i ]._trigger( "deactivate", null, this._uiHash( this ) );
15715  if ( this.containers[ i ].containerCache.over ) {
15716  this.containers[ i ]._trigger( "out", null, this._uiHash( this ) );
15717  this.containers[ i ].containerCache.over = 0;
15718  }
15719  }
15720 
15721  }
15722 
15723  if ( this.placeholder ) {
15724 
15725  //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately,
15726  // it unbinds ALL events from the original node!
15727  if ( this.placeholder[ 0 ].parentNode ) {
15728  this.placeholder[ 0 ].parentNode.removeChild( this.placeholder[ 0 ] );
15729  }
15730  if ( this.options.helper !== "original" && this.helper &&
15731  this.helper[ 0 ].parentNode ) {
15732  this.helper.remove();
15733  }
15734 
15735  $.extend( this, {
15736  helper: null,
15737  dragging: false,
15738  reverting: false,
15739  _noFinalSort: null
15740  } );
15741 
15742  if ( this.domPosition.prev ) {
15743  $( this.domPosition.prev ).after( this.currentItem );
15744  } else {
15745  $( this.domPosition.parent ).prepend( this.currentItem );
15746  }
15747  }
15748 
15749  return this;
15750 
15751  },
15752 
15753  serialize: function( o ) {
15754 
15755  var items = this._getItemsAsjQuery( o && o.connected ),
15756  str = [];
15757  o = o || {};
15758 
15759  $( items ).each( function() {
15760  var res = ( $( o.item || this ).attr( o.attribute || "id" ) || "" )
15761  .match( o.expression || ( /(.+)[\-=_](.+)/ ) );
15762  if ( res ) {
15763  str.push(
15764  ( o.key || res[ 1 ] + "[]" ) +
15765  "=" + ( o.key && o.expression ? res[ 1 ] : res[ 2 ] ) );
15766  }
15767  } );
15768 
15769  if ( !str.length && o.key ) {
15770  str.push( o.key + "=" );
15771  }
15772 
15773  return str.join( "&" );
15774 
15775  },
15776 
15777  toArray: function( o ) {
15778 
15779  var items = this._getItemsAsjQuery( o && o.connected ),
15780  ret = [];
15781 
15782  o = o || {};
15783 
15784  items.each( function() {
15785  ret.push( $( o.item || this ).attr( o.attribute || "id" ) || "" );
15786  } );
15787  return ret;
15788 
15789  },
15790 
15791  /* Be careful with the following core functions */
15792  _intersectsWith: function( item ) {
15793 
15794  var x1 = this.positionAbs.left,
15795  x2 = x1 + this.helperProportions.width,
15796  y1 = this.positionAbs.top,
15797  y2 = y1 + this.helperProportions.height,
15798  l = item.left,
15799  r = l + item.width,
15800  t = item.top,
15801  b = t + item.height,
15802  dyClick = this.offset.click.top,
15803  dxClick = this.offset.click.left,
15804  isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t &&
15805  ( y1 + dyClick ) < b ),
15806  isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l &&
15807  ( x1 + dxClick ) < r ),
15808  isOverElement = isOverElementHeight && isOverElementWidth;
15809 
15810  if ( this.options.tolerance === "pointer" ||
15811  this.options.forcePointerForContainers ||
15812  ( this.options.tolerance !== "pointer" &&
15813  this.helperProportions[ this.floating ? "width" : "height" ] >
15814  item[ this.floating ? "width" : "height" ] )
15815  ) {
15816  return isOverElement;
15817  } else {
15818 
15819  return ( l < x1 + ( this.helperProportions.width / 2 ) && // Right Half
15820  x2 - ( this.helperProportions.width / 2 ) < r && // Left Half
15821  t < y1 + ( this.helperProportions.height / 2 ) && // Bottom Half
15822  y2 - ( this.helperProportions.height / 2 ) < b ); // Top Half
15823 
15824  }
15825  },
15826 
15827  _intersectsWithPointer: function( item ) {
15828  var verticalDirection, horizontalDirection,
15829  isOverElementHeight = ( this.options.axis === "x" ) ||
15830  this._isOverAxis(
15831  this.positionAbs.top + this.offset.click.top, item.top, item.height ),
15832  isOverElementWidth = ( this.options.axis === "y" ) ||
15833  this._isOverAxis(
15834  this.positionAbs.left + this.offset.click.left, item.left, item.width ),
15835  isOverElement = isOverElementHeight && isOverElementWidth;
15836 
15837  if ( !isOverElement ) {
15838  return false;
15839  }
15840 
15841  verticalDirection = this._getDragVerticalDirection();
15842  horizontalDirection = this._getDragHorizontalDirection();
15843 
15844  return this.floating ?
15845  ( ( horizontalDirection === "right" || verticalDirection === "down" ) ? 2 : 1 )
15846  : ( verticalDirection && ( verticalDirection === "down" ? 2 : 1 ) );
15847 
15848  },
15849 
15850  _intersectsWithSides: function( item ) {
15851 
15852  var isOverBottomHalf = this._isOverAxis( this.positionAbs.top +
15853  this.offset.click.top, item.top + ( item.height / 2 ), item.height ),
15854  isOverRightHalf = this._isOverAxis( this.positionAbs.left +
15855  this.offset.click.left, item.left + ( item.width / 2 ), item.width ),
15856  verticalDirection = this._getDragVerticalDirection(),
15857  horizontalDirection = this._getDragHorizontalDirection();
15858 
15859  if ( this.floating && horizontalDirection ) {
15860  return ( ( horizontalDirection === "right" && isOverRightHalf ) ||
15861  ( horizontalDirection === "left" && !isOverRightHalf ) );
15862  } else {
15863  return verticalDirection && ( ( verticalDirection === "down" && isOverBottomHalf ) ||
15864  ( verticalDirection === "up" && !isOverBottomHalf ) );
15865  }
15866 
15867  },
15868 
15869  _getDragVerticalDirection: function() {
15870  var delta = this.positionAbs.top - this.lastPositionAbs.top;
15871  return delta !== 0 && ( delta > 0 ? "down" : "up" );
15872  },
15873 
15874  _getDragHorizontalDirection: function() {
15875  var delta = this.positionAbs.left - this.lastPositionAbs.left;
15876  return delta !== 0 && ( delta > 0 ? "right" : "left" );
15877  },
15878 
15879  refresh: function( event ) {
15880  this._refreshItems( event );
15881  this._setHandleClassName();
15882  this.refreshPositions();
15883  return this;
15884  },
15885 
15886  _connectWith: function() {
15887  var options = this.options;
15888  return options.connectWith.constructor === String ?
15889  [ options.connectWith ] :
15890  options.connectWith;
15891  },
15892 
15893  _getItemsAsjQuery: function( connected ) {
15894 
15895  var i, j, cur, inst,
15896  items = [],
15897  queries = [],
15898  connectWith = this._connectWith();
15899 
15900  if ( connectWith && connected ) {
15901  for ( i = connectWith.length - 1; i >= 0; i-- ) {
15902  cur = $( connectWith[ i ], this.document[ 0 ] );
15903  for ( j = cur.length - 1; j >= 0; j-- ) {
15904  inst = $.data( cur[ j ], this.widgetFullName );
15905  if ( inst && inst !== this && !inst.options.disabled ) {
15906  queries.push( [ $.isFunction( inst.options.items ) ?
15907  inst.options.items.call( inst.element ) :
15908  $( inst.options.items, inst.element )
15909  .not( ".ui-sortable-helper" )
15910  .not( ".ui-sortable-placeholder" ), inst ] );
15911  }
15912  }
15913  }
15914  }
15915 
15916  queries.push( [ $.isFunction( this.options.items ) ?
15917  this.options.items
15918  .call( this.element, null, { options: this.options, item: this.currentItem } ) :
15919  $( this.options.items, this.element )
15920  .not( ".ui-sortable-helper" )
15921  .not( ".ui-sortable-placeholder" ), this ] );
15922 
15923  function addItems() {
15924  items.push( this );
15925  }
15926  for ( i = queries.length - 1; i >= 0; i-- ) {
15927  queries[ i ][ 0 ].each( addItems );
15928  }
15929 
15930  return $( items );
15931 
15932  },
15933 
15934  _removeCurrentsFromItems: function() {
15935 
15936  var list = this.currentItem.find( ":data(" + this.widgetName + "-item)" );
15937 
15938  this.items = $.grep( this.items, function( item ) {
15939  for ( var j = 0; j < list.length; j++ ) {
15940  if ( list[ j ] === item.item[ 0 ] ) {
15941  return false;
15942  }
15943  }
15944  return true;
15945  } );
15946 
15947  },
15948 
15949  _refreshItems: function( event ) {
15950 
15951  this.items = [];
15952  this.containers = [ this ];
15953 
15954  var i, j, cur, inst, targetData, _queries, item, queriesLength,
15955  items = this.items,
15956  queries = [ [ $.isFunction( this.options.items ) ?
15957  this.options.items.call( this.element[ 0 ], event, { item: this.currentItem } ) :
15958  $( this.options.items, this.element ), this ] ],
15959  connectWith = this._connectWith();
15960 
15961  //Shouldn't be run the first time through due to massive slow-down
15962  if ( connectWith && this.ready ) {
15963  for ( i = connectWith.length - 1; i >= 0; i-- ) {
15964  cur = $( connectWith[ i ], this.document[ 0 ] );
15965  for ( j = cur.length - 1; j >= 0; j-- ) {
15966  inst = $.data( cur[ j ], this.widgetFullName );
15967  if ( inst && inst !== this && !inst.options.disabled ) {
15968  queries.push( [ $.isFunction( inst.options.items ) ?
15969  inst.options.items
15970  .call( inst.element[ 0 ], event, { item: this.currentItem } ) :
15971  $( inst.options.items, inst.element ), inst ] );
15972  this.containers.push( inst );
15973  }
15974  }
15975  }
15976  }
15977 
15978  for ( i = queries.length - 1; i >= 0; i-- ) {
15979  targetData = queries[ i ][ 1 ];
15980  _queries = queries[ i ][ 0 ];
15981 
15982  for ( j = 0, queriesLength = _queries.length; j < queriesLength; j++ ) {
15983  item = $( _queries[ j ] );
15984 
15985  // Data for target checking (mouse manager)
15986  item.data( this.widgetName + "-item", targetData );
15987 
15988  items.push( {
15989  item: item,
15990  instance: targetData,
15991  width: 0, height: 0,
15992  left: 0, top: 0
15993  } );
15994  }
15995  }
15996 
15997  },
15998 
15999  refreshPositions: function( fast ) {
16000 
16001  // Determine whether items are being displayed horizontally
16002  this.floating = this.items.length ?
16003  this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
16004  false;
16005 
16006  //This has to be redone because due to the item being moved out/into the offsetParent,
16007  // the offsetParent's position will change
16008  if ( this.offsetParent && this.helper ) {
16009  this.offset.parent = this._getParentOffset();
16010  }
16011 
16012  var i, item, t, p;
16013 
16014  for ( i = this.items.length - 1; i >= 0; i-- ) {
16015  item = this.items[ i ];
16016 
16017  //We ignore calculating positions of all connected containers when we're not over them
16018  if ( item.instance !== this.currentContainer && this.currentContainer &&
16019  item.item[ 0 ] !== this.currentItem[ 0 ] ) {
16020  continue;
16021  }
16022 
16023  t = this.options.toleranceElement ?
16024  $( this.options.toleranceElement, item.item ) :
16025  item.item;
16026 
16027  if ( !fast ) {
16028  item.width = t.outerWidth();
16029  item.height = t.outerHeight();
16030  }
16031 
16032  p = t.offset();
16033  item.left = p.left;
16034  item.top = p.top;
16035  }
16036 
16037  if ( this.options.custom && this.options.custom.refreshContainers ) {
16038  this.options.custom.refreshContainers.call( this );
16039  } else {
16040  for ( i = this.containers.length - 1; i >= 0; i-- ) {
16041  p = this.containers[ i ].element.offset();
16042  this.containers[ i ].containerCache.left = p.left;
16043  this.containers[ i ].containerCache.top = p.top;
16044  this.containers[ i ].containerCache.width =
16045  this.containers[ i ].element.outerWidth();
16046  this.containers[ i ].containerCache.height =
16047  this.containers[ i ].element.outerHeight();
16048  }
16049  }
16050 
16051  return this;
16052  },
16053 
16054  _createPlaceholder: function( that ) {
16055  that = that || this;
16056  var className,
16057  o = that.options;
16058 
16059  if ( !o.placeholder || o.placeholder.constructor === String ) {
16060  className = o.placeholder;
16061  o.placeholder = {
16062  element: function() {
16063 
16064  var nodeName = that.currentItem[ 0 ].nodeName.toLowerCase(),
16065  element = $( "<" + nodeName + ">", that.document[ 0 ] );
16066 
16067  that._addClass( element, "ui-sortable-placeholder",
16068  className || that.currentItem[ 0 ].className )
16069  ._removeClass( element, "ui-sortable-helper" );
16070 
16071  if ( nodeName === "tbody" ) {
16072  that._createTrPlaceholder(
16073  that.currentItem.find( "tr" ).eq( 0 ),
16074  $( "<tr>", that.document[ 0 ] ).appendTo( element )
16075  );
16076  } else if ( nodeName === "tr" ) {
16077  that._createTrPlaceholder( that.currentItem, element );
16078  } else if ( nodeName === "img" ) {
16079  element.attr( "src", that.currentItem.attr( "src" ) );
16080  }
16081 
16082  if ( !className ) {
16083  element.css( "visibility", "hidden" );
16084  }
16085 
16086  return element;
16087  },
16088  update: function( container, p ) {
16089 
16090  // 1. If a className is set as 'placeholder option, we don't force sizes -
16091  // the class is responsible for that
16092  // 2. The option 'forcePlaceholderSize can be enabled to force it even if a
16093  // class name is specified
16094  if ( className && !o.forcePlaceholderSize ) {
16095  return;
16096  }
16097 
16098  //If the element doesn't have a actual height by itself (without styles coming
16099  // from a stylesheet), it receives the inline height from the dragged item
16100  if ( !p.height() ) {
16101  p.height(
16102  that.currentItem.innerHeight() -
16103  parseInt( that.currentItem.css( "paddingTop" ) || 0, 10 ) -
16104  parseInt( that.currentItem.css( "paddingBottom" ) || 0, 10 ) );
16105  }
16106  if ( !p.width() ) {
16107  p.width(
16108  that.currentItem.innerWidth() -
16109  parseInt( that.currentItem.css( "paddingLeft" ) || 0, 10 ) -
16110  parseInt( that.currentItem.css( "paddingRight" ) || 0, 10 ) );
16111  }
16112  }
16113  };
16114  }
16115 
16116  //Create the placeholder
16117  that.placeholder = $( o.placeholder.element.call( that.element, that.currentItem ) );
16118 
16119  //Append it after the actual current item
16120  that.currentItem.after( that.placeholder );
16121 
16122  //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
16123  o.placeholder.update( that, that.placeholder );
16124 
16125  },
16126 
16127  _createTrPlaceholder: function( sourceTr, targetTr ) {
16128  var that = this;
16129 
16130  sourceTr.children().each( function() {
16131  $( "<td>&#160;</td>", that.document[ 0 ] )
16132  .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
16133  .appendTo( targetTr );
16134  } );
16135  },
16136 
16137  _contactContainers: function( event ) {
16138  var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom,
16139  floating, axis,
16140  innermostContainer = null,
16141  innermostIndex = null;
16142 
16143  // Get innermost container that intersects with item
16144  for ( i = this.containers.length - 1; i >= 0; i-- ) {
16145 
16146  // Never consider a container that's located within the item itself
16147  if ( $.contains( this.currentItem[ 0 ], this.containers[ i ].element[ 0 ] ) ) {
16148  continue;
16149  }
16150 
16151  if ( this._intersectsWith( this.containers[ i ].containerCache ) ) {
16152 
16153  // If we've already found a container and it's more "inner" than this, then continue
16154  if ( innermostContainer &&
16155  $.contains(
16156  this.containers[ i ].element[ 0 ],
16157  innermostContainer.element[ 0 ] ) ) {
16158  continue;
16159  }
16160 
16161  innermostContainer = this.containers[ i ];
16162  innermostIndex = i;
16163 
16164  } else {
16165 
16166  // container doesn't intersect. trigger "out" event if necessary
16167  if ( this.containers[ i ].containerCache.over ) {
16168  this.containers[ i ]._trigger( "out", event, this._uiHash( this ) );
16169  this.containers[ i ].containerCache.over = 0;
16170  }
16171  }
16172 
16173  }
16174 
16175  // If no intersecting containers found, return
16176  if ( !innermostContainer ) {
16177  return;
16178  }
16179 
16180  // Move the item into the container if it's not there already
16181  if ( this.containers.length === 1 ) {
16182  if ( !this.containers[ innermostIndex ].containerCache.over ) {
16183  this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash( this ) );
16184  this.containers[ innermostIndex ].containerCache.over = 1;
16185  }
16186  } else {
16187 
16188  // When entering a new container, we will find the item with the least distance and
16189  // append our item near it
16190  dist = 10000;
16191  itemWithLeastDistance = null;
16192  floating = innermostContainer.floating || this._isFloating( this.currentItem );
16193  posProperty = floating ? "left" : "top";
16194  sizeProperty = floating ? "width" : "height";
16195  axis = floating ? "pageX" : "pageY";
16196 
16197  for ( j = this.items.length - 1; j >= 0; j-- ) {
16198  if ( !$.contains(
16199  this.containers[ innermostIndex ].element[ 0 ], this.items[ j ].item[ 0 ] )
16200  ) {
16201  continue;
16202  }
16203  if ( this.items[ j ].item[ 0 ] === this.currentItem[ 0 ] ) {
16204  continue;
16205  }
16206 
16207  cur = this.items[ j ].item.offset()[ posProperty ];
16208  nearBottom = false;
16209  if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
16210  nearBottom = true;
16211  }
16212 
16213  if ( Math.abs( event[ axis ] - cur ) < dist ) {
16214  dist = Math.abs( event[ axis ] - cur );
16215  itemWithLeastDistance = this.items[ j ];
16216  this.direction = nearBottom ? "up" : "down";
16217  }
16218  }
16219 
16220  //Check if dropOnEmpty is enabled
16221  if ( !itemWithLeastDistance && !this.options.dropOnEmpty ) {
16222  return;
16223  }
16224 
16225  if ( this.currentContainer === this.containers[ innermostIndex ] ) {
16226  if ( !this.currentContainer.containerCache.over ) {
16227  this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
16228  this.currentContainer.containerCache.over = 1;
16229  }
16230  return;
16231  }
16232 
16233  itemWithLeastDistance ?
16234  this._rearrange( event, itemWithLeastDistance, null, true ) :
16235  this._rearrange( event, null, this.containers[ innermostIndex ].element, true );
16236  this._trigger( "change", event, this._uiHash() );
16237  this.containers[ innermostIndex ]._trigger( "change", event, this._uiHash( this ) );
16238  this.currentContainer = this.containers[ innermostIndex ];
16239 
16240  //Update the placeholder
16241  this.options.placeholder.update( this.currentContainer, this.placeholder );
16242 
16243  this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash( this ) );
16244  this.containers[ innermostIndex ].containerCache.over = 1;
16245  }
16246 
16247  },
16248 
16249  _createHelper: function( event ) {
16250 
16251  var o = this.options,
16252  helper = $.isFunction( o.helper ) ?
16253  $( o.helper.apply( this.element[ 0 ], [ event, this.currentItem ] ) ) :
16254  ( o.helper === "clone" ? this.currentItem.clone() : this.currentItem );
16255 
16256  //Add the helper to the DOM if that didn't happen already
16257  if ( !helper.parents( "body" ).length ) {
16258  $( o.appendTo !== "parent" ?
16259  o.appendTo :
16260  this.currentItem[ 0 ].parentNode )[ 0 ].appendChild( helper[ 0 ] );
16261  }
16262 
16263  if ( helper[ 0 ] === this.currentItem[ 0 ] ) {
16264  this._storedCSS = {
16265  width: this.currentItem[ 0 ].style.width,
16266  height: this.currentItem[ 0 ].style.height,
16267  position: this.currentItem.css( "position" ),
16268  top: this.currentItem.css( "top" ),
16269  left: this.currentItem.css( "left" )
16270  };
16271  }
16272 
16273  if ( !helper[ 0 ].style.width || o.forceHelperSize ) {
16274  helper.width( this.currentItem.width() );
16275  }
16276  if ( !helper[ 0 ].style.height || o.forceHelperSize ) {
16277  helper.height( this.currentItem.height() );
16278  }
16279 
16280  return helper;
16281 
16282  },
16283 
16284  _adjustOffsetFromHelper: function( obj ) {
16285  if ( typeof obj === "string" ) {
16286  obj = obj.split( " " );
16287  }
16288  if ( $.isArray( obj ) ) {
16289  obj = { left: +obj[ 0 ], top: +obj[ 1 ] || 0 };
16290  }
16291  if ( "left" in obj ) {
16292  this.offset.click.left = obj.left + this.margins.left;
16293  }
16294  if ( "right" in obj ) {
16295  this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
16296  }
16297  if ( "top" in obj ) {
16298  this.offset.click.top = obj.top + this.margins.top;
16299  }
16300  if ( "bottom" in obj ) {
16301  this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
16302  }
16303  },
16304 
16305  _getParentOffset: function() {
16306 
16307  //Get the offsetParent and cache its position
16308  this.offsetParent = this.helper.offsetParent();
16309  var po = this.offsetParent.offset();
16310 
16311  // This is a special case where we need to modify a offset calculated on start, since the
16312  // following happened:
16313  // 1. The position of the helper is absolute, so it's position is calculated based on the
16314  // next positioned parent
16315  // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
16316  // the document, which means that the scroll is included in the initial calculation of the
16317  // offset of the parent, and never recalculated upon drag
16318  if ( this.cssPosition === "absolute" && this.scrollParent[ 0 ] !== this.document[ 0 ] &&
16319  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) {
16320  po.left += this.scrollParent.scrollLeft();
16321  po.top += this.scrollParent.scrollTop();
16322  }
16323 
16324  // This needs to be actually done for all browsers, since pageX/pageY includes this
16325  // information with an ugly IE fix
16326  if ( this.offsetParent[ 0 ] === this.document[ 0 ].body ||
16327  ( this.offsetParent[ 0 ].tagName &&
16328  this.offsetParent[ 0 ].tagName.toLowerCase() === "html" && $.ui.ie ) ) {
16329  po = { top: 0, left: 0 };
16330  }
16331 
16332  return {
16333  top: po.top + ( parseInt( this.offsetParent.css( "borderTopWidth" ), 10 ) || 0 ),
16334  left: po.left + ( parseInt( this.offsetParent.css( "borderLeftWidth" ), 10 ) || 0 )
16335  };
16336 
16337  },
16338 
16339  _getRelativeOffset: function() {
16340 
16341  if ( this.cssPosition === "relative" ) {
16342  var p = this.currentItem.position();
16343  return {
16344  top: p.top - ( parseInt( this.helper.css( "top" ), 10 ) || 0 ) +
16345  this.scrollParent.scrollTop(),
16346  left: p.left - ( parseInt( this.helper.css( "left" ), 10 ) || 0 ) +
16347  this.scrollParent.scrollLeft()
16348  };
16349  } else {
16350  return { top: 0, left: 0 };
16351  }
16352 
16353  },
16354 
16355  _cacheMargins: function() {
16356  this.margins = {
16357  left: ( parseInt( this.currentItem.css( "marginLeft" ), 10 ) || 0 ),
16358  top: ( parseInt( this.currentItem.css( "marginTop" ), 10 ) || 0 )
16359  };
16360  },
16361 
16362  _cacheHelperProportions: function() {
16363  this.helperProportions = {
16364  width: this.helper.outerWidth(),
16365  height: this.helper.outerHeight()
16366  };
16367  },
16368 
16369  _setContainment: function() {
16370 
16371  var ce, co, over,
16372  o = this.options;
16373  if ( o.containment === "parent" ) {
16374  o.containment = this.helper[ 0 ].parentNode;
16375  }
16376  if ( o.containment === "document" || o.containment === "window" ) {
16377  this.containment = [
16378  0 - this.offset.relative.left - this.offset.parent.left,
16379  0 - this.offset.relative.top - this.offset.parent.top,
16380  o.containment === "document" ?
16381  this.document.width() :
16382  this.window.width() - this.helperProportions.width - this.margins.left,
16383  ( o.containment === "document" ?
16384  ( this.document.height() || document.body.parentNode.scrollHeight ) :
16385  this.window.height() || this.document[ 0 ].body.parentNode.scrollHeight
16386  ) - this.helperProportions.height - this.margins.top
16387  ];
16388  }
16389 
16390  if ( !( /^(document|window|parent)$/ ).test( o.containment ) ) {
16391  ce = $( o.containment )[ 0 ];
16392  co = $( o.containment ).offset();
16393  over = ( $( ce ).css( "overflow" ) !== "hidden" );
16394 
16395  this.containment = [
16396  co.left + ( parseInt( $( ce ).css( "borderLeftWidth" ), 10 ) || 0 ) +
16397  ( parseInt( $( ce ).css( "paddingLeft" ), 10 ) || 0 ) - this.margins.left,
16398  co.top + ( parseInt( $( ce ).css( "borderTopWidth" ), 10 ) || 0 ) +
16399  ( parseInt( $( ce ).css( "paddingTop" ), 10 ) || 0 ) - this.margins.top,
16400  co.left + ( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
16401  ( parseInt( $( ce ).css( "borderLeftWidth" ), 10 ) || 0 ) -
16402  ( parseInt( $( ce ).css( "paddingRight" ), 10 ) || 0 ) -
16403  this.helperProportions.width - this.margins.left,
16404  co.top + ( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
16405  ( parseInt( $( ce ).css( "borderTopWidth" ), 10 ) || 0 ) -
16406  ( parseInt( $( ce ).css( "paddingBottom" ), 10 ) || 0 ) -
16407  this.helperProportions.height - this.margins.top
16408  ];
16409  }
16410 
16411  },
16412 
16413  _convertPositionTo: function( d, pos ) {
16414 
16415  if ( !pos ) {
16416  pos = this.position;
16417  }
16418  var mod = d === "absolute" ? 1 : -1,
16419  scroll = this.cssPosition === "absolute" &&
16420  !( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
16421  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ?
16422  this.offsetParent :
16423  this.scrollParent,
16424  scrollIsRootNode = ( /(html|body)/i ).test( scroll[ 0 ].tagName );
16425 
16426  return {
16427  top: (
16428 
16429  // The absolute mouse position
16430  pos.top +
16431 
16432  // Only for relative positioned nodes: Relative offset from element to offset parent
16433  this.offset.relative.top * mod +
16434 
16435  // The offsetParent's offset without borders (offset + border)
16436  this.offset.parent.top * mod -
16437  ( ( this.cssPosition === "fixed" ?
16438  -this.scrollParent.scrollTop() :
16439  ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod )
16440  ),
16441  left: (
16442 
16443  // The absolute mouse position
16444  pos.left +
16445 
16446  // Only for relative positioned nodes: Relative offset from element to offset parent
16447  this.offset.relative.left * mod +
16448 
16449  // The offsetParent's offset without borders (offset + border)
16450  this.offset.parent.left * mod -
16451  ( ( this.cssPosition === "fixed" ?
16452  -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 :
16453  scroll.scrollLeft() ) * mod )
16454  )
16455  };
16456 
16457  },
16458 
16459  _generatePosition: function( event ) {
16460 
16461  var top, left,
16462  o = this.options,
16463  pageX = event.pageX,
16464  pageY = event.pageY,
16465  scroll = this.cssPosition === "absolute" &&
16466  !( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
16467  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ?
16468  this.offsetParent :
16469  this.scrollParent,
16470  scrollIsRootNode = ( /(html|body)/i ).test( scroll[ 0 ].tagName );
16471 
16472  // This is another very weird special case that only happens for relative elements:
16473  // 1. If the css position is relative
16474  // 2. and the scroll parent is the document or similar to the offset parent
16475  // we have to refresh the relative offset during the scroll so there are no jumps
16476  if ( this.cssPosition === "relative" && !( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
16477  this.scrollParent[ 0 ] !== this.offsetParent[ 0 ] ) ) {
16478  this.offset.relative = this._getRelativeOffset();
16479  }
16480 
16481  /*
16482  * - Position constraining -
16483  * Constrain the position to a mix of grid, containment.
16484  */
16485 
16486  if ( this.originalPosition ) { //If we are not dragging yet, we won't check for options
16487 
16488  if ( this.containment ) {
16489  if ( event.pageX - this.offset.click.left < this.containment[ 0 ] ) {
16490  pageX = this.containment[ 0 ] + this.offset.click.left;
16491  }
16492  if ( event.pageY - this.offset.click.top < this.containment[ 1 ] ) {
16493  pageY = this.containment[ 1 ] + this.offset.click.top;
16494  }
16495  if ( event.pageX - this.offset.click.left > this.containment[ 2 ] ) {
16496  pageX = this.containment[ 2 ] + this.offset.click.left;
16497  }
16498  if ( event.pageY - this.offset.click.top > this.containment[ 3 ] ) {
16499  pageY = this.containment[ 3 ] + this.offset.click.top;
16500  }
16501  }
16502 
16503  if ( o.grid ) {
16504  top = this.originalPageY + Math.round( ( pageY - this.originalPageY ) /
16505  o.grid[ 1 ] ) * o.grid[ 1 ];
16506  pageY = this.containment ?
16507  ( ( top - this.offset.click.top >= this.containment[ 1 ] &&
16508  top - this.offset.click.top <= this.containment[ 3 ] ) ?
16509  top :
16510  ( ( top - this.offset.click.top >= this.containment[ 1 ] ) ?
16511  top - o.grid[ 1 ] : top + o.grid[ 1 ] ) ) :
16512  top;
16513 
16514  left = this.originalPageX + Math.round( ( pageX - this.originalPageX ) /
16515  o.grid[ 0 ] ) * o.grid[ 0 ];
16516  pageX = this.containment ?
16517  ( ( left - this.offset.click.left >= this.containment[ 0 ] &&
16518  left - this.offset.click.left <= this.containment[ 2 ] ) ?
16519  left :
16520  ( ( left - this.offset.click.left >= this.containment[ 0 ] ) ?
16521  left - o.grid[ 0 ] : left + o.grid[ 0 ] ) ) :
16522  left;
16523  }
16524 
16525  }
16526 
16527  return {
16528  top: (
16529 
16530  // The absolute mouse position
16531  pageY -
16532 
16533  // Click offset (relative to the element)
16534  this.offset.click.top -
16535 
16536  // Only for relative positioned nodes: Relative offset from element to offset parent
16537  this.offset.relative.top -
16538 
16539  // The offsetParent's offset without borders (offset + border)
16540  this.offset.parent.top +
16541  ( ( this.cssPosition === "fixed" ?
16542  -this.scrollParent.scrollTop() :
16543  ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) )
16544  ),
16545  left: (
16546 
16547  // The absolute mouse position
16548  pageX -
16549 
16550  // Click offset (relative to the element)
16551  this.offset.click.left -
16552 
16553  // Only for relative positioned nodes: Relative offset from element to offset parent
16554  this.offset.relative.left -
16555 
16556  // The offsetParent's offset without borders (offset + border)
16557  this.offset.parent.left +
16558  ( ( this.cssPosition === "fixed" ?
16559  -this.scrollParent.scrollLeft() :
16560  scrollIsRootNode ? 0 : scroll.scrollLeft() ) )
16561  )
16562  };
16563 
16564  },
16565 
16566  _rearrange: function( event, i, a, hardRefresh ) {
16567 
16568  a ? a[ 0 ].appendChild( this.placeholder[ 0 ] ) :
16569  i.item[ 0 ].parentNode.insertBefore( this.placeholder[ 0 ],
16570  ( this.direction === "down" ? i.item[ 0 ] : i.item[ 0 ].nextSibling ) );
16571 
16572  //Various things done here to improve the performance:
16573  // 1. we create a setTimeout, that calls refreshPositions
16574  // 2. on the instance, we have a counter variable, that get's higher after every append
16575  // 3. on the local scope, we copy the counter variable, and check in the timeout,
16576  // if it's still the same
16577  // 4. this lets only the last addition to the timeout stack through
16578  this.counter = this.counter ? ++this.counter : 1;
16579  var counter = this.counter;
16580 
16581  this._delay( function() {
16582  if ( counter === this.counter ) {
16583 
16584  //Precompute after each DOM insertion, NOT on mousemove
16585  this.refreshPositions( !hardRefresh );
16586  }
16587  } );
16588 
16589  },
16590 
16591  _clear: function( event, noPropagation ) {
16592 
16593  this.reverting = false;
16594 
16595  // We delay all events that have to be triggered to after the point where the placeholder
16596  // has been removed and everything else normalized again
16597  var i,
16598  delayedTriggers = [];
16599 
16600  // We first have to update the dom position of the actual currentItem
16601  // Note: don't do it if the current item is already removed (by a user), or it gets
16602  // reappended (see #4088)
16603  if ( !this._noFinalSort && this.currentItem.parent().length ) {
16604  this.placeholder.before( this.currentItem );
16605  }
16606  this._noFinalSort = null;
16607 
16608  if ( this.helper[ 0 ] === this.currentItem[ 0 ] ) {
16609  for ( i in this._storedCSS ) {
16610  if ( this._storedCSS[ i ] === "auto" || this._storedCSS[ i ] === "static" ) {
16611  this._storedCSS[ i ] = "";
16612  }
16613  }
16614  this.currentItem.css( this._storedCSS );
16615  this._removeClass( this.currentItem, "ui-sortable-helper" );
16616  } else {
16617  this.currentItem.show();
16618  }
16619 
16620  if ( this.fromOutside && !noPropagation ) {
16621  delayedTriggers.push( function( event ) {
16622  this._trigger( "receive", event, this._uiHash( this.fromOutside ) );
16623  } );
16624  }
16625  if ( ( this.fromOutside ||
16626  this.domPosition.prev !==
16627  this.currentItem.prev().not( ".ui-sortable-helper" )[ 0 ] ||
16628  this.domPosition.parent !== this.currentItem.parent()[ 0 ] ) && !noPropagation ) {
16629 
16630  // Trigger update callback if the DOM position has changed
16631  delayedTriggers.push( function( event ) {
16632  this._trigger( "update", event, this._uiHash() );
16633  } );
16634  }
16635 
16636  // Check if the items Container has Changed and trigger appropriate
16637  // events.
16638  if ( this !== this.currentContainer ) {
16639  if ( !noPropagation ) {
16640  delayedTriggers.push( function( event ) {
16641  this._trigger( "remove", event, this._uiHash() );
16642  } );
16643  delayedTriggers.push( ( function( c ) {
16644  return function( event ) {
16645  c._trigger( "receive", event, this._uiHash( this ) );
16646  };
16647  } ).call( this, this.currentContainer ) );
16648  delayedTriggers.push( ( function( c ) {
16649  return function( event ) {
16650  c._trigger( "update", event, this._uiHash( this ) );
16651  };
16652  } ).call( this, this.currentContainer ) );
16653  }
16654  }
16655 
16656  //Post events to containers
16657  function delayEvent( type, instance, container ) {
16658  return function( event ) {
16659  container._trigger( type, event, instance._uiHash( instance ) );
16660  };
16661  }
16662  for ( i = this.containers.length - 1; i >= 0; i-- ) {
16663  if ( !noPropagation ) {
16664  delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
16665  }
16666  if ( this.containers[ i ].containerCache.over ) {
16667  delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
16668  this.containers[ i ].containerCache.over = 0;
16669  }
16670  }
16671 
16672  //Do what was originally in plugins
16673  if ( this.storedCursor ) {
16674  this.document.find( "body" ).css( "cursor", this.storedCursor );
16675  this.storedStylesheet.remove();
16676  }
16677  if ( this._storedOpacity ) {
16678  this.helper.css( "opacity", this._storedOpacity );
16679  }
16680  if ( this._storedZIndex ) {
16681  this.helper.css( "zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex );
16682  }
16683 
16684  this.dragging = false;
16685 
16686  if ( !noPropagation ) {
16687  this._trigger( "beforeStop", event, this._uiHash() );
16688  }
16689 
16690  //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately,
16691  // it unbinds ALL events from the original node!
16692  this.placeholder[ 0 ].parentNode.removeChild( this.placeholder[ 0 ] );
16693 
16694  if ( !this.cancelHelperRemoval ) {
16695  if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
16696  this.helper.remove();
16697  }
16698  this.helper = null;
16699  }
16700 
16701  if ( !noPropagation ) {
16702  for ( i = 0; i < delayedTriggers.length; i++ ) {
16703 
16704  // Trigger all delayed events
16705  delayedTriggers[ i ].call( this, event );
16706  }
16707  this._trigger( "stop", event, this._uiHash() );
16708  }
16709 
16710  this.fromOutside = false;
16711  return !this.cancelHelperRemoval;
16712 
16713  },
16714 
16715  _trigger: function() {
16716  if ( $.Widget.prototype._trigger.apply( this, arguments ) === false ) {
16717  this.cancel();
16718  }
16719  },
16720 
16721  _uiHash: function( _inst ) {
16722  var inst = _inst || this;
16723  return {
16724  helper: inst.helper,
16725  placeholder: inst.placeholder || $( [] ),
16726  position: inst.position,
16727  originalPosition: inst.originalPosition,
16728  offset: inst.positionAbs,
16729  item: inst.currentItem,
16730  sender: _inst ? _inst.element : null
16731  };
16732  }
16733 
16734 } );
16735 
16736 
16737 /*!
16738  * jQuery UI Spinner 1.12.1
16739  * http://jqueryui.com
16740  *
16741  * Copyright jQuery Foundation and other contributors
16742  * Released under the MIT license.
16743  * http://jquery.org/license
16744  */
16745 
16746 //>>label: Spinner
16747 //>>group: Widgets
16748 //>>description: Displays buttons to easily input numbers via the keyboard or mouse.
16749 //>>docs: http://api.jqueryui.com/spinner/
16750 //>>demos: http://jqueryui.com/spinner/
16751 //>>css.structure: ../../themes/base/core.css
16752 //>>css.structure: ../../themes/base/spinner.css
16753 //>>css.theme: ../../themes/base/theme.css
16754 
16755 
16756 
16757 function spinnerModifer( fn ) {
16758  return function() {
16759  var previous = this.element.val();
16760  fn.apply( this, arguments );
16761  this._refresh();
16762  if ( previous !== this.element.val() ) {
16763  this._trigger( "change" );
16764  }
16765  };
16766 }
16767 
16768 $.widget( "ui.spinner", {
16769  version: "1.12.1",
16770  defaultElement: "<input>",
16771  widgetEventPrefix: "spin",
16772  options: {
16773  classes: {
16774  "ui-spinner": "ui-corner-all",
16775  "ui-spinner-down": "ui-corner-br",
16776  "ui-spinner-up": "ui-corner-tr"
16777  },
16778  culture: null,
16779  icons: {
16780  down: "ui-icon-triangle-1-s",
16781  up: "ui-icon-triangle-1-n"
16782  },
16783  incremental: true,
16784  max: null,
16785  min: null,
16786  numberFormat: null,
16787  page: 10,
16788  step: 1,
16789 
16790  change: null,
16791  spin: null,
16792  start: null,
16793  stop: null
16794  },
16795 
16796  _create: function() {
16797 
16798  // handle string values that need to be parsed
16799  this._setOption( "max", this.options.max );
16800  this._setOption( "min", this.options.min );
16801  this._setOption( "step", this.options.step );
16802 
16803  // Only format if there is a value, prevents the field from being marked
16804  // as invalid in Firefox, see #9573.
16805  if ( this.value() !== "" ) {
16806 
16807  // Format the value, but don't constrain.
16808  this._value( this.element.val(), true );
16809  }
16810 
16811  this._draw();
16812  this._on( this._events );
16813  this._refresh();
16814 
16815  // Turning off autocomplete prevents the browser from remembering the
16816  // value when navigating through history, so we re-enable autocomplete
16817  // if the page is unloaded before the widget is destroyed. #7790
16818  this._on( this.window, {
16819  beforeunload: function() {
16820  this.element.removeAttr( "autocomplete" );
16821  }
16822  } );
16823  },
16824 
16825  _getCreateOptions: function() {
16826  var options = this._super();
16827  var element = this.element;
16828 
16829  $.each( [ "min", "max", "step" ], function( i, option ) {
16830  var value = element.attr( option );
16831  if ( value != null && value.length ) {
16832  options[ option ] = value;
16833  }
16834  } );
16835 
16836  return options;
16837  },
16838 
16839  _events: {
16840  keydown: function( event ) {
16841  if ( this._start( event ) && this._keydown( event ) ) {
16842  event.preventDefault();
16843  }
16844  },
16845  keyup: "_stop",
16846  focus: function() {
16847  this.previous = this.element.val();
16848  },
16849  blur: function( event ) {
16850  if ( this.cancelBlur ) {
16851  delete this.cancelBlur;
16852  return;
16853  }
16854 
16855  this._stop();
16856  this._refresh();
16857  if ( this.previous !== this.element.val() ) {
16858  this._trigger( "change", event );
16859  }
16860  },
16861  mousewheel: function( event, delta ) {
16862  if ( !delta ) {
16863  return;
16864  }
16865  if ( !this.spinning && !this._start( event ) ) {
16866  return false;
16867  }
16868 
16869  this._spin( ( delta > 0 ? 1 : -1 ) * this.options.step, event );
16870  clearTimeout( this.mousewheelTimer );
16871  this.mousewheelTimer = this._delay( function() {
16872  if ( this.spinning ) {
16873  this._stop( event );
16874  }
16875  }, 100 );
16876  event.preventDefault();
16877  },
16878  "mousedown .ui-spinner-button": function( event ) {
16879  var previous;
16880 
16881  // We never want the buttons to have focus; whenever the user is
16882  // interacting with the spinner, the focus should be on the input.
16883  // If the input is focused then this.previous is properly set from
16884  // when the input first received focus. If the input is not focused
16885  // then we need to set this.previous based on the value before spinning.
16886  previous = this.element[ 0 ] === $.ui.safeActiveElement( this.document[ 0 ] ) ?
16887  this.previous : this.element.val();
16888  function checkFocus() {
16889  var isActive = this.element[ 0 ] === $.ui.safeActiveElement( this.document[ 0 ] );
16890  if ( !isActive ) {
16891  this.element.trigger( "focus" );
16892  this.previous = previous;
16893 
16894  // support: IE
16895  // IE sets focus asynchronously, so we need to check if focus
16896  // moved off of the input because the user clicked on the button.
16897  this._delay( function() {
16898  this.previous = previous;
16899  } );
16900  }
16901  }
16902 
16903  // Ensure focus is on (or stays on) the text field
16904  event.preventDefault();
16905  checkFocus.call( this );
16906 
16907  // Support: IE
16908  // IE doesn't prevent moving focus even with event.preventDefault()
16909  // so we set a flag to know when we should ignore the blur event
16910  // and check (again) if focus moved off of the input.
16911  this.cancelBlur = true;
16912  this._delay( function() {
16913  delete this.cancelBlur;
16914  checkFocus.call( this );
16915  } );
16916 
16917  if ( this._start( event ) === false ) {
16918  return;
16919  }
16920 
16921  this._repeat( null, $( event.currentTarget )
16922  .hasClass( "ui-spinner-up" ) ? 1 : -1, event );
16923  },
16924  "mouseup .ui-spinner-button": "_stop",
16925  "mouseenter .ui-spinner-button": function( event ) {
16926 
16927  // button will add ui-state-active if mouse was down while mouseleave and kept down
16928  if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
16929  return;
16930  }
16931 
16932  if ( this._start( event ) === false ) {
16933  return false;
16934  }
16935  this._repeat( null, $( event.currentTarget )
16936  .hasClass( "ui-spinner-up" ) ? 1 : -1, event );
16937  },
16938 
16939  // TODO: do we really want to consider this a stop?
16940  // shouldn't we just stop the repeater and wait until mouseup before
16941  // we trigger the stop event?
16942  "mouseleave .ui-spinner-button": "_stop"
16943  },
16944 
16945  // Support mobile enhanced option and make backcompat more sane
16946  _enhance: function() {
16947  this.uiSpinner = this.element
16948  .attr( "autocomplete", "off" )
16949  .wrap( "<span>" )
16950  .parent()
16951 
16952  // Add buttons
16953  .append(
16954  "<a></a><a></a>"
16955  );
16956  },
16957 
16958  _draw: function() {
16959  this._enhance();
16960 
16961  this._addClass( this.uiSpinner, "ui-spinner", "ui-widget ui-widget-content" );
16962  this._addClass( "ui-spinner-input" );
16963 
16964  this.element.attr( "role", "spinbutton" );
16965 
16966  // Button bindings
16967  this.buttons = this.uiSpinner.children( "a" )
16968  .attr( "tabIndex", -1 )
16969  .attr( "aria-hidden", true )
16970  .button( {
16971  classes: {
16972  "ui-button": ""
16973  }
16974  } );
16975 
16976  // TODO: Right now button does not support classes this is already updated in button PR
16977  this._removeClass( this.buttons, "ui-corner-all" );
16978 
16979  this._addClass( this.buttons.first(), "ui-spinner-button ui-spinner-up" );
16980  this._addClass( this.buttons.last(), "ui-spinner-button ui-spinner-down" );
16981  this.buttons.first().button( {
16982  "icon": this.options.icons.up,
16983  "showLabel": false
16984  } );
16985  this.buttons.last().button( {
16986  "icon": this.options.icons.down,
16987  "showLabel": false
16988  } );
16989 
16990  // IE 6 doesn't understand height: 50% for the buttons
16991  // unless the wrapper has an explicit height
16992  if ( this.buttons.height() > Math.ceil( this.uiSpinner.height() * 0.5 ) &&
16993  this.uiSpinner.height() > 0 ) {
16994  this.uiSpinner.height( this.uiSpinner.height() );
16995  }
16996  },
16997 
16998  _keydown: function( event ) {
16999  var options = this.options,
17000  keyCode = $.ui.keyCode;
17001 
17002  switch ( event.keyCode ) {
17003  case keyCode.UP:
17004  this._repeat( null, 1, event );
17005  return true;
17006  case keyCode.DOWN:
17007  this._repeat( null, -1, event );
17008  return true;
17009  case keyCode.PAGE_UP:
17010  this._repeat( null, options.page, event );
17011  return true;
17012  case keyCode.PAGE_DOWN:
17013  this._repeat( null, -options.page, event );
17014  return true;
17015  }
17016 
17017  return false;
17018  },
17019 
17020  _start: function( event ) {
17021  if ( !this.spinning && this._trigger( "start", event ) === false ) {
17022  return false;
17023  }
17024 
17025  if ( !this.counter ) {
17026  this.counter = 1;
17027  }
17028  this.spinning = true;
17029  return true;
17030  },
17031 
17032  _repeat: function( i, steps, event ) {
17033  i = i || 500;
17034 
17035  clearTimeout( this.timer );
17036  this.timer = this._delay( function() {
17037  this._repeat( 40, steps, event );
17038  }, i );
17039 
17040  this._spin( steps * this.options.step, event );
17041  },
17042 
17043  _spin: function( step, event ) {
17044  var value = this.value() || 0;
17045 
17046  if ( !this.counter ) {
17047  this.counter = 1;
17048  }
17049 
17050  value = this._adjustValue( value + step * this._increment( this.counter ) );
17051 
17052  if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false ) {
17053  this._value( value );
17054  this.counter++;
17055  }
17056  },
17057 
17058  _increment: function( i ) {
17059  var incremental = this.options.incremental;
17060 
17061  if ( incremental ) {
17062  return $.isFunction( incremental ) ?
17063  incremental( i ) :
17064  Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 );
17065  }
17066 
17067  return 1;
17068  },
17069 
17070  _precision: function() {
17071  var precision = this._precisionOf( this.options.step );
17072  if ( this.options.min !== null ) {
17073  precision = Math.max( precision, this._precisionOf( this.options.min ) );
17074  }
17075  return precision;
17076  },
17077 
17078  _precisionOf: function( num ) {
17079  var str = num.toString(),
17080  decimal = str.indexOf( "." );
17081  return decimal === -1 ? 0 : str.length - decimal - 1;
17082  },
17083 
17084  _adjustValue: function( value ) {
17085  var base, aboveMin,
17086  options = this.options;
17087 
17088  // Make sure we're at a valid step
17089  // - find out where we are relative to the base (min or 0)
17090  base = options.min !== null ? options.min : 0;
17091  aboveMin = value - base;
17092 
17093  // - round to the nearest step
17094  aboveMin = Math.round( aboveMin / options.step ) * options.step;
17095 
17096  // - rounding is based on 0, so adjust back to our base
17097  value = base + aboveMin;
17098 
17099  // Fix precision from bad JS floating point math
17100  value = parseFloat( value.toFixed( this._precision() ) );
17101 
17102  // Clamp the value
17103  if ( options.max !== null && value > options.max ) {
17104  return options.max;
17105  }
17106  if ( options.min !== null && value < options.min ) {
17107  return options.min;
17108  }
17109 
17110  return value;
17111  },
17112 
17113  _stop: function( event ) {
17114  if ( !this.spinning ) {
17115  return;
17116  }
17117 
17118  clearTimeout( this.timer );
17119  clearTimeout( this.mousewheelTimer );
17120  this.counter = 0;
17121  this.spinning = false;
17122  this._trigger( "stop", event );
17123  },
17124 
17125  _setOption: function( key, value ) {
17126  var prevValue, first, last;
17127 
17128  if ( key === "culture" || key === "numberFormat" ) {
17129  prevValue = this._parse( this.element.val() );
17130  this.options[ key ] = value;
17131  this.element.val( this._format( prevValue ) );
17132  return;
17133  }
17134 
17135  if ( key === "max" || key === "min" || key === "step" ) {
17136  if ( typeof value === "string" ) {
17137  value = this._parse( value );
17138  }
17139  }
17140  if ( key === "icons" ) {
17141  first = this.buttons.first().find( ".ui-icon" );
17142  this._removeClass( first, null, this.options.icons.up );
17143  this._addClass( first, null, value.up );
17144  last = this.buttons.last().find( ".ui-icon" );
17145  this._removeClass( last, null, this.options.icons.down );
17146  this._addClass( last, null, value.down );
17147  }
17148 
17149  this._super( key, value );
17150  },
17151 
17152  _setOptionDisabled: function( value ) {
17153  this._super( value );
17154 
17155  this._toggleClass( this.uiSpinner, null, "ui-state-disabled", !!value );
17156  this.element.prop( "disabled", !!value );
17157  this.buttons.button( value ? "disable" : "enable" );
17158  },
17159 
17160  _setOptions: spinnerModifer( function( options ) {
17161  this._super( options );
17162  } ),
17163 
17164  _parse: function( val ) {
17165  if ( typeof val === "string" && val !== "" ) {
17166  val = window.Globalize && this.options.numberFormat ?
17167  Globalize.parseFloat( val, 10, this.options.culture ) : +val;
17168  }
17169  return val === "" || isNaN( val ) ? null : val;
17170  },
17171 
17172  _format: function( value ) {
17173  if ( value === "" ) {
17174  return "";
17175  }
17176  return window.Globalize && this.options.numberFormat ?
17177  Globalize.format( value, this.options.numberFormat, this.options.culture ) :
17178  value;
17179  },
17180 
17181  _refresh: function() {
17182  this.element.attr( {
17183  "aria-valuemin": this.options.min,
17184  "aria-valuemax": this.options.max,
17185 
17186  // TODO: what should we do with values that can't be parsed?
17187  "aria-valuenow": this._parse( this.element.val() )
17188  } );
17189  },
17190 
17191  isValid: function() {
17192  var value = this.value();
17193 
17194  // Null is invalid
17195  if ( value === null ) {
17196  return false;
17197  }
17198 
17199  // If value gets adjusted, it's invalid
17200  return value === this._adjustValue( value );
17201  },
17202 
17203  // Update the value without triggering change
17204  _value: function( value, allowAny ) {
17205  var parsed;
17206  if ( value !== "" ) {
17207  parsed = this._parse( value );
17208  if ( parsed !== null ) {
17209  if ( !allowAny ) {
17210  parsed = this._adjustValue( parsed );
17211  }
17212  value = this._format( parsed );
17213  }
17214  }
17215  this.element.val( value );
17216  this._refresh();
17217  },
17218 
17219  _destroy: function() {
17220  this.element
17221  .prop( "disabled", false )
17222  .removeAttr( "autocomplete role aria-valuemin aria-valuemax aria-valuenow" );
17223 
17224  this.uiSpinner.replaceWith( this.element );
17225  },
17226 
17227  stepUp: spinnerModifer( function( steps ) {
17228  this._stepUp( steps );
17229  } ),
17230  _stepUp: function( steps ) {
17231  if ( this._start() ) {
17232  this._spin( ( steps || 1 ) * this.options.step );
17233  this._stop();
17234  }
17235  },
17236 
17237  stepDown: spinnerModifer( function( steps ) {
17238  this._stepDown( steps );
17239  } ),
17240  _stepDown: function( steps ) {
17241  if ( this._start() ) {
17242  this._spin( ( steps || 1 ) * -this.options.step );
17243  this._stop();
17244  }
17245  },
17246 
17247  pageUp: spinnerModifer( function( pages ) {
17248  this._stepUp( ( pages || 1 ) * this.options.page );
17249  } ),
17250 
17251  pageDown: spinnerModifer( function( pages ) {
17252  this._stepDown( ( pages || 1 ) * this.options.page );
17253  } ),
17254 
17255  value: function( newVal ) {
17256  if ( !arguments.length ) {
17257  return this._parse( this.element.val() );
17258  }
17259  spinnerModifer( this._value ).call( this, newVal );
17260  },
17261 
17262  widget: function() {
17263  return this.uiSpinner;
17264  }
17265 } );
17266 
17267 // DEPRECATED
17268 // TODO: switch return back to widget declaration at top of file when this is removed
17269 if ( $.uiBackCompat !== false ) {
17270 
17271  // Backcompat for spinner html extension points
17272  $.widget( "ui.spinner", $.ui.spinner, {
17273  _enhance: function() {
17274  this.uiSpinner = this.element
17275  .attr( "autocomplete", "off" )
17276  .wrap( this._uiSpinnerHtml() )
17277  .parent()
17278 
17279  // Add buttons
17280  .append( this._buttonHtml() );
17281  },
17282  _uiSpinnerHtml: function() {
17283  return "<span>";
17284  },
17285 
17286  _buttonHtml: function() {
17287  return "<a></a><a></a>";
17288  }
17289  } );
17290 }
17291 
17292 var widgetsSpinner = $.ui.spinner;
17293 
17294 
17295 /*!
17296  * jQuery UI Tabs 1.12.1
17297  * http://jqueryui.com
17298  *
17299  * Copyright jQuery Foundation and other contributors
17300  * Released under the MIT license.
17301  * http://jquery.org/license
17302  */
17303 
17304 //>>label: Tabs
17305 //>>group: Widgets
17306 //>>description: Transforms a set of container elements into a tab structure.
17307 //>>docs: http://api.jqueryui.com/tabs/
17308 //>>demos: http://jqueryui.com/tabs/
17309 //>>css.structure: ../../themes/base/core.css
17310 //>>css.structure: ../../themes/base/tabs.css
17311 //>>css.theme: ../../themes/base/theme.css
17312 
17313 
17314 
17315 $.widget( "ui.tabs", {
17316  version: "1.12.1",
17317  delay: 300,
17318  options: {
17319  active: null,
17320  classes: {
17321  "ui-tabs": "ui-corner-all",
17322  "ui-tabs-nav": "ui-corner-all",
17323  "ui-tabs-panel": "ui-corner-bottom",
17324  "ui-tabs-tab": "ui-corner-top"
17325  },
17326  collapsible: false,
17327  event: "click",
17328  heightStyle: "content",
17329  hide: null,
17330  show: null,
17331 
17332  // Callbacks
17333  activate: null,
17334  beforeActivate: null,
17335  beforeLoad: null,
17336  load: null
17337  },
17338 
17339  _isLocal: ( function() {
17340  var rhash = /#.*$/;
17341 
17342  return function( anchor ) {
17343  var anchorUrl, locationUrl;
17344 
17345  anchorUrl = anchor.href.replace( rhash, "" );
17346  locationUrl = location.href.replace( rhash, "" );
17347 
17348  // Decoding may throw an error if the URL isn't UTF-8 (#9518)
17349  try {
17350  anchorUrl = decodeURIComponent( anchorUrl );
17351  } catch ( error ) {}
17352  try {
17353  locationUrl = decodeURIComponent( locationUrl );
17354  } catch ( error ) {}
17355 
17356  return anchor.hash.length > 1 && anchorUrl === locationUrl;
17357  };
17358  } )(),
17359 
17360  _create: function() {
17361  var that = this,
17362  options = this.options;
17363 
17364  this.running = false;
17365 
17366  this._addClass( "ui-tabs", "ui-widget ui-widget-content" );
17367  this._toggleClass( "ui-tabs-collapsible", null, options.collapsible );
17368 
17369  this._processTabs();
17370  options.active = this._initialActive();
17371 
17372  // Take disabling tabs via class attribute from HTML
17373  // into account and update option properly.
17374  if ( $.isArray( options.disabled ) ) {
17375  options.disabled = $.unique( options.disabled.concat(
17376  $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
17377  return that.tabs.index( li );
17378  } )
17379  ) ).sort();
17380  }
17381 
17382  // Check for length avoids error when initializing empty list
17383  if ( this.options.active !== false && this.anchors.length ) {
17384  this.active = this._findActive( options.active );
17385  } else {
17386  this.active = $();
17387  }
17388 
17389  this._refresh();
17390 
17391  if ( this.active.length ) {
17392  this.load( options.active );
17393  }
17394  },
17395 
17396  _initialActive: function() {
17397  var active = this.options.active,
17398  collapsible = this.options.collapsible,
17399  locationHash = location.hash.substring( 1 );
17400 
17401  if ( active === null ) {
17402 
17403  // check the fragment identifier in the URL
17404  if ( locationHash ) {
17405  this.tabs.each( function( i, tab ) {
17406  if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
17407  active = i;
17408  return false;
17409  }
17410  } );
17411  }
17412 
17413  // Check for a tab marked active via a class
17414  if ( active === null ) {
17415  active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
17416  }
17417 
17418  // No active tab, set to false
17419  if ( active === null || active === -1 ) {
17420  active = this.tabs.length ? 0 : false;
17421  }
17422  }
17423 
17424  // Handle numbers: negative, out of range
17425  if ( active !== false ) {
17426  active = this.tabs.index( this.tabs.eq( active ) );
17427  if ( active === -1 ) {
17428  active = collapsible ? false : 0;
17429  }
17430  }
17431 
17432  // Don't allow collapsible: false and active: false
17433  if ( !collapsible && active === false && this.anchors.length ) {
17434  active = 0;
17435  }
17436 
17437  return active;
17438  },
17439 
17440  _getCreateEventData: function() {
17441  return {
17442  tab: this.active,
17443  panel: !this.active.length ? $() : this._getPanelForTab( this.active )
17444  };
17445  },
17446 
17447  _tabKeydown: function( event ) {
17448  var focusedTab = $( $.ui.safeActiveElement( this.document[ 0 ] ) ).closest( "li" ),
17449  selectedIndex = this.tabs.index( focusedTab ),
17450  goingForward = true;
17451 
17452  if ( this._handlePageNav( event ) ) {
17453  return;
17454  }
17455 
17456  switch ( event.keyCode ) {
17457  case $.ui.keyCode.RIGHT:
17458  case $.ui.keyCode.DOWN:
17459  selectedIndex++;
17460  break;
17461  case $.ui.keyCode.UP:
17462  case $.ui.keyCode.LEFT:
17463  goingForward = false;
17464  selectedIndex--;
17465  break;
17466  case $.ui.keyCode.END:
17467  selectedIndex = this.anchors.length - 1;
17468  break;
17469  case $.ui.keyCode.HOME:
17470  selectedIndex = 0;
17471  break;
17472  case $.ui.keyCode.SPACE:
17473 
17474  // Activate only, no collapsing
17475  event.preventDefault();
17476  clearTimeout( this.activating );
17477  this._activate( selectedIndex );
17478  return;
17479  case $.ui.keyCode.ENTER:
17480 
17481  // Toggle (cancel delayed activation, allow collapsing)
17482  event.preventDefault();
17483  clearTimeout( this.activating );
17484 
17485  // Determine if we should collapse or activate
17486  this._activate( selectedIndex === this.options.active ? false : selectedIndex );
17487  return;
17488  default:
17489  return;
17490  }
17491 
17492  // Focus the appropriate tab, based on which key was pressed
17493  event.preventDefault();
17494  clearTimeout( this.activating );
17495  selectedIndex = this._focusNextTab( selectedIndex, goingForward );
17496 
17497  // Navigating with control/command key will prevent automatic activation
17498  if ( !event.ctrlKey && !event.metaKey ) {
17499 
17500  // Update aria-selected immediately so that AT think the tab is already selected.
17501  // Otherwise AT may confuse the user by stating that they need to activate the tab,
17502  // but the tab will already be activated by the time the announcement finishes.
17503  focusedTab.attr( "aria-selected", "false" );
17504  this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
17505 
17506  this.activating = this._delay( function() {
17507  this.option( "active", selectedIndex );
17508  }, this.delay );
17509  }
17510  },
17511 
17512  _panelKeydown: function( event ) {
17513  if ( this._handlePageNav( event ) ) {
17514  return;
17515  }
17516 
17517  // Ctrl+up moves focus to the current tab
17518  if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
17519  event.preventDefault();
17520  this.active.trigger( "focus" );
17521  }
17522  },
17523 
17524  // Alt+page up/down moves focus to the previous/next tab (and activates)
17525  _handlePageNav: function( event ) {
17526  if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
17527  this._activate( this._focusNextTab( this.options.active - 1, false ) );
17528  return true;
17529  }
17530  if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
17531  this._activate( this._focusNextTab( this.options.active + 1, true ) );
17532  return true;
17533  }
17534  },
17535 
17536  _findNextTab: function( index, goingForward ) {
17537  var lastTabIndex = this.tabs.length - 1;
17538 
17539  function constrain() {
17540  if ( index > lastTabIndex ) {
17541  index = 0;
17542  }
17543  if ( index < 0 ) {
17544  index = lastTabIndex;
17545  }
17546  return index;
17547  }
17548 
17549  while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
17550  index = goingForward ? index + 1 : index - 1;
17551  }
17552 
17553  return index;
17554  },
17555 
17556  _focusNextTab: function( index, goingForward ) {
17557  index = this._findNextTab( index, goingForward );
17558  this.tabs.eq( index ).trigger( "focus" );
17559  return index;
17560  },
17561 
17562  _setOption: function( key, value ) {
17563  if ( key === "active" ) {
17564 
17565  // _activate() will handle invalid values and update this.options
17566  this._activate( value );
17567  return;
17568  }
17569 
17570  this._super( key, value );
17571 
17572  if ( key === "collapsible" ) {
17573  this._toggleClass( "ui-tabs-collapsible", null, value );
17574 
17575  // Setting collapsible: false while collapsed; open first panel
17576  if ( !value && this.options.active === false ) {
17577  this._activate( 0 );
17578  }
17579  }
17580 
17581  if ( key === "event" ) {
17582  this._setupEvents( value );
17583  }
17584 
17585  if ( key === "heightStyle" ) {
17586  this._setupHeightStyle( value );
17587  }
17588  },
17589 
17590  _sanitizeSelector: function( hash ) {
17591  return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
17592  },
17593 
17594  refresh: function() {
17595  var options = this.options,
17596  lis = this.tablist.children( ":has(a[href])" );
17597 
17598  // Get disabled tabs from class attribute from HTML
17599  // this will get converted to a boolean if needed in _refresh()
17600  options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
17601  return lis.index( tab );
17602  } );
17603 
17604  this._processTabs();
17605 
17606  // Was collapsed or no tabs
17607  if ( options.active === false || !this.anchors.length ) {
17608  options.active = false;
17609  this.active = $();
17610 
17611  // was active, but active tab is gone
17612  } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
17613 
17614  // all remaining tabs are disabled
17615  if ( this.tabs.length === options.disabled.length ) {
17616  options.active = false;
17617  this.active = $();
17618 
17619  // activate previous tab
17620  } else {
17621  this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
17622  }
17623 
17624  // was active, active tab still exists
17625  } else {
17626 
17627  // make sure active index is correct
17628  options.active = this.tabs.index( this.active );
17629  }
17630 
17631  this._refresh();
17632  },
17633 
17634  _refresh: function() {
17635  this._setOptionDisabled( this.options.disabled );
17636  this._setupEvents( this.options.event );
17637  this._setupHeightStyle( this.options.heightStyle );
17638 
17639  this.tabs.not( this.active ).attr( {
17640  "aria-selected": "false",
17641  "aria-expanded": "false",
17642  tabIndex: -1
17643  } );
17644  this.panels.not( this._getPanelForTab( this.active ) )
17645  .hide()
17646  .attr( {
17647  "aria-hidden": "true"
17648  } );
17649 
17650  // Make sure one tab is in the tab order
17651  if ( !this.active.length ) {
17652  this.tabs.eq( 0 ).attr( "tabIndex", 0 );
17653  } else {
17654  this.active
17655  .attr( {
17656  "aria-selected": "true",
17657  "aria-expanded": "true",
17658  tabIndex: 0
17659  } );
17660  this._addClass( this.active, "ui-tabs-active", "ui-state-active" );
17661  this._getPanelForTab( this.active )
17662  .show()
17663  .attr( {
17664  "aria-hidden": "false"
17665  } );
17666  }
17667  },
17668 
17669  _processTabs: function() {
17670  var that = this,
17671  prevTabs = this.tabs,
17672  prevAnchors = this.anchors,
17673  prevPanels = this.panels;
17674 
17675  this.tablist = this._getList().attr( "role", "tablist" );
17676  this._addClass( this.tablist, "ui-tabs-nav",
17677  "ui-helper-reset ui-helper-clearfix ui-widget-header" );
17678 
17679  // Prevent users from focusing disabled tabs via click
17680  this.tablist
17681  .on( "mousedown" + this.eventNamespace, "> li", function( event ) {
17682  if ( $( this ).is( ".ui-state-disabled" ) ) {
17683  event.preventDefault();
17684  }
17685  } )
17686 
17687  // Support: IE <9
17688  // Preventing the default action in mousedown doesn't prevent IE
17689  // from focusing the element, so if the anchor gets focused, blur.
17690  // We don't have to worry about focusing the previously focused
17691  // element since clicking on a non-focusable element should focus
17692  // the body anyway.
17693  .on( "focus" + this.eventNamespace, ".ui-tabs-anchor", function() {
17694  if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
17695  this.blur();
17696  }
17697  } );
17698 
17699  this.tabs = this.tablist.find( "> li:has(a[href])" )
17700  .attr( {
17701  role: "tab",
17702  tabIndex: -1
17703  } );
17704  this._addClass( this.tabs, "ui-tabs-tab", "ui-state-default" );
17705 
17706  this.anchors = this.tabs.map( function() {
17707  return $( "a", this )[ 0 ];
17708  } )
17709  .attr( {
17710  role: "presentation",
17711  tabIndex: -1
17712  } );
17713  this._addClass( this.anchors, "ui-tabs-anchor" );
17714 
17715  this.panels = $();
17716 
17717  this.anchors.each( function( i, anchor ) {
17718  var selector, panel, panelId,
17719  anchorId = $( anchor ).uniqueId().attr( "id" ),
17720  tab = $( anchor ).closest( "li" ),
17721  originalAriaControls = tab.attr( "aria-controls" );
17722 
17723  // Inline tab
17724  if ( that._isLocal( anchor ) ) {
17725  selector = anchor.hash;
17726  panelId = selector.substring( 1 );
17727  panel = that.element.find( that._sanitizeSelector( selector ) );
17728 
17729  // remote tab
17730  } else {
17731 
17732  // If the tab doesn't already have aria-controls,
17733  // generate an id by using a throw-away element
17734  panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
17735  selector = "#" + panelId;
17736  panel = that.element.find( selector );
17737  if ( !panel.length ) {
17738  panel = that._createPanel( panelId );
17739  panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
17740  }
17741  panel.attr( "aria-live", "polite" );
17742  }
17743 
17744  if ( panel.length ) {
17745  that.panels = that.panels.add( panel );
17746  }
17747  if ( originalAriaControls ) {
17748  tab.data( "ui-tabs-aria-controls", originalAriaControls );
17749  }
17750  tab.attr( {
17751  "aria-controls": panelId,
17752  "aria-labelledby": anchorId
17753  } );
17754  panel.attr( "aria-labelledby", anchorId );
17755  } );
17756 
17757  this.panels.attr( "role", "tabpanel" );
17758  this._addClass( this.panels, "ui-tabs-panel", "ui-widget-content" );
17759 
17760  // Avoid memory leaks (#10056)
17761  if ( prevTabs ) {
17762  this._off( prevTabs.not( this.tabs ) );
17763  this._off( prevAnchors.not( this.anchors ) );
17764  this._off( prevPanels.not( this.panels ) );
17765  }
17766  },
17767 
17768  // Allow overriding how to find the list for rare usage scenarios (#7715)
17769  _getList: function() {
17770  return this.tablist || this.element.find( "ol, ul" ).eq( 0 );
17771  },
17772 
17773  _createPanel: function( id ) {
17774  return $( "<div>" )
17775  .attr( "id", id )
17776  .data( "ui-tabs-destroy", true );
17777  },
17778 
17779  _setOptionDisabled: function( disabled ) {
17780  var currentItem, li, i;
17781 
17782  if ( $.isArray( disabled ) ) {
17783  if ( !disabled.length ) {
17784  disabled = false;
17785  } else if ( disabled.length === this.anchors.length ) {
17786  disabled = true;
17787  }
17788  }
17789 
17790  // Disable tabs
17791  for ( i = 0; ( li = this.tabs[ i ] ); i++ ) {
17792  currentItem = $( li );
17793  if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
17794  currentItem.attr( "aria-disabled", "true" );
17795  this._addClass( currentItem, null, "ui-state-disabled" );
17796  } else {
17797  currentItem.removeAttr( "aria-disabled" );
17798  this._removeClass( currentItem, null, "ui-state-disabled" );
17799  }
17800  }
17801 
17802  this.options.disabled = disabled;
17803 
17804  this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null,
17805  disabled === true );
17806  },
17807 
17808  _setupEvents: function( event ) {
17809  var events = {};
17810  if ( event ) {
17811  $.each( event.split( " " ), function( index, eventName ) {
17812  events[ eventName ] = "_eventHandler";
17813  } );
17814  }
17815 
17816  this._off( this.anchors.add( this.tabs ).add( this.panels ) );
17817 
17818  // Always prevent the default action, even when disabled
17819  this._on( true, this.anchors, {
17820  click: function( event ) {
17821  event.preventDefault();
17822  }
17823  } );
17824  this._on( this.anchors, events );
17825  this._on( this.tabs, { keydown: "_tabKeydown" } );
17826  this._on( this.panels, { keydown: "_panelKeydown" } );
17827 
17828  this._focusable( this.tabs );
17829  this._hoverable( this.tabs );
17830  },
17831 
17832  _setupHeightStyle: function( heightStyle ) {
17833  var maxHeight,
17834  parent = this.element.parent();
17835 
17836  if ( heightStyle === "fill" ) {
17837  maxHeight = parent.height();
17838  maxHeight -= this.element.outerHeight() - this.element.height();
17839 
17840  this.element.siblings( ":visible" ).each( function() {
17841  var elem = $( this ),
17842  position = elem.css( "position" );
17843 
17844  if ( position === "absolute" || position === "fixed" ) {
17845  return;
17846  }
17847  maxHeight -= elem.outerHeight( true );
17848  } );
17849 
17850  this.element.children().not( this.panels ).each( function() {
17851  maxHeight -= $( this ).outerHeight( true );
17852  } );
17853 
17854  this.panels.each( function() {
17855  $( this ).height( Math.max( 0, maxHeight -
17856  $( this ).innerHeight() + $( this ).height() ) );
17857  } )
17858  .css( "overflow", "auto" );
17859  } else if ( heightStyle === "auto" ) {
17860  maxHeight = 0;
17861  this.panels.each( function() {
17862  maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
17863  } ).height( maxHeight );
17864  }
17865  },
17866 
17867  _eventHandler: function( event ) {
17868  var options = this.options,
17869  active = this.active,
17870  anchor = $( event.currentTarget ),
17871  tab = anchor.closest( "li" ),
17872  clickedIsActive = tab[ 0 ] === active[ 0 ],
17873  collapsing = clickedIsActive && options.collapsible,
17874  toShow = collapsing ? $() : this._getPanelForTab( tab ),
17875  toHide = !active.length ? $() : this._getPanelForTab( active ),
17876  eventData = {
17877  oldTab: active,
17878  oldPanel: toHide,
17879  newTab: collapsing ? $() : tab,
17880  newPanel: toShow
17881  };
17882 
17883  event.preventDefault();
17884 
17885  if ( tab.hasClass( "ui-state-disabled" ) ||
17886 
17887  // tab is already loading
17888  tab.hasClass( "ui-tabs-loading" ) ||
17889 
17890  // can't switch durning an animation
17891  this.running ||
17892 
17893  // click on active header, but not collapsible
17894  ( clickedIsActive && !options.collapsible ) ||
17895 
17896  // allow canceling activation
17897  ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
17898  return;
17899  }
17900 
17901  options.active = collapsing ? false : this.tabs.index( tab );
17902 
17903  this.active = clickedIsActive ? $() : tab;
17904  if ( this.xhr ) {
17905  this.xhr.abort();
17906  }
17907 
17908  if ( !toHide.length && !toShow.length ) {
17909  $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
17910  }
17911 
17912  if ( toShow.length ) {
17913  this.load( this.tabs.index( tab ), event );
17914  }
17915  this._toggle( event, eventData );
17916  },
17917 
17918  // Handles show/hide for selecting tabs
17919  _toggle: function( event, eventData ) {
17920  var that = this,
17921  toShow = eventData.newPanel,
17922  toHide = eventData.oldPanel;
17923 
17924  this.running = true;
17925 
17926  function complete() {
17927  that.running = false;
17928  that._trigger( "activate", event, eventData );
17929  }
17930 
17931  function show() {
17932  that._addClass( eventData.newTab.closest( "li" ), "ui-tabs-active", "ui-state-active" );
17933 
17934  if ( toShow.length && that.options.show ) {
17935  that._show( toShow, that.options.show, complete );
17936  } else {
17937  toShow.show();
17938  complete();
17939  }
17940  }
17941 
17942  // Start out by hiding, then showing, then completing
17943  if ( toHide.length && this.options.hide ) {
17944  this._hide( toHide, this.options.hide, function() {
17945  that._removeClass( eventData.oldTab.closest( "li" ),
17946  "ui-tabs-active", "ui-state-active" );
17947  show();
17948  } );
17949  } else {
17950  this._removeClass( eventData.oldTab.closest( "li" ),
17951  "ui-tabs-active", "ui-state-active" );
17952  toHide.hide();
17953  show();
17954  }
17955 
17956  toHide.attr( "aria-hidden", "true" );
17957  eventData.oldTab.attr( {
17958  "aria-selected": "false",
17959  "aria-expanded": "false"
17960  } );
17961 
17962  // If we're switching tabs, remove the old tab from the tab order.
17963  // If we're opening from collapsed state, remove the previous tab from the tab order.
17964  // If we're collapsing, then keep the collapsing tab in the tab order.
17965  if ( toShow.length && toHide.length ) {
17966  eventData.oldTab.attr( "tabIndex", -1 );
17967  } else if ( toShow.length ) {
17968  this.tabs.filter( function() {
17969  return $( this ).attr( "tabIndex" ) === 0;
17970  } )
17971  .attr( "tabIndex", -1 );
17972  }
17973 
17974  toShow.attr( "aria-hidden", "false" );
17975  eventData.newTab.attr( {
17976  "aria-selected": "true",
17977  "aria-expanded": "true",
17978  tabIndex: 0
17979  } );
17980  },
17981 
17982  _activate: function( index ) {
17983  var anchor,
17984  active = this._findActive( index );
17985 
17986  // Trying to activate the already active panel
17987  if ( active[ 0 ] === this.active[ 0 ] ) {
17988  return;
17989  }
17990 
17991  // Trying to collapse, simulate a click on the current active header
17992  if ( !active.length ) {
17993  active = this.active;
17994  }
17995 
17996  anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
17997  this._eventHandler( {
17998  target: anchor,
17999  currentTarget: anchor,
18000  preventDefault: $.noop
18001  } );
18002  },
18003 
18004  _findActive: function( index ) {
18005  return index === false ? $() : this.tabs.eq( index );
18006  },
18007 
18008  _getIndex: function( index ) {
18009 
18010  // meta-function to give users option to provide a href string instead of a numerical index.
18011  if ( typeof index === "string" ) {
18012  index = this.anchors.index( this.anchors.filter( "[href$='" +
18013  $.ui.escapeSelector( index ) + "']" ) );
18014  }
18015 
18016  return index;
18017  },
18018 
18019  _destroy: function() {
18020  if ( this.xhr ) {
18021  this.xhr.abort();
18022  }
18023 
18024  this.tablist
18025  .removeAttr( "role" )
18026  .off( this.eventNamespace );
18027 
18028  this.anchors
18029  .removeAttr( "role tabIndex" )
18030  .removeUniqueId();
18031 
18032  this.tabs.add( this.panels ).each( function() {
18033  if ( $.data( this, "ui-tabs-destroy" ) ) {
18034  $( this ).remove();
18035  } else {
18036  $( this ).removeAttr( "role tabIndex " +
18037  "aria-live aria-busy aria-selected aria-labelledby aria-hidden aria-expanded" );
18038  }
18039  } );
18040 
18041  this.tabs.each( function() {
18042  var li = $( this ),
18043  prev = li.data( "ui-tabs-aria-controls" );
18044  if ( prev ) {
18045  li
18046  .attr( "aria-controls", prev )
18047  .removeData( "ui-tabs-aria-controls" );
18048  } else {
18049  li.removeAttr( "aria-controls" );
18050  }
18051  } );
18052 
18053  this.panels.show();
18054 
18055  if ( this.options.heightStyle !== "content" ) {
18056  this.panels.css( "height", "" );
18057  }
18058  },
18059 
18060  enable: function( index ) {
18061  var disabled = this.options.disabled;
18062  if ( disabled === false ) {
18063  return;
18064  }
18065 
18066  if ( index === undefined ) {
18067  disabled = false;
18068  } else {
18069  index = this._getIndex( index );
18070  if ( $.isArray( disabled ) ) {
18071  disabled = $.map( disabled, function( num ) {
18072  return num !== index ? num : null;
18073  } );
18074  } else {
18075  disabled = $.map( this.tabs, function( li, num ) {
18076  return num !== index ? num : null;
18077  } );
18078  }
18079  }
18080  this._setOptionDisabled( disabled );
18081  },
18082 
18083  disable: function( index ) {
18084  var disabled = this.options.disabled;
18085  if ( disabled === true ) {
18086  return;
18087  }
18088 
18089  if ( index === undefined ) {
18090  disabled = true;
18091  } else {
18092  index = this._getIndex( index );
18093  if ( $.inArray( index, disabled ) !== -1 ) {
18094  return;
18095  }
18096  if ( $.isArray( disabled ) ) {
18097  disabled = $.merge( [ index ], disabled ).sort();
18098  } else {
18099  disabled = [ index ];
18100  }
18101  }
18102  this._setOptionDisabled( disabled );
18103  },
18104 
18105  load: function( index, event ) {
18106  index = this._getIndex( index );
18107  var that = this,
18108  tab = this.tabs.eq( index ),
18109  anchor = tab.find( ".ui-tabs-anchor" ),
18110  panel = this._getPanelForTab( tab ),
18111  eventData = {
18112  tab: tab,
18113  panel: panel
18114  },
18115  complete = function( jqXHR, status ) {
18116  if ( status === "abort" ) {
18117  that.panels.stop( false, true );
18118  }
18119 
18120  that._removeClass( tab, "ui-tabs-loading" );
18121  panel.removeAttr( "aria-busy" );
18122 
18123  if ( jqXHR === that.xhr ) {
18124  delete that.xhr;
18125  }
18126  };
18127 
18128  // Not remote
18129  if ( this._isLocal( anchor[ 0 ] ) ) {
18130  return;
18131  }
18132 
18133  this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
18134 
18135  // Support: jQuery <1.8
18136  // jQuery <1.8 returns false if the request is canceled in beforeSend,
18137  // but as of 1.8, $.ajax() always returns a jqXHR object.
18138  if ( this.xhr && this.xhr.statusText !== "canceled" ) {
18139  this._addClass( tab, "ui-tabs-loading" );
18140  panel.attr( "aria-busy", "true" );
18141 
18142  this.xhr
18143  .done( function( response, status, jqXHR ) {
18144 
18145  // support: jQuery <1.8
18146  // http://bugs.jquery.com/ticket/11778
18147  setTimeout( function() {
18148  panel.html( response );
18149  that._trigger( "load", event, eventData );
18150 
18151  complete( jqXHR, status );
18152  }, 1 );
18153  } )
18154  .fail( function( jqXHR, status ) {
18155 
18156  // support: jQuery <1.8
18157  // http://bugs.jquery.com/ticket/11778
18158  setTimeout( function() {
18159  complete( jqXHR, status );
18160  }, 1 );
18161  } );
18162  }
18163  },
18164 
18165  _ajaxSettings: function( anchor, event, eventData ) {
18166  var that = this;
18167  return {
18168 
18169  // Support: IE <11 only
18170  // Strip any hash that exists to prevent errors with the Ajax request
18171  url: anchor.attr( "href" ).replace( /#.*$/, "" ),
18172  beforeSend: function( jqXHR, settings ) {
18173  return that._trigger( "beforeLoad", event,
18174  $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
18175  }
18176  };
18177  },
18178 
18179  _getPanelForTab: function( tab ) {
18180  var id = $( tab ).attr( "aria-controls" );
18181  return this.element.find( this._sanitizeSelector( "#" + id ) );
18182  }
18183 } );
18184 
18185 // DEPRECATED
18186 // TODO: Switch return back to widget declaration at top of file when this is removed
18187 if ( $.uiBackCompat !== false ) {
18188 
18189  // Backcompat for ui-tab class (now ui-tabs-tab)
18190  $.widget( "ui.tabs", $.ui.tabs, {
18191  _processTabs: function() {
18192  this._superApply( arguments );
18193  this._addClass( this.tabs, "ui-tab" );
18194  }
18195  } );
18196 }
18197 
18198 var widgetsTabs = $.ui.tabs;
18199 
18200 
18201 /*!
18202  * jQuery UI Tooltip 1.12.1
18203  * http://jqueryui.com
18204  *
18205  * Copyright jQuery Foundation and other contributors
18206  * Released under the MIT license.
18207  * http://jquery.org/license
18208  */
18209 
18210 //>>label: Tooltip
18211 //>>group: Widgets
18212 //>>description: Shows additional information for any element on hover or focus.
18213 //>>docs: http://api.jqueryui.com/tooltip/
18214 //>>demos: http://jqueryui.com/tooltip/
18215 //>>css.structure: ../../themes/base/core.css
18216 //>>css.structure: ../../themes/base/tooltip.css
18217 //>>css.theme: ../../themes/base/theme.css
18218 
18219 
18220 
18221 $.widget( "ui.tooltip", {
18222  version: "1.12.1",
18223  options: {
18224  classes: {
18225  "ui-tooltip": "ui-corner-all ui-widget-shadow"
18226  },
18227  content: function() {
18228 
18229  // support: IE<9, Opera in jQuery <1.7
18230  // .text() can't accept undefined, so coerce to a string
18231  var title = $( this ).attr( "title" ) || "";
18232 
18233  // Escape title, since we're going from an attribute to raw HTML
18234  return $( "<a>" ).text( title ).html();
18235  },
18236  hide: true,
18237 
18238  // Disabled elements have inconsistent behavior across browsers (#8661)
18239  items: "[title]:not([disabled])",
18240  position: {
18241  my: "left top+15",
18242  at: "left bottom",
18243  collision: "flipfit flip"
18244  },
18245  show: true,
18246  track: false,
18247 
18248  // Callbacks
18249  close: null,
18250  open: null
18251  },
18252 
18253  _addDescribedBy: function( elem, id ) {
18254  var describedby = ( elem.attr( "aria-describedby" ) || "" ).split( /\s+/ );
18255  describedby.push( id );
18256  elem
18257  .data( "ui-tooltip-id", id )
18258  .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
18259  },
18260 
18261  _removeDescribedBy: function( elem ) {
18262  var id = elem.data( "ui-tooltip-id" ),
18263  describedby = ( elem.attr( "aria-describedby" ) || "" ).split( /\s+/ ),
18264  index = $.inArray( id, describedby );
18265 
18266  if ( index !== -1 ) {
18267  describedby.splice( index, 1 );
18268  }
18269 
18270  elem.removeData( "ui-tooltip-id" );
18271  describedby = $.trim( describedby.join( " " ) );
18272  if ( describedby ) {
18273  elem.attr( "aria-describedby", describedby );
18274  } else {
18275  elem.removeAttr( "aria-describedby" );
18276  }
18277  },
18278 
18279  _create: function() {
18280  this._on( {
18281  mouseover: "open",
18282  focusin: "open"
18283  } );
18284 
18285  // IDs of generated tooltips, needed for destroy
18286  this.tooltips = {};
18287 
18288  // IDs of parent tooltips where we removed the title attribute
18289  this.parents = {};
18290 
18291  // Append the aria-live region so tooltips announce correctly
18292  this.liveRegion = $( "<div>" )
18293  .attr( {
18294  role: "log",
18295  "aria-live": "assertive",
18296  "aria-relevant": "additions"
18297  } )
18298  .appendTo( this.document[ 0 ].body );
18299  this._addClass( this.liveRegion, null, "ui-helper-hidden-accessible" );
18300 
18301  this.disabledTitles = $( [] );
18302  },
18303 
18304  _setOption: function( key, value ) {
18305  var that = this;
18306 
18307  this._super( key, value );
18308 
18309  if ( key === "content" ) {
18310  $.each( this.tooltips, function( id, tooltipData ) {
18311  that._updateContent( tooltipData.element );
18312  } );
18313  }
18314  },
18315 
18316  _setOptionDisabled: function( value ) {
18317  this[ value ? "_disable" : "_enable" ]();
18318  },
18319 
18320  _disable: function() {
18321  var that = this;
18322 
18323  // Close open tooltips
18324  $.each( this.tooltips, function( id, tooltipData ) {
18325  var event = $.Event( "blur" );
18326  event.target = event.currentTarget = tooltipData.element[ 0 ];
18327  that.close( event, true );
18328  } );
18329 
18330  // Remove title attributes to prevent native tooltips
18331  this.disabledTitles = this.disabledTitles.add(
18332  this.element.find( this.options.items ).addBack()
18333  .filter( function() {
18334  var element = $( this );
18335  if ( element.is( "[title]" ) ) {
18336  return element
18337  .data( "ui-tooltip-title", element.attr( "title" ) )
18338  .removeAttr( "title" );
18339  }
18340  } )
18341  );
18342  },
18343 
18344  _enable: function() {
18345 
18346  // restore title attributes
18347  this.disabledTitles.each( function() {
18348  var element = $( this );
18349  if ( element.data( "ui-tooltip-title" ) ) {
18350  element.attr( "title", element.data( "ui-tooltip-title" ) );
18351  }
18352  } );
18353  this.disabledTitles = $( [] );
18354  },
18355 
18356  open: function( event ) {
18357  var that = this,
18358  target = $( event ? event.target : this.element )
18359 
18360  // we need closest here due to mouseover bubbling,
18361  // but always pointing at the same event target
18362  .closest( this.options.items );
18363 
18364  // No element to show a tooltip for or the tooltip is already open
18365  if ( !target.length || target.data( "ui-tooltip-id" ) ) {
18366  return;
18367  }
18368 
18369  if ( target.attr( "title" ) ) {
18370  target.data( "ui-tooltip-title", target.attr( "title" ) );
18371  }
18372 
18373  target.data( "ui-tooltip-open", true );
18374 
18375  // Kill parent tooltips, custom or native, for hover
18376  if ( event && event.type === "mouseover" ) {
18377  target.parents().each( function() {
18378  var parent = $( this ),
18379  blurEvent;
18380  if ( parent.data( "ui-tooltip-open" ) ) {
18381  blurEvent = $.Event( "blur" );
18382  blurEvent.target = blurEvent.currentTarget = this;
18383  that.close( blurEvent, true );
18384  }
18385  if ( parent.attr( "title" ) ) {
18386  parent.uniqueId();
18387  that.parents[ this.id ] = {
18388  element: this,
18389  title: parent.attr( "title" )
18390  };
18391  parent.attr( "title", "" );
18392  }
18393  } );
18394  }
18395 
18396  this._registerCloseHandlers( event, target );
18397  this._updateContent( target, event );
18398  },
18399 
18400  _updateContent: function( target, event ) {
18401  var content,
18402  contentOption = this.options.content,
18403  that = this,
18404  eventType = event ? event.type : null;
18405 
18406  if ( typeof contentOption === "string" || contentOption.nodeType ||
18407  contentOption.jquery ) {
18408  return this._open( event, target, contentOption );
18409  }
18410 
18411  content = contentOption.call( target[ 0 ], function( response ) {
18412 
18413  // IE may instantly serve a cached response for ajax requests
18414  // delay this call to _open so the other call to _open runs first
18415  that._delay( function() {
18416 
18417  // Ignore async response if tooltip was closed already
18418  if ( !target.data( "ui-tooltip-open" ) ) {
18419  return;
18420  }
18421 
18422  // JQuery creates a special event for focusin when it doesn't
18423  // exist natively. To improve performance, the native event
18424  // object is reused and the type is changed. Therefore, we can't
18425  // rely on the type being correct after the event finished
18426  // bubbling, so we set it back to the previous value. (#8740)
18427  if ( event ) {
18428  event.type = eventType;
18429  }
18430  this._open( event, target, response );
18431  } );
18432  } );
18433  if ( content ) {
18434  this._open( event, target, content );
18435  }
18436  },
18437 
18438  _open: function( event, target, content ) {
18439  var tooltipData, tooltip, delayedShow, a11yContent,
18440  positionOption = $.extend( {}, this.options.position );
18441 
18442  if ( !content ) {
18443  return;
18444  }
18445 
18446  // Content can be updated multiple times. If the tooltip already
18447  // exists, then just update the content and bail.
18448  tooltipData = this._find( target );
18449  if ( tooltipData ) {
18450  tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );
18451  return;
18452  }
18453 
18454  // If we have a title, clear it to prevent the native tooltip
18455  // we have to check first to avoid defining a title if none exists
18456  // (we don't want to cause an element to start matching [title])
18457  //
18458  // We use removeAttr only for key events, to allow IE to export the correct
18459  // accessible attributes. For mouse events, set to empty string to avoid
18460  // native tooltip showing up (happens only when removing inside mouseover).
18461  if ( target.is( "[title]" ) ) {
18462  if ( event && event.type === "mouseover" ) {
18463  target.attr( "title", "" );
18464  } else {
18465  target.removeAttr( "title" );
18466  }
18467  }
18468 
18469  tooltipData = this._tooltip( target );
18470  tooltip = tooltipData.tooltip;
18471  this._addDescribedBy( target, tooltip.attr( "id" ) );
18472  tooltip.find( ".ui-tooltip-content" ).html( content );
18473 
18474  // Support: Voiceover on OS X, JAWS on IE <= 9
18475  // JAWS announces deletions even when aria-relevant="additions"
18476  // Voiceover will sometimes re-read the entire log region's contents from the beginning
18477  this.liveRegion.children().hide();
18478  a11yContent = $( "<div>" ).html( tooltip.find( ".ui-tooltip-content" ).html() );
18479  a11yContent.removeAttr( "name" ).find( "[name]" ).removeAttr( "name" );
18480  a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );
18481  a11yContent.appendTo( this.liveRegion );
18482 
18483  function position( event ) {
18484  positionOption.of = event;
18485  if ( tooltip.is( ":hidden" ) ) {
18486  return;
18487  }
18488  tooltip.position( positionOption );
18489  }
18490  if ( this.options.track && event && /^mouse/.test( event.type ) ) {
18491  this._on( this.document, {
18492  mousemove: position
18493  } );
18494 
18495  // trigger once to override element-relative positioning
18496  position( event );
18497  } else {
18498  tooltip.position( $.extend( {
18499  of: target
18500  }, this.options.position ) );
18501  }
18502 
18503  tooltip.hide();
18504 
18505  this._show( tooltip, this.options.show );
18506 
18507  // Handle tracking tooltips that are shown with a delay (#8644). As soon
18508  // as the tooltip is visible, position the tooltip using the most recent
18509  // event.
18510  // Adds the check to add the timers only when both delay and track options are set (#14682)
18511  if ( this.options.track && this.options.show && this.options.show.delay ) {
18512  delayedShow = this.delayedShow = setInterval( function() {
18513  if ( tooltip.is( ":visible" ) ) {
18514  position( positionOption.of );
18515  clearInterval( delayedShow );
18516  }
18517  }, $.fx.interval );
18518  }
18519 
18520  this._trigger( "open", event, { tooltip: tooltip } );
18521  },
18522 
18523  _registerCloseHandlers: function( event, target ) {
18524  var events = {
18525  keyup: function( event ) {
18526  if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
18527  var fakeEvent = $.Event( event );
18528  fakeEvent.currentTarget = target[ 0 ];
18529  this.close( fakeEvent, true );
18530  }
18531  }
18532  };
18533 
18534  // Only bind remove handler for delegated targets. Non-delegated
18535  // tooltips will handle this in destroy.
18536  if ( target[ 0 ] !== this.element[ 0 ] ) {
18537  events.remove = function() {
18538  this._removeTooltip( this._find( target ).tooltip );
18539  };
18540  }
18541 
18542  if ( !event || event.type === "mouseover" ) {
18543  events.mouseleave = "close";
18544  }
18545  if ( !event || event.type === "focusin" ) {
18546  events.focusout = "close";
18547  }
18548  this._on( true, target, events );
18549  },
18550 
18551  close: function( event ) {
18552  var tooltip,
18553  that = this,
18554  target = $( event ? event.currentTarget : this.element ),
18555  tooltipData = this._find( target );
18556 
18557  // The tooltip may already be closed
18558  if ( !tooltipData ) {
18559 
18560  // We set ui-tooltip-open immediately upon open (in open()), but only set the
18561  // additional data once there's actually content to show (in _open()). So even if the
18562  // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
18563  // the period between open() and _open().
18564  target.removeData( "ui-tooltip-open" );
18565  return;
18566  }
18567 
18568  tooltip = tooltipData.tooltip;
18569 
18570  // Disabling closes the tooltip, so we need to track when we're closing
18571  // to avoid an infinite loop in case the tooltip becomes disabled on close
18572  if ( tooltipData.closing ) {
18573  return;
18574  }
18575 
18576  // Clear the interval for delayed tracking tooltips
18577  clearInterval( this.delayedShow );
18578 
18579  // Only set title if we had one before (see comment in _open())
18580  // If the title attribute has changed since open(), don't restore
18581  if ( target.data( "ui-tooltip-title" ) && !target.attr( "title" ) ) {
18582  target.attr( "title", target.data( "ui-tooltip-title" ) );
18583  }
18584 
18585  this._removeDescribedBy( target );
18586 
18587  tooltipData.hiding = true;
18588  tooltip.stop( true );
18589  this._hide( tooltip, this.options.hide, function() {
18590  that._removeTooltip( $( this ) );
18591  } );
18592 
18593  target.removeData( "ui-tooltip-open" );
18594  this._off( target, "mouseleave focusout keyup" );
18595 
18596  // Remove 'remove' binding only on delegated targets
18597  if ( target[ 0 ] !== this.element[ 0 ] ) {
18598  this._off( target, "remove" );
18599  }
18600  this._off( this.document, "mousemove" );
18601 
18602  if ( event && event.type === "mouseleave" ) {
18603  $.each( this.parents, function( id, parent ) {
18604  $( parent.element ).attr( "title", parent.title );
18605  delete that.parents[ id ];
18606  } );
18607  }
18608 
18609  tooltipData.closing = true;
18610  this._trigger( "close", event, { tooltip: tooltip } );
18611  if ( !tooltipData.hiding ) {
18612  tooltipData.closing = false;
18613  }
18614  },
18615 
18616  _tooltip: function( element ) {
18617  var tooltip = $( "<div>" ).attr( "role", "tooltip" ),
18618  content = $( "<div>" ).appendTo( tooltip ),
18619  id = tooltip.uniqueId().attr( "id" );
18620 
18621  this._addClass( content, "ui-tooltip-content" );
18622  this._addClass( tooltip, "ui-tooltip", "ui-widget ui-widget-content" );
18623 
18624  tooltip.appendTo( this._appendTo( element ) );
18625 
18626  return this.tooltips[ id ] = {
18627  element: element,
18628  tooltip: tooltip
18629  };
18630  },
18631 
18632  _find: function( target ) {
18633  var id = target.data( "ui-tooltip-id" );
18634  return id ? this.tooltips[ id ] : null;
18635  },
18636 
18637  _removeTooltip: function( tooltip ) {
18638  tooltip.remove();
18639  delete this.tooltips[ tooltip.attr( "id" ) ];
18640  },
18641 
18642  _appendTo: function( target ) {
18643  var element = target.closest( ".ui-front, dialog" );
18644 
18645  if ( !element.length ) {
18646  element = this.document[ 0 ].body;
18647  }
18648 
18649  return element;
18650  },
18651 
18652  _destroy: function() {
18653  var that = this;
18654 
18655  // Close open tooltips
18656  $.each( this.tooltips, function( id, tooltipData ) {
18657 
18658  // Delegate to close method to handle common cleanup
18659  var event = $.Event( "blur" ),
18660  element = tooltipData.element;
18661  event.target = event.currentTarget = element[ 0 ];
18662  that.close( event, true );
18663 
18664  // Remove immediately; destroying an open tooltip doesn't use the
18665  // hide animation
18666  $( "#" + id ).remove();
18667 
18668  // Restore the title
18669  if ( element.data( "ui-tooltip-title" ) ) {
18670 
18671  // If the title attribute has changed since open(), don't restore
18672  if ( !element.attr( "title" ) ) {
18673  element.attr( "title", element.data( "ui-tooltip-title" ) );
18674  }
18675  element.removeData( "ui-tooltip-title" );
18676  }
18677  } );
18678  this.liveRegion.remove();
18679  }
18680 } );
18681 
18682 // DEPRECATED
18683 // TODO: Switch return back to widget declaration at top of file when this is removed
18684 if ( $.uiBackCompat !== false ) {
18685 
18686  // Backcompat for tooltipClass option
18687  $.widget( "ui.tooltip", $.ui.tooltip, {
18688  options: {
18689  tooltipClass: null
18690  },
18691  _tooltip: function() {
18692  var tooltipData = this._superApply( arguments );
18693  if ( this.options.tooltipClass ) {
18694  tooltipData.tooltip.addClass( this.options.tooltipClass );
18695  }
18696  return tooltipData;
18697  }
18698  } );
18699 }
18700 
18701 var widgetsTooltip = $.ui.tooltip;
18702 
18703 
18704 
18705 
18706 }));