Debian Codegraph @

maven-plugin-tools-api/src/test/resources/javadoc/jdk17/jquery/jquery-ui.js

raw
1 /*! jQuery UI - v1.12.1 - 2018-12-06
2 * http://jqueryui.com
3 * Includes: widget.js, position.js, keycode.js, unique-id.js, widgets/autocomplete.js, widgets/menu.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 Keycode 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: Keycode
1244 //>>group: Core
1245 //>>description: Provide keycodes as keynames
1246 //>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
1247
1248
1249 var keycode = $.ui.keyCode = {
1250 BACKSPACE: 8,
1251 COMMA: 188,
1252 DELETE: 46,
1253 DOWN: 40,
1254 END: 35,
1255 ENTER: 13,
1256 ESCAPE: 27,
1257 HOME: 36,
1258 LEFT: 37,
1259 PAGE_DOWN: 34,
1260 PAGE_UP: 33,
1261 PERIOD: 190,
1262 RIGHT: 39,
1263 SPACE: 32,
1264 TAB: 9,
1265 UP: 38
1266 };
1267
1268
1269 /*!
1270 * jQuery UI Unique ID 1.12.1
1271 * http://jqueryui.com
1272 *
1273 * Copyright jQuery Foundation and other contributors
1274 * Released under the MIT license.
1275 * http://jquery.org/license
1276 */
1277
1278 //>>label: uniqueId
1279 //>>group: Core
1280 //>>description: Functions to generate and remove uniqueId's
1281 //>>docs: http://api.jqueryui.com/uniqueId/
1282
1283
1284
1285 var uniqueId = $.fn.extend( {
1286 uniqueId: ( function() {
1287 var uuid = 0;
1288
1289 return function() {
1290 return this.each( function() {
1291 if ( !this.id ) {
1292 this.id = "ui-id-" + ( ++uuid );
1293 }
1294 } );
1295 };
1296 } )(),
1297
1298 removeUniqueId: function() {
1299 return this.each( function() {
1300 if ( /^ui-id-\d+$/.test( this.id ) ) {
1301 $( this ).removeAttr( "id" );
1302 }
1303 } );
1304 }
1305 } );
1306
1307
1308
1309 var safeActiveElement = $.ui.safeActiveElement = function( document ) {
1310 var activeElement;
1311
1312 // Support: IE 9 only
1313 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
1314 try {
1315 activeElement = document.activeElement;
1316 } catch ( error ) {
1317 activeElement = document.body;
1318 }
1319
1320 // Support: IE 9 - 11 only
1321 // IE may return null instead of an element
1322 // Interestingly, this only seems to occur when NOT in an iframe
1323 if ( !activeElement ) {
1324 activeElement = document.body;
1325 }
1326
1327 // Support: IE 11 only
1328 // IE11 returns a seemingly empty object in some cases when accessing
1329 // document.activeElement from an <iframe>
1330 if ( !activeElement.nodeName ) {
1331 activeElement = document.body;
1332 }
1333
1334 return activeElement;
1335 };
1336
1337
1338 /*!
1339 * jQuery UI Menu 1.12.1
1340 * http://jqueryui.com
1341 *
1342 * Copyright jQuery Foundation and other contributors
1343 * Released under the MIT license.
1344 * http://jquery.org/license
1345 */
1346
1347 //>>label: Menu
1348 //>>group: Widgets
1349 //>>description: Creates nestable menus.
1350 //>>docs: http://api.jqueryui.com/menu/
1351 //>>demos: http://jqueryui.com/menu/
1352 //>>css.structure: ../../themes/base/core.css
1353 //>>css.structure: ../../themes/base/menu.css
1354 //>>css.theme: ../../themes/base/theme.css
1355
1356
1357
1358 var widgetsMenu = $.widget( "ui.menu", {
1359 version: "1.12.1",
1360 defaultElement: "<ul>",
1361 delay: 300,
1362 options: {
1363 icons: {
1364 submenu: "ui-icon-caret-1-e"
1365 },
1366 items: "> *",
1367 menus: "ul",
1368 position: {
1369 my: "left top",
1370 at: "right top"
1371 },
1372 role: "menu",
1373
1374 // Callbacks
1375 blur: null,
1376 focus: null,
1377 select: null
1378 },
1379
1380 _create: function() {
1381 this.activeMenu = this.element;
1382
1383 // Flag used to prevent firing of the click handler
1384 // as the event bubbles up through nested menus
1385 this.mouseHandled = false;
1386 this.element
1387 .uniqueId()
1388 .attr( {
1389 role: this.options.role,
1390 tabIndex: 0
1391 } );
1392
1393 this._addClass( "ui-menu", "ui-widget ui-widget-content" );
1394 this._on( {
1395
1396 // Prevent focus from sticking to links inside menu after clicking
1397 // them (focus should always stay on UL during navigation).
1398 "mousedown .ui-menu-item": function( event ) {
1399 event.preventDefault();
1400 },
1401 "click .ui-menu-item": function( event ) {
1402 var target = $( event.target );
1403 var active = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
1404 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
1405 this.select( event );
1406
1407 // Only set the mouseHandled flag if the event will bubble, see #9469.
1408 if ( !event.isPropagationStopped() ) {
1409 this.mouseHandled = true;
1410 }
1411
1412 // Open submenu on click
1413 if ( target.has( ".ui-menu" ).length ) {
1414 this.expand( event );
1415 } else if ( !this.element.is( ":focus" ) &&
1416 active.closest( ".ui-menu" ).length ) {
1417
1418 // Redirect focus to the menu
1419 this.element.trigger( "focus", [ true ] );
1420
1421 // If the active item is on the top level, let it stay active.
1422 // Otherwise, blur the active item since it is no longer visible.
1423 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
1424 clearTimeout( this.timer );
1425 }
1426 }
1427 }
1428 },
1429 "mouseenter .ui-menu-item": function( event ) {
1430
1431 // Ignore mouse events while typeahead is active, see #10458.
1432 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
1433 // is over an item in the menu
1434 if ( this.previousFilter ) {
1435 return;
1436 }
1437
1438 var actualTarget = $( event.target ).closest( ".ui-menu-item" ),
1439 target = $( event.currentTarget );
1440
1441 // Ignore bubbled events on parent items, see #11641
1442 if ( actualTarget[ 0 ] !== target[ 0 ] ) {
1443 return;
1444 }
1445
1446 // Remove ui-state-active class from siblings of the newly focused menu item
1447 // to avoid a jump caused by adjacent elements both having a class with a border
1448 this._removeClass( target.siblings().children( ".ui-state-active" ),
1449 null, "ui-state-active" );
1450 this.focus( event, target );
1451 },
1452 mouseleave: "collapseAll",
1453 "mouseleave .ui-menu": "collapseAll",
1454 focus: function( event, keepActiveItem ) {
1455
1456 // If there's already an active item, keep it active
1457 // If not, activate the first item
1458 var item = this.active || this.element.find( this.options.items ).eq( 0 );
1459
1460 if ( !keepActiveItem ) {
1461 this.focus( event, item );
1462 }
1463 },
1464 blur: function( event ) {
1465 this._delay( function() {
1466 var notContained = !$.contains(
1467 this.element[ 0 ],
1468 $.ui.safeActiveElement( this.document[ 0 ] )
1469 );
1470 if ( notContained ) {
1471 this.collapseAll( event );
1472 }
1473 } );
1474 },
1475 keydown: "_keydown"
1476 } );
1477
1478 this.refresh();
1479
1480 // Clicks outside of a menu collapse any open menus
1481 this._on( this.document, {
1482 click: function( event ) {
1483 if ( this._closeOnDocumentClick( event ) ) {
1484 this.collapseAll( event );
1485 }
1486
1487 // Reset the mouseHandled flag
1488 this.mouseHandled = false;
1489 }
1490 } );
1491 },
1492
1493 _destroy: function() {
1494 var items = this.element.find( ".ui-menu-item" )
1495 .removeAttr( "role aria-disabled" ),
1496 submenus = items.children( ".ui-menu-item-wrapper" )
1497 .removeUniqueId()
1498 .removeAttr( "tabIndex role aria-haspopup" );
1499
1500 // Destroy (sub)menus
1501 this.element
1502 .removeAttr( "aria-activedescendant" )
1503 .find( ".ui-menu" ).addBack()
1504 .removeAttr( "role aria-labelledby aria-expanded aria-hidden aria-disabled " +
1505 "tabIndex" )
1506 .removeUniqueId()
1507 .show();
1508
1509 submenus.children().each( function() {
1510 var elem = $( this );
1511 if ( elem.data( "ui-menu-submenu-caret" ) ) {
1512 elem.remove();
1513 }
1514 } );
1515 },
1516
1517 _keydown: function( event ) {
1518 var match, prev, character, skip,
1519 preventDefault = true;
1520
1521 switch ( event.keyCode ) {
1522 case $.ui.keyCode.PAGE_UP:
1523 this.previousPage( event );
1524 break;
1525 case $.ui.keyCode.PAGE_DOWN:
1526 this.nextPage( event );
1527 break;
1528 case $.ui.keyCode.HOME:
1529 this._move( "first", "first", event );
1530 break;
1531 case $.ui.keyCode.END:
1532 this._move( "last", "last", event );
1533 break;
1534 case $.ui.keyCode.UP:
1535 this.previous( event );
1536 break;
1537 case $.ui.keyCode.DOWN:
1538 this.next( event );
1539 break;
1540 case $.ui.keyCode.LEFT:
1541 this.collapse( event );
1542 break;
1543 case $.ui.keyCode.RIGHT:
1544 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
1545 this.expand( event );
1546 }
1547 break;
1548 case $.ui.keyCode.ENTER:
1549 case $.ui.keyCode.SPACE:
1550 this._activate( event );
1551 break;
1552 case $.ui.keyCode.ESCAPE:
1553 this.collapse( event );
1554 break;
1555 default:
1556 preventDefault = false;
1557 prev = this.previousFilter || "";
1558 skip = false;
1559
1560 // Support number pad values
1561 character = event.keyCode >= 96 && event.keyCode <= 105 ?
1562 ( event.keyCode - 96 ).toString() : String.fromCharCode( event.keyCode );
1563
1564 clearTimeout( this.filterTimer );
1565
1566 if ( character === prev ) {
1567 skip = true;
1568 } else {
1569 character = prev + character;
1570 }
1571
1572 match = this._filterMenuItems( character );
1573 match = skip && match.index( this.active.next() ) !== -1 ?
1574 this.active.nextAll( ".ui-menu-item" ) :
1575 match;
1576
1577 // If no matches on the current filter, reset to the last character pressed
1578 // to move down the menu to the first item that starts with that character
1579 if ( !match.length ) {
1580 character = String.fromCharCode( event.keyCode );
1581 match = this._filterMenuItems( character );
1582 }
1583
1584 if ( match.length ) {
1585 this.focus( event, match );
1586 this.previousFilter = character;
1587 this.filterTimer = this._delay( function() {
1588 delete this.previousFilter;
1589 }, 1000 );
1590 } else {
1591 delete this.previousFilter;
1592 }
1593 }
1594
1595 if ( preventDefault ) {
1596 event.preventDefault();
1597 }
1598 },
1599
1600 _activate: function( event ) {
1601 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
1602 if ( this.active.children( "[aria-haspopup='true']" ).length ) {
1603 this.expand( event );
1604 } else {
1605 this.select( event );
1606 }
1607 }
1608 },
1609
1610 refresh: function() {
1611 var menus, items, newSubmenus, newItems, newWrappers,
1612 that = this,
1613 icon = this.options.icons.submenu,
1614 submenus = this.element.find( this.options.menus );
1615
1616 this._toggleClass( "ui-menu-icons", null, !!this.element.find( ".ui-icon" ).length );
1617
1618 // Initialize nested menus
1619 newSubmenus = submenus.filter( ":not(.ui-menu)" )
1620 .hide()
1621 .attr( {
1622 role: this.options.role,
1623 "aria-hidden": "true",
1624 "aria-expanded": "false"
1625 } )
1626 .each( function() {
1627 var menu = $( this ),
1628 item = menu.prev(),
1629 submenuCaret = $( "<span>" ).data( "ui-menu-submenu-caret", true );
1630
1631 that._addClass( submenuCaret, "ui-menu-icon", "ui-icon " + icon );
1632 item
1633 .attr( "aria-haspopup", "true" )
1634 .prepend( submenuCaret );
1635 menu.attr( "aria-labelledby", item.attr( "id" ) );
1636 } );
1637
1638 this._addClass( newSubmenus, "ui-menu", "ui-widget ui-widget-content ui-front" );
1639
1640 menus = submenus.add( this.element );
1641 items = menus.find( this.options.items );
1642
1643 // Initialize menu-items containing spaces and/or dashes only as dividers
1644 items.not( ".ui-menu-item" ).each( function() {
1645 var item = $( this );
1646 if ( that._isDivider( item ) ) {
1647 that._addClass( item, "ui-menu-divider", "ui-widget-content" );
1648 }
1649 } );
1650
1651 // Don't refresh list items that are already adapted
1652 newItems = items.not( ".ui-menu-item, .ui-menu-divider" );
1653 newWrappers = newItems.children()
1654 .not( ".ui-menu" )
1655 .uniqueId()
1656 .attr( {
1657 tabIndex: -1,
1658 role: this._itemRole()
1659 } );
1660 this._addClass( newItems, "ui-menu-item" )
1661 ._addClass( newWrappers, "ui-menu-item-wrapper" );
1662
1663 // Add aria-disabled attribute to any disabled menu item
1664 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
1665
1666 // If the active item has been removed, blur the menu
1667 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1668 this.blur();
1669 }
1670 },
1671
1672 _itemRole: function() {
1673 return {
1674 menu: "menuitem",
1675 listbox: "option"
1676 }[ this.options.role ];
1677 },
1678
1679 _setOption: function( key, value ) {
1680 if ( key === "icons" ) {
1681 var icons = this.element.find( ".ui-menu-icon" );
1682 this._removeClass( icons, null, this.options.icons.submenu )
1683 ._addClass( icons, null, value.submenu );
1684 }
1685 this._super( key, value );
1686 },
1687
1688 _setOptionDisabled: function( value ) {
1689 this._super( value );
1690
1691 this.element.attr( "aria-disabled", String( value ) );
1692 this._toggleClass( null, "ui-state-disabled", !!value );
1693 },
1694
1695 focus: function( event, item ) {
1696 var nested, focused, activeParent;
1697 this.blur( event, event && event.type === "focus" );
1698
1699 this._scrollIntoView( item );
1700
1701 this.active = item.first();
1702
1703 focused = this.active.children( ".ui-menu-item-wrapper" );
1704 this._addClass( focused, null, "ui-state-active" );
1705
1706 // Only update aria-activedescendant if there's a role
1707 // otherwise we assume focus is managed elsewhere
1708 if ( this.options.role ) {
1709 this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
1710 }
1711
1712 // Highlight active parent menu item, if any
1713 activeParent = this.active
1714 .parent()
1715 .closest( ".ui-menu-item" )
1716 .children( ".ui-menu-item-wrapper" );
1717 this._addClass( activeParent, null, "ui-state-active" );
1718
1719 if ( event && event.type === "keydown" ) {
1720 this._close();
1721 } else {
1722 this.timer = this._delay( function() {
1723 this._close();
1724 }, this.delay );
1725 }
1726
1727 nested = item.children( ".ui-menu" );
1728 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
1729 this._startOpening( nested );
1730 }
1731 this.activeMenu = item.parent();
1732
1733 this._trigger( "focus", event, { item: item } );
1734 },
1735
1736 _scrollIntoView: function( item ) {
1737 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
1738 if ( this._hasScroll() ) {
1739 borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0;
1740 paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0;
1741 offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
1742 scroll = this.activeMenu.scrollTop();
1743 elementHeight = this.activeMenu.height();
1744 itemHeight = item.outerHeight();
1745
1746 if ( offset < 0 ) {
1747 this.activeMenu.scrollTop( scroll + offset );
1748 } else if ( offset + itemHeight > elementHeight ) {
1749 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
1750 }
1751 }
1752 },
1753
1754 blur: function( event, fromFocus ) {
1755 if ( !fromFocus ) {
1756 clearTimeout( this.timer );
1757 }
1758
1759 if ( !this.active ) {
1760 return;
1761 }
1762
1763 this._removeClass( this.active.children( ".ui-menu-item-wrapper" ),
1764 null, "ui-state-active" );
1765
1766 this._trigger( "blur", event, { item: this.active } );
1767 this.active = null;
1768 },
1769
1770 _startOpening: function( submenu ) {
1771 clearTimeout( this.timer );
1772
1773 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
1774 // shift in the submenu position when mousing over the caret icon
1775 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
1776 return;
1777 }
1778
1779 this.timer = this._delay( function() {
1780 this._close();
1781 this._open( submenu );
1782 }, this.delay );
1783 },
1784
1785 _open: function( submenu ) {
1786 var position = $.extend( {
1787 of: this.active
1788 }, this.options.position );
1789
1790 clearTimeout( this.timer );
1791 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
1792 .hide()
1793 .attr( "aria-hidden", "true" );
1794
1795 submenu
1796 .show()
1797 .removeAttr( "aria-hidden" )
1798 .attr( "aria-expanded", "true" )
1799 .position( position );
1800 },
1801
1802 collapseAll: function( event, all ) {
1803 clearTimeout( this.timer );
1804 this.timer = this._delay( function() {
1805
1806 // If we were passed an event, look for the submenu that contains the event
1807 var currentMenu = all ? this.element :
1808 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
1809
1810 // If we found no valid submenu ancestor, use the main menu to close all
1811 // sub menus anyway
1812 if ( !currentMenu.length ) {
1813 currentMenu = this.element;
1814 }
1815
1816 this._close( currentMenu );
1817
1818 this.blur( event );
1819
1820 // Work around active item staying active after menu is blurred
1821 this._removeClass( currentMenu.find( ".ui-state-active" ), null, "ui-state-active" );
1822
1823 this.activeMenu = currentMenu;
1824 }, this.delay );
1825 },
1826
1827 // With no arguments, closes the currently active menu - if nothing is active
1828 // it closes all menus. If passed an argument, it will search for menus BELOW
1829 _close: function( startMenu ) {
1830 if ( !startMenu ) {
1831 startMenu = this.active ? this.active.parent() : this.element;
1832 }
1833
1834 startMenu.find( ".ui-menu" )
1835 .hide()
1836 .attr( "aria-hidden", "true" )
1837 .attr( "aria-expanded", "false" );
1838 },
1839
1840 _closeOnDocumentClick: function( event ) {
1841 return !$( event.target ).closest( ".ui-menu" ).length;
1842 },
1843
1844 _isDivider: function( item ) {
1845
1846 // Match hyphen, em dash, en dash
1847 return !/[^\-\u2014\u2013\s]/.test( item.text() );
1848 },
1849
1850 collapse: function( event ) {
1851 var newItem = this.active &&
1852 this.active.parent().closest( ".ui-menu-item", this.element );
1853 if ( newItem && newItem.length ) {
1854 this._close();
1855 this.focus( event, newItem );
1856 }
1857 },
1858
1859 expand: function( event ) {
1860 var newItem = this.active &&
1861 this.active
1862 .children( ".ui-menu " )
1863 .find( this.options.items )
1864 .first();
1865
1866 if ( newItem && newItem.length ) {
1867 this._open( newItem.parent() );
1868
1869 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
1870 this._delay( function() {
1871 this.focus( event, newItem );
1872 } );
1873 }
1874 },
1875
1876 next: function( event ) {
1877 this._move( "next", "first", event );
1878 },
1879
1880 previous: function( event ) {
1881 this._move( "prev", "last", event );
1882 },
1883
1884 isFirstItem: function() {
1885 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
1886 },
1887
1888 isLastItem: function() {
1889 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
1890 },
1891
1892 _move: function( direction, filter, event ) {
1893 var next;
1894 if ( this.active ) {
1895 if ( direction === "first" || direction === "last" ) {
1896 next = this.active
1897 [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
1898 .eq( -1 );
1899 } else {
1900 next = this.active
1901 [ direction + "All" ]( ".ui-menu-item" )
1902 .eq( 0 );
1903 }
1904 }
1905 if ( !next || !next.length || !this.active ) {
1906 next = this.activeMenu.find( this.options.items )[ filter ]();
1907 }
1908
1909 this.focus( event, next );
1910 },
1911
1912 nextPage: function( event ) {
1913 var item, base, height;
1914
1915 if ( !this.active ) {
1916 this.next( event );
1917 return;
1918 }
1919 if ( this.isLastItem() ) {
1920 return;
1921 }
1922 if ( this._hasScroll() ) {
1923 base = this.active.offset().top;
1924 height = this.element.height();
1925 this.active.nextAll( ".ui-menu-item" ).each( function() {
1926 item = $( this );
1927 return item.offset().top - base - height < 0;
1928 } );
1929
1930 this.focus( event, item );
1931 } else {
1932 this.focus( event, this.activeMenu.find( this.options.items )
1933 [ !this.active ? "first" : "last" ]() );
1934 }
1935 },
1936
1937 previousPage: function( event ) {
1938 var item, base, height;
1939 if ( !this.active ) {
1940 this.next( event );
1941 return;
1942 }
1943 if ( this.isFirstItem() ) {
1944 return;
1945 }
1946 if ( this._hasScroll() ) {
1947 base = this.active.offset().top;
1948 height = this.element.height();
1949 this.active.prevAll( ".ui-menu-item" ).each( function() {
1950 item = $( this );
1951 return item.offset().top - base + height > 0;
1952 } );
1953
1954 this.focus( event, item );
1955 } else {
1956 this.focus( event, this.activeMenu.find( this.options.items ).first() );
1957 }
1958 },
1959
1960 _hasScroll: function() {
1961 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
1962 },
1963
1964 select: function( event ) {
1965
1966 // TODO: It should never be possible to not have an active item at this
1967 // point, but the tests don't trigger mouseenter before click.
1968 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
1969 var ui = { item: this.active };
1970 if ( !this.active.has( ".ui-menu" ).length ) {
1971 this.collapseAll( event, true );
1972 }
1973 this._trigger( "select", event, ui );
1974 },
1975
1976 _filterMenuItems: function( character ) {
1977 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
1978 regex = new RegExp( "^" + escapedCharacter, "i" );
1979
1980 return this.activeMenu
1981 .find( this.options.items )
1982
1983 // Only match on items, not dividers or other content (#10571)
1984 .filter( ".ui-menu-item" )
1985 .filter( function() {
1986 return regex.test(
1987 $.trim( $( this ).children( ".ui-menu-item-wrapper" ).text() ) );
1988 } );
1989 }
1990 } );
1991
1992
1993 /*!
1994 * jQuery UI Autocomplete 1.12.1
1995 * http://jqueryui.com
1996 *
1997 * Copyright jQuery Foundation and other contributors
1998 * Released under the MIT license.
1999 * http://jquery.org/license
2000 */
2001
2002 //>>label: Autocomplete
2003 //>>group: Widgets
2004 //>>description: Lists suggested words as the user is typing.
2005 //>>docs: http://api.jqueryui.com/autocomplete/
2006 //>>demos: http://jqueryui.com/autocomplete/
2007 //>>css.structure: ../../themes/base/core.css
2008 //>>css.structure: ../../themes/base/autocomplete.css
2009 //>>css.theme: ../../themes/base/theme.css
2010
2011
2012
2013 $.widget( "ui.autocomplete", {
2014 version: "1.12.1",
2015 defaultElement: "<input>",
2016 options: {
2017 appendTo: null,
2018 autoFocus: false,
2019 delay: 300,
2020 minLength: 1,
2021 position: {
2022 my: "left top",
2023 at: "left bottom",
2024 collision: "none"
2025 },
2026 source: null,
2027
2028 // Callbacks
2029 change: null,
2030 close: null,
2031 focus: null,
2032 open: null,
2033 response: null,
2034 search: null,
2035 select: null
2036 },
2037
2038 requestIndex: 0,
2039 pending: 0,
2040
2041 _create: function() {
2042
2043 // Some browsers only repeat keydown events, not keypress events,
2044 // so we use the suppressKeyPress flag to determine if we've already
2045 // handled the keydown event. #7269
2046 // Unfortunately the code for & in keypress is the same as the up arrow,
2047 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2048 // events when we know the keydown event was used to modify the
2049 // search term. #7799
2050 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2051 nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2052 isTextarea = nodeName === "textarea",
2053 isInput = nodeName === "input";
2054
2055 // Textareas are always multi-line
2056 // Inputs are always single-line, even if inside a contentEditable element
2057 // IE also treats inputs as contentEditable
2058 // All other element types are determined by whether or not they're contentEditable
2059 this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );
2060
2061 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2062 this.isNewMenu = true;
2063
2064 this._addClass( "ui-autocomplete-input" );
2065 this.element.attr( "autocomplete", "off" );
2066
2067 this._on( this.element, {
2068 keydown: function( event ) {
2069 if ( this.element.prop( "readOnly" ) ) {
2070 suppressKeyPress = true;
2071 suppressInput = true;
2072 suppressKeyPressRepeat = true;
2073 return;
2074 }
2075
2076 suppressKeyPress = false;
2077 suppressInput = false;
2078 suppressKeyPressRepeat = false;
2079 var keyCode = $.ui.keyCode;
2080 switch ( event.keyCode ) {
2081 case keyCode.PAGE_UP:
2082 suppressKeyPress = true;
2083 this._move( "previousPage", event );
2084 break;
2085 case keyCode.PAGE_DOWN:
2086 suppressKeyPress = true;
2087 this._move( "nextPage", event );
2088 break;
2089 case keyCode.UP:
2090 suppressKeyPress = true;
2091 this._keyEvent( "previous", event );
2092 break;
2093 case keyCode.DOWN:
2094 suppressKeyPress = true;
2095 this._keyEvent( "next", event );
2096 break;
2097 case keyCode.ENTER:
2098
2099 // when menu is open and has focus
2100 if ( this.menu.active ) {
2101
2102 // #6055 - Opera still allows the keypress to occur
2103 // which causes forms to submit
2104 suppressKeyPress = true;
2105 event.preventDefault();
2106 this.menu.select( event );
2107 }
2108 break;
2109 case keyCode.TAB:
2110 if ( this.menu.active ) {
2111 this.menu.select( event );
2112 }
2113 break;
2114 case keyCode.ESCAPE:
2115 if ( this.menu.element.is( ":visible" ) ) {
2116 if ( !this.isMultiLine ) {
2117 this._value( this.term );
2118 }
2119 this.close( event );
2120
2121 // Different browsers have different default behavior for escape
2122 // Single press can mean undo or clear
2123 // Double press in IE means clear the whole form
2124 event.preventDefault();
2125 }
2126 break;
2127 default:
2128 suppressKeyPressRepeat = true;
2129
2130 // search timeout should be triggered before the input value is changed
2131 this._searchTimeout( event );
2132 break;
2133 }
2134 },
2135 keypress: function( event ) {
2136 if ( suppressKeyPress ) {
2137 suppressKeyPress = false;
2138 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2139 event.preventDefault();
2140 }
2141 return;
2142 }
2143 if ( suppressKeyPressRepeat ) {
2144 return;
2145 }
2146
2147 // Replicate some key handlers to allow them to repeat in Firefox and Opera
2148 var keyCode = $.ui.keyCode;
2149 switch ( event.keyCode ) {
2150 case keyCode.PAGE_UP:
2151 this._move( "previousPage", event );
2152 break;
2153 case keyCode.PAGE_DOWN:
2154 this._move( "nextPage", event );
2155 break;
2156 case keyCode.UP:
2157 this._keyEvent( "previous", event );
2158 break;
2159 case keyCode.DOWN:
2160 this._keyEvent( "next", event );
2161 break;
2162 }
2163 },
2164 input: function( event ) {
2165 if ( suppressInput ) {
2166 suppressInput = false;
2167 event.preventDefault();
2168 return;
2169 }
2170 this._searchTimeout( event );
2171 },
2172 focus: function() {
2173 this.selectedItem = null;
2174 this.previous = this._value();
2175 },
2176 blur: function( event ) {
2177 if ( this.cancelBlur ) {
2178 delete this.cancelBlur;
2179 return;
2180 }
2181
2182 clearTimeout( this.searching );
2183 this.close( event );
2184 this._change( event );
2185 }
2186 } );
2187
2188 this._initSource();
2189 this.menu = $( "<ul>" )
2190 .appendTo( this._appendTo() )
2191 .menu( {
2192
2193 // disable ARIA support, the live region takes care of that
2194 role: null
2195 } )
2196 .hide()
2197 .menu( "instance" );
2198
2199 this._addClass( this.menu.element, "ui-autocomplete", "ui-front" );
2200 this._on( this.menu.element, {
2201 mousedown: function( event ) {
2202
2203 // prevent moving focus out of the text field
2204 event.preventDefault();
2205
2206 // IE doesn't prevent moving focus even with event.preventDefault()
2207 // so we set a flag to know when we should ignore the blur event
2208 this.cancelBlur = true;
2209 this._delay( function() {
2210 delete this.cancelBlur;
2211
2212 // Support: IE 8 only
2213 // Right clicking a menu item or selecting text from the menu items will
2214 // result in focus moving out of the input. However, we've already received
2215 // and ignored the blur event because of the cancelBlur flag set above. So
2216 // we restore focus to ensure that the menu closes properly based on the user's
2217 // next actions.
2218 if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
2219 this.element.trigger( "focus" );
2220 }
2221 } );
2222 },
2223 menufocus: function( event, ui ) {
2224 var label, item;
2225
2226 // support: Firefox
2227 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2228 if ( this.isNewMenu ) {
2229 this.isNewMenu = false;
2230 if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2231 this.menu.blur();
2232
2233 this.document.one( "mousemove", function() {
2234 $( event.target ).trigger( event.originalEvent );
2235 } );
2236
2237 return;
2238 }
2239 }
2240
2241 item = ui.item.data( "ui-autocomplete-item" );
2242 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
2243
2244 // use value to match what will end up in the input, if it was a key event
2245 if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
2246 this._value( item.value );
2247 }
2248 }
2249
2250 // Announce the value in the liveRegion
2251 label = ui.item.attr( "aria-label" ) || item.value;
2252 if ( label && $.trim( label ).length ) {
2253 this.liveRegion.children().hide();
2254 $( "<div>" ).text( label ).appendTo( this.liveRegion );
2255 }
2256 },
2257 menuselect: function( event, ui ) {
2258 var item = ui.item.data( "ui-autocomplete-item" ),
2259 previous = this.previous;
2260
2261 // Only trigger when focus was lost (click on menu)
2262 if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
2263 this.element.trigger( "focus" );
2264 this.previous = previous;
2265
2266 // #6109 - IE triggers two focus events and the second
2267 // is asynchronous, so we need to reset the previous
2268 // term synchronously and asynchronously :-(
2269 this._delay( function() {
2270 this.previous = previous;
2271 this.selectedItem = item;
2272 } );
2273 }
2274
2275 if ( false !== this._trigger( "select", event, { item: item } ) ) {
2276 this._value( item.value );
2277 }
2278
2279 // reset the term after the select event
2280 // this allows custom select handling to work properly
2281 this.term = this._value();
2282
2283 this.close( event );
2284 this.selectedItem = item;
2285 }
2286 } );
2287
2288 this.liveRegion = $( "<div>", {
2289 role: "status",
2290 "aria-live": "assertive",
2291 "aria-relevant": "additions"
2292 } )
2293 .appendTo( this.document[ 0 ].body );
2294
2295 this._addClass( this.liveRegion, null, "ui-helper-hidden-accessible" );
2296
2297 // Turning off autocomplete prevents the browser from remembering the
2298 // value when navigating through history, so we re-enable autocomplete
2299 // if the page is unloaded before the widget is destroyed. #7790
2300 this._on( this.window, {
2301 beforeunload: function() {
2302 this.element.removeAttr( "autocomplete" );
2303 }
2304 } );
2305 },
2306
2307 _destroy: function() {
2308 clearTimeout( this.searching );
2309 this.element.removeAttr( "autocomplete" );
2310 this.menu.element.remove();
2311 this.liveRegion.remove();
2312 },
2313
2314 _setOption: function( key, value ) {
2315 this._super( key, value );
2316 if ( key === "source" ) {
2317 this._initSource();
2318 }
2319 if ( key === "appendTo" ) {
2320 this.menu.element.appendTo( this._appendTo() );
2321 }
2322 if ( key === "disabled" && value && this.xhr ) {
2323 this.xhr.abort();
2324 }
2325 },
2326
2327 _isEventTargetInWidget: function( event ) {
2328 var menuElement = this.menu.element[ 0 ];
2329
2330 return event.target === this.element[ 0 ] ||
2331 event.target === menuElement ||
2332 $.contains( menuElement, event.target );
2333 },
2334
2335 _closeOnClickOutside: function( event ) {
2336 if ( !this._isEventTargetInWidget( event ) ) {
2337 this.close();
2338 }
2339 },
2340
2341 _appendTo: function() {
2342 var element = this.options.appendTo;
2343
2344 if ( element ) {
2345 element = element.jquery || element.nodeType ?
2346 $( element ) :
2347 this.document.find( element ).eq( 0 );
2348 }
2349
2350 if ( !element || !element[ 0 ] ) {
2351 element = this.element.closest( ".ui-front, dialog" );
2352 }
2353
2354 if ( !element.length ) {
2355 element = this.document[ 0 ].body;
2356 }
2357
2358 return element;
2359 },
2360
2361 _initSource: function() {
2362 var array, url,
2363 that = this;
2364 if ( $.isArray( this.options.source ) ) {
2365 array = this.options.source;
2366 this.source = function( request, response ) {
2367 response( $.ui.autocomplete.filter( array, request.term ) );
2368 };
2369 } else if ( typeof this.options.source === "string" ) {
2370 url = this.options.source;
2371 this.source = function( request, response ) {
2372 if ( that.xhr ) {
2373 that.xhr.abort();
2374 }
2375 that.xhr = $.ajax( {
2376 url: url,
2377 data: request,
2378 dataType: "json",
2379 success: function( data ) {
2380 response( data );
2381 },
2382 error: function() {
2383 response( [] );
2384 }
2385 } );
2386 };
2387 } else {
2388 this.source = this.options.source;
2389 }
2390 },
2391
2392 _searchTimeout: function( event ) {
2393 clearTimeout( this.searching );
2394 this.searching = this._delay( function() {
2395
2396 // Search if the value has changed, or if the user retypes the same value (see #7434)
2397 var equalValues = this.term === this._value(),
2398 menuVisible = this.menu.element.is( ":visible" ),
2399 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
2400
2401 if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
2402 this.selectedItem = null;
2403 this.search( null, event );
2404 }
2405 }, this.options.delay );
2406 },
2407
2408 search: function( value, event ) {
2409 value = value != null ? value : this._value();
2410
2411 // Always save the actual value, not the one passed as an argument
2412 this.term = this._value();
2413
2414 if ( value.length < this.options.minLength ) {
2415 return this.close( event );
2416 }
2417
2418 if ( this._trigger( "search", event ) === false ) {
2419 return;
2420 }
2421
2422 return this._search( value );
2423 },
2424
2425 _search: function( value ) {
2426 this.pending++;
2427 this._addClass( "ui-autocomplete-loading" );
2428 this.cancelSearch = false;
2429
2430 this.source( { term: value }, this._response() );
2431 },
2432
2433 _response: function() {
2434 var index = ++this.requestIndex;
2435
2436 return $.proxy( function( content ) {
2437 if ( index === this.requestIndex ) {
2438 this.__response( content );
2439 }
2440
2441 this.pending--;
2442 if ( !this.pending ) {
2443 this._removeClass( "ui-autocomplete-loading" );
2444 }
2445 }, this );
2446 },
2447
2448 __response: function( content ) {
2449 if ( content ) {
2450 content = this._normalize( content );
2451 }
2452 this._trigger( "response", null, { content: content } );
2453 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
2454 this._suggest( content );
2455 this._trigger( "open" );
2456 } else {
2457
2458 // use ._close() instead of .close() so we don't cancel future searches
2459 this._close();
2460 }
2461 },
2462
2463 close: function( event ) {
2464 this.cancelSearch = true;
2465 this._close( event );
2466 },
2467
2468 _close: function( event ) {
2469
2470 // Remove the handler that closes the menu on outside clicks
2471 this._off( this.document, "mousedown" );
2472
2473 if ( this.menu.element.is( ":visible" ) ) {
2474 this.menu.element.hide();
2475 this.menu.blur();
2476 this.isNewMenu = true;
2477 this._trigger( "close", event );
2478 }
2479 },
2480
2481 _change: function( event ) {
2482 if ( this.previous !== this._value() ) {
2483 this._trigger( "change", event, { item: this.selectedItem } );
2484 }
2485 },
2486
2487 _normalize: function( items ) {
2488
2489 // assume all items have the right format when the first item is complete
2490 if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
2491 return items;
2492 }
2493 return $.map( items, function( item ) {
2494 if ( typeof item === "string" ) {
2495 return {
2496 label: item,
2497 value: item
2498 };
2499 }
2500 return $.extend( {}, item, {
2501 label: item.label || item.value,
2502 value: item.value || item.label
2503 } );
2504 } );
2505 },
2506
2507 _suggest: function( items ) {
2508 var ul = this.menu.element.empty();
2509 this._renderMenu( ul, items );
2510 this.isNewMenu = true;
2511 this.menu.refresh();
2512
2513 // Size and position menu
2514 ul.show();
2515 this._resizeMenu();
2516 ul.position( $.extend( {
2517 of: this.element
2518 }, this.options.position ) );
2519
2520 if ( this.options.autoFocus ) {
2521 this.menu.next();
2522 }
2523
2524 // Listen for interactions outside of the widget (#6642)
2525 this._on( this.document, {
2526 mousedown: "_closeOnClickOutside"
2527 } );
2528 },
2529
2530 _resizeMenu: function() {
2531 var ul = this.menu.element;
2532 ul.outerWidth( Math.max(
2533
2534 // Firefox wraps long text (possibly a rounding bug)
2535 // so we add 1px to avoid the wrapping (#7513)
2536 ul.width( "" ).outerWidth() + 1,
2537 this.element.outerWidth()
2538 ) );
2539 },
2540
2541 _renderMenu: function( ul, items ) {
2542 var that = this;
2543 $.each( items, function( index, item ) {
2544 that._renderItemData( ul, item );
2545 } );
2546 },
2547
2548 _renderItemData: function( ul, item ) {
2549 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
2550 },
2551
2552 _renderItem: function( ul, item ) {
2553 return $( "<li>" )
2554 .append( $( "<div>" ).text( item.label ) )
2555 .appendTo( ul );
2556 },
2557
2558 _move: function( direction, event ) {
2559 if ( !this.menu.element.is( ":visible" ) ) {
2560 this.search( null, event );
2561 return;
2562 }
2563 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
2564 this.menu.isLastItem() && /^next/.test( direction ) ) {
2565
2566 if ( !this.isMultiLine ) {
2567 this._value( this.term );
2568 }
2569
2570 this.menu.blur();
2571 return;
2572 }
2573 this.menu[ direction ]( event );
2574 },
2575
2576 widget: function() {
2577 return this.menu.element;
2578 },
2579
2580 _value: function() {
2581 return this.valueMethod.apply( this.element, arguments );
2582 },
2583
2584 _keyEvent: function( keyEvent, event ) {
2585 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2586 this._move( keyEvent, event );
2587
2588 // Prevents moving cursor to beginning/end of the text field in some browsers
2589 event.preventDefault();
2590 }
2591 },
2592
2593 // Support: Chrome <=50
2594 // We should be able to just use this.element.prop( "isContentEditable" )
2595 // but hidden elements always report false in Chrome.
2596 // https://code.google.com/p/chromium/issues/detail?id=313082
2597 _isContentEditable: function( element ) {
2598 if ( !element.length ) {
2599 return false;
2600 }
2601
2602 var editable = element.prop( "contentEditable" );
2603
2604 if ( editable === "inherit" ) {
2605 return this._isContentEditable( element.parent() );
2606 }
2607
2608 return editable === "true";
2609 }
2610 } );
2611
2612 $.extend( $.ui.autocomplete, {
2613 escapeRegex: function( value ) {
2614 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
2615 },
2616 filter: function( array, term ) {
2617 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
2618 return $.grep( array, function( value ) {
2619 return matcher.test( value.label || value.value || value );
2620 } );
2621 }
2622 } );
2623
2624 // Live region extension, adding a `messages` option
2625 // NOTE: This is an experimental API. We are still investigating
2626 // a full solution for string manipulation and internationalization.
2627 $.widget( "ui.autocomplete", $.ui.autocomplete, {
2628 options: {
2629 messages: {
2630 noResults: "No search results.",
2631 results: function( amount ) {
2632 return amount + ( amount > 1 ? " results are" : " result is" ) +
2633 " available, use up and down arrow keys to navigate.";
2634 }
2635 }
2636 },
2637
2638 __response: function( content ) {
2639 var message;
2640 this._superApply( arguments );
2641 if ( this.options.disabled || this.cancelSearch ) {
2642 return;
2643 }
2644 if ( content && content.length ) {
2645 message = this.options.messages.results( content.length );
2646 } else {
2647 message = this.options.messages.noResults;
2648 }
2649 this.liveRegion.children().hide();
2650 $( "<div>" ).text( message ).appendTo( this.liveRegion );
2651 }
2652 } );
2653
2654 var widgetsAutocomplete = $.ui.autocomplete;
2655
2656
2657
2658
2659 }));