|
7
|
1 /*!
|
|
|
2 * jQuery UI Widget 1.10.4
|
|
|
3 * http://jqueryui.com
|
|
|
4 *
|
|
|
5 * Copyright 2014 jQuery Foundation and other contributors
|
|
|
6 * Released under the MIT license.
|
|
|
7 * http://jquery.org/license
|
|
|
8 *
|
|
|
9 * http://api.jqueryui.com/jQuery.widget/
|
|
|
10 */
|
|
|
11 (function( $, undefined ) {
|
|
|
12
|
|
|
13 var uuid = 0,
|
|
|
14 slice = Array.prototype.slice,
|
|
|
15 _cleanData = $.cleanData;
|
|
|
16 $.cleanData = function( elems ) {
|
|
|
17 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
|
18 try {
|
|
|
19 $( elem ).triggerHandler( "remove" );
|
|
|
20 // http://bugs.jquery.com/ticket/8235
|
|
|
21 } catch( e ) {}
|
|
|
22 }
|
|
|
23 _cleanData( elems );
|
|
|
24 };
|
|
|
25
|
|
|
26 $.widget = function( name, base, prototype ) {
|
|
|
27 var fullName, existingConstructor, constructor, basePrototype,
|
|
|
28 // proxiedPrototype allows the provided prototype to remain unmodified
|
|
|
29 // so that it can be used as a mixin for multiple widgets (#8876)
|
|
|
30 proxiedPrototype = {},
|
|
|
31 namespace = name.split( "." )[ 0 ];
|
|
|
32
|
|
|
33 name = name.split( "." )[ 1 ];
|
|
|
34 fullName = namespace + "-" + name;
|
|
|
35
|
|
|
36 if ( !prototype ) {
|
|
|
37 prototype = base;
|
|
|
38 base = $.Widget;
|
|
|
39 }
|
|
|
40
|
|
|
41 // create selector for plugin
|
|
|
42 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
|
|
|
43 return !!$.data( elem, fullName );
|
|
|
44 };
|
|
|
45
|
|
|
46 $[ namespace ] = $[ namespace ] || {};
|
|
|
47 existingConstructor = $[ namespace ][ name ];
|
|
|
48 constructor = $[ namespace ][ name ] = function( options, element ) {
|
|
|
49 // allow instantiation without "new" keyword
|
|
|
50 if ( !this._createWidget ) {
|
|
|
51 return new constructor( options, element );
|
|
|
52 }
|
|
|
53
|
|
|
54 // allow instantiation without initializing for simple inheritance
|
|
|
55 // must use "new" keyword (the code above always passes args)
|
|
|
56 if ( arguments.length ) {
|
|
|
57 this._createWidget( options, element );
|
|
|
58 }
|
|
|
59 };
|
|
|
60 // extend with the existing constructor to carry over any static properties
|
|
|
61 $.extend( constructor, existingConstructor, {
|
|
|
62 version: prototype.version,
|
|
|
63 // copy the object used to create the prototype in case we need to
|
|
|
64 // redefine the widget later
|
|
|
65 _proto: $.extend( {}, prototype ),
|
|
|
66 // track widgets that inherit from this widget in case this widget is
|
|
|
67 // redefined after a widget inherits from it
|
|
|
68 _childConstructors: []
|
|
|
69 });
|
|
|
70
|
|
|
71 basePrototype = new base();
|
|
|
72 // we need to make the options hash a property directly on the new instance
|
|
|
73 // otherwise we'll modify the options hash on the prototype that we're
|
|
|
74 // inheriting from
|
|
|
75 basePrototype.options = $.widget.extend( {}, basePrototype.options );
|
|
|
76 $.each( prototype, function( prop, value ) {
|
|
|
77 if ( !$.isFunction( value ) ) {
|
|
|
78 proxiedPrototype[ prop ] = value;
|
|
|
79 return;
|
|
|
80 }
|
|
|
81 proxiedPrototype[ prop ] = (function() {
|
|
|
82 var _super = function() {
|
|
|
83 return base.prototype[ prop ].apply( this, arguments );
|
|
|
84 },
|
|
|
85 _superApply = function( args ) {
|
|
|
86 return base.prototype[ prop ].apply( this, args );
|
|
|
87 };
|
|
|
88 return function() {
|
|
|
89 var __super = this._super,
|
|
|
90 __superApply = this._superApply,
|
|
|
91 returnValue;
|
|
|
92
|
|
|
93 this._super = _super;
|
|
|
94 this._superApply = _superApply;
|
|
|
95
|
|
|
96 returnValue = value.apply( this, arguments );
|
|
|
97
|
|
|
98 this._super = __super;
|
|
|
99 this._superApply = __superApply;
|
|
|
100
|
|
|
101 return returnValue;
|
|
|
102 };
|
|
|
103 })();
|
|
|
104 });
|
|
|
105 constructor.prototype = $.widget.extend( basePrototype, {
|
|
|
106 // TODO: remove support for widgetEventPrefix
|
|
|
107 // always use the name + a colon as the prefix, e.g., draggable:start
|
|
|
108 // don't prefix for widgets that aren't DOM-based
|
|
|
109 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
|
|
|
110 }, proxiedPrototype, {
|
|
|
111 constructor: constructor,
|
|
|
112 namespace: namespace,
|
|
|
113 widgetName: name,
|
|
|
114 widgetFullName: fullName
|
|
|
115 });
|
|
|
116
|
|
|
117 // If this widget is being redefined then we need to find all widgets that
|
|
|
118 // are inheriting from it and redefine all of them so that they inherit from
|
|
|
119 // the new version of this widget. We're essentially trying to replace one
|
|
|
120 // level in the prototype chain.
|
|
|
121 if ( existingConstructor ) {
|
|
|
122 $.each( existingConstructor._childConstructors, function( i, child ) {
|
|
|
123 var childPrototype = child.prototype;
|
|
|
124
|
|
|
125 // redefine the child widget using the same prototype that was
|
|
|
126 // originally used, but inherit from the new version of the base
|
|
|
127 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
|
|
|
128 });
|
|
|
129 // remove the list of existing child constructors from the old constructor
|
|
|
130 // so the old child constructors can be garbage collected
|
|
|
131 delete existingConstructor._childConstructors;
|
|
|
132 } else {
|
|
|
133 base._childConstructors.push( constructor );
|
|
|
134 }
|
|
|
135
|
|
|
136 $.widget.bridge( name, constructor );
|
|
|
137 };
|
|
|
138
|
|
|
139 $.widget.extend = function( target ) {
|
|
|
140 var input = slice.call( arguments, 1 ),
|
|
|
141 inputIndex = 0,
|
|
|
142 inputLength = input.length,
|
|
|
143 key,
|
|
|
144 value;
|
|
|
145 for ( ; inputIndex < inputLength; inputIndex++ ) {
|
|
|
146 for ( key in input[ inputIndex ] ) {
|
|
|
147 value = input[ inputIndex ][ key ];
|
|
|
148 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
|
|
|
149 // Clone objects
|
|
|
150 if ( $.isPlainObject( value ) ) {
|
|
|
151 target[ key ] = $.isPlainObject( target[ key ] ) ?
|
|
|
152 $.widget.extend( {}, target[ key ], value ) :
|
|
|
153 // Don't extend strings, arrays, etc. with objects
|
|
|
154 $.widget.extend( {}, value );
|
|
|
155 // Copy everything else by reference
|
|
|
156 } else {
|
|
|
157 target[ key ] = value;
|
|
|
158 }
|
|
|
159 }
|
|
|
160 }
|
|
|
161 }
|
|
|
162 return target;
|
|
|
163 };
|
|
|
164
|
|
|
165 $.widget.bridge = function( name, object ) {
|
|
|
166 var fullName = object.prototype.widgetFullName || name;
|
|
|
167 $.fn[ name ] = function( options ) {
|
|
|
168 var isMethodCall = typeof options === "string",
|
|
|
169 args = slice.call( arguments, 1 ),
|
|
|
170 returnValue = this;
|
|
|
171
|
|
|
172 // allow multiple hashes to be passed on init
|
|
|
173 options = !isMethodCall && args.length ?
|
|
|
174 $.widget.extend.apply( null, [ options ].concat(args) ) :
|
|
|
175 options;
|
|
|
176
|
|
|
177 if ( isMethodCall ) {
|
|
|
178 this.each(function() {
|
|
|
179 var methodValue,
|
|
|
180 instance = $.data( this, fullName );
|
|
|
181 if ( !instance ) {
|
|
|
182 return $.error( "cannot call methods on " + name + " prior to initialization; " +
|
|
|
183 "attempted to call method '" + options + "'" );
|
|
|
184 }
|
|
|
185 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
|
|
|
186 return $.error( "no such method '" + options + "' for " + name + " widget instance" );
|
|
|
187 }
|
|
|
188 methodValue = instance[ options ].apply( instance, args );
|
|
|
189 if ( methodValue !== instance && methodValue !== undefined ) {
|
|
|
190 returnValue = methodValue && methodValue.jquery ?
|
|
|
191 returnValue.pushStack( methodValue.get() ) :
|
|
|
192 methodValue;
|
|
|
193 return false;
|
|
|
194 }
|
|
|
195 });
|
|
|
196 } else {
|
|
|
197 this.each(function() {
|
|
|
198 var instance = $.data( this, fullName );
|
|
|
199 if ( instance ) {
|
|
|
200 instance.option( options || {} )._init();
|
|
|
201 } else {
|
|
|
202 $.data( this, fullName, new object( options, this ) );
|
|
|
203 }
|
|
|
204 });
|
|
|
205 }
|
|
|
206
|
|
|
207 return returnValue;
|
|
|
208 };
|
|
|
209 };
|
|
|
210
|
|
|
211 $.Widget = function( /* options, element */ ) {};
|
|
|
212 $.Widget._childConstructors = [];
|
|
|
213
|
|
|
214 $.Widget.prototype = {
|
|
|
215 widgetName: "widget",
|
|
|
216 widgetEventPrefix: "",
|
|
|
217 defaultElement: "<div>",
|
|
|
218 options: {
|
|
|
219 disabled: false,
|
|
|
220
|
|
|
221 // callbacks
|
|
|
222 create: null
|
|
|
223 },
|
|
|
224 _createWidget: function( options, element ) {
|
|
|
225 element = $( element || this.defaultElement || this )[ 0 ];
|
|
|
226 this.element = $( element );
|
|
|
227 this.uuid = uuid++;
|
|
|
228 this.eventNamespace = "." + this.widgetName + this.uuid;
|
|
|
229 this.options = $.widget.extend( {},
|
|
|
230 this.options,
|
|
|
231 this._getCreateOptions(),
|
|
|
232 options );
|
|
|
233
|
|
|
234 this.bindings = $();
|
|
|
235 this.hoverable = $();
|
|
|
236 this.focusable = $();
|
|
|
237
|
|
|
238 if ( element !== this ) {
|
|
|
239 $.data( element, this.widgetFullName, this );
|
|
|
240 this._on( true, this.element, {
|
|
|
241 remove: function( event ) {
|
|
|
242 if ( event.target === element ) {
|
|
|
243 this.destroy();
|
|
|
244 }
|
|
|
245 }
|
|
|
246 });
|
|
|
247 this.document = $( element.style ?
|
|
|
248 // element within the document
|
|
|
249 element.ownerDocument :
|
|
|
250 // element is window or document
|
|
|
251 element.document || element );
|
|
|
252 this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
|
|
|
253 }
|
|
|
254
|
|
|
255 this._create();
|
|
|
256 this._trigger( "create", null, this._getCreateEventData() );
|
|
|
257 this._init();
|
|
|
258 },
|
|
|
259 _getCreateOptions: $.noop,
|
|
|
260 _getCreateEventData: $.noop,
|
|
|
261 _create: $.noop,
|
|
|
262 _init: $.noop,
|
|
|
263
|
|
|
264 destroy: function() {
|
|
|
265 this._destroy();
|
|
|
266 // we can probably remove the unbind calls in 2.0
|
|
|
267 // all event bindings should go through this._on()
|
|
|
268 this.element
|
|
|
269 .unbind( this.eventNamespace )
|
|
|
270 // 1.9 BC for #7810
|
|
|
271 // TODO remove dual storage
|
|
|
272 .removeData( this.widgetName )
|
|
|
273 .removeData( this.widgetFullName )
|
|
|
274 // support: jquery <1.6.3
|
|
|
275 // http://bugs.jquery.com/ticket/9413
|
|
|
276 .removeData( $.camelCase( this.widgetFullName ) );
|
|
|
277 this.widget()
|
|
|
278 .unbind( this.eventNamespace )
|
|
|
279 .removeAttr( "aria-disabled" )
|
|
|
280 .removeClass(
|
|
|
281 this.widgetFullName + "-disabled " +
|
|
|
282 "ui-state-disabled" );
|
|
|
283
|
|
|
284 // clean up events and states
|
|
|
285 this.bindings.unbind( this.eventNamespace );
|
|
|
286 this.hoverable.removeClass( "ui-state-hover" );
|
|
|
287 this.focusable.removeClass( "ui-state-focus" );
|
|
|
288 },
|
|
|
289 _destroy: $.noop,
|
|
|
290
|
|
|
291 widget: function() {
|
|
|
292 return this.element;
|
|
|
293 },
|
|
|
294
|
|
|
295 option: function( key, value ) {
|
|
|
296 var options = key,
|
|
|
297 parts,
|
|
|
298 curOption,
|
|
|
299 i;
|
|
|
300
|
|
|
301 if ( arguments.length === 0 ) {
|
|
|
302 // don't return a reference to the internal hash
|
|
|
303 return $.widget.extend( {}, this.options );
|
|
|
304 }
|
|
|
305
|
|
|
306 if ( typeof key === "string" ) {
|
|
|
307 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
|
|
|
308 options = {};
|
|
|
309 parts = key.split( "." );
|
|
|
310 key = parts.shift();
|
|
|
311 if ( parts.length ) {
|
|
|
312 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
|
|
|
313 for ( i = 0; i < parts.length - 1; i++ ) {
|
|
|
314 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
|
|
|
315 curOption = curOption[ parts[ i ] ];
|
|
|
316 }
|
|
|
317 key = parts.pop();
|
|
|
318 if ( arguments.length === 1 ) {
|
|
|
319 return curOption[ key ] === undefined ? null : curOption[ key ];
|
|
|
320 }
|
|
|
321 curOption[ key ] = value;
|
|
|
322 } else {
|
|
|
323 if ( arguments.length === 1 ) {
|
|
|
324 return this.options[ key ] === undefined ? null : this.options[ key ];
|
|
|
325 }
|
|
|
326 options[ key ] = value;
|
|
|
327 }
|
|
|
328 }
|
|
|
329
|
|
|
330 this._setOptions( options );
|
|
|
331
|
|
|
332 return this;
|
|
|
333 },
|
|
|
334 _setOptions: function( options ) {
|
|
|
335 var key;
|
|
|
336
|
|
|
337 for ( key in options ) {
|
|
|
338 this._setOption( key, options[ key ] );
|
|
|
339 }
|
|
|
340
|
|
|
341 return this;
|
|
|
342 },
|
|
|
343 _setOption: function( key, value ) {
|
|
|
344 this.options[ key ] = value;
|
|
|
345
|
|
|
346 if ( key === "disabled" ) {
|
|
|
347 this.widget()
|
|
|
348 .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
|
|
|
349 .attr( "aria-disabled", value );
|
|
|
350 this.hoverable.removeClass( "ui-state-hover" );
|
|
|
351 this.focusable.removeClass( "ui-state-focus" );
|
|
|
352 }
|
|
|
353
|
|
|
354 return this;
|
|
|
355 },
|
|
|
356
|
|
|
357 enable: function() {
|
|
|
358 return this._setOption( "disabled", false );
|
|
|
359 },
|
|
|
360 disable: function() {
|
|
|
361 return this._setOption( "disabled", true );
|
|
|
362 },
|
|
|
363
|
|
|
364 _on: function( suppressDisabledCheck, element, handlers ) {
|
|
|
365 var delegateElement,
|
|
|
366 instance = this;
|
|
|
367
|
|
|
368 // no suppressDisabledCheck flag, shuffle arguments
|
|
|
369 if ( typeof suppressDisabledCheck !== "boolean" ) {
|
|
|
370 handlers = element;
|
|
|
371 element = suppressDisabledCheck;
|
|
|
372 suppressDisabledCheck = false;
|
|
|
373 }
|
|
|
374
|
|
|
375 // no element argument, shuffle and use this.element
|
|
|
376 if ( !handlers ) {
|
|
|
377 handlers = element;
|
|
|
378 element = this.element;
|
|
|
379 delegateElement = this.widget();
|
|
|
380 } else {
|
|
|
381 // accept selectors, DOM elements
|
|
|
382 element = delegateElement = $( element );
|
|
|
383 this.bindings = this.bindings.add( element );
|
|
|
384 }
|
|
|
385
|
|
|
386 $.each( handlers, function( event, handler ) {
|
|
|
387 function handlerProxy() {
|
|
|
388 // allow widgets to customize the disabled handling
|
|
|
389 // - disabled as an array instead of boolean
|
|
|
390 // - disabled class as method for disabling individual parts
|
|
|
391 if ( !suppressDisabledCheck &&
|
|
|
392 ( instance.options.disabled === true ||
|
|
|
393 $( this ).hasClass( "ui-state-disabled" ) ) ) {
|
|
|
394 return;
|
|
|
395 }
|
|
|
396 return ( typeof handler === "string" ? instance[ handler ] : handler )
|
|
|
397 .apply( instance, arguments );
|
|
|
398 }
|
|
|
399
|
|
|
400 // copy the guid so direct unbinding works
|
|
|
401 if ( typeof handler !== "string" ) {
|
|
|
402 handlerProxy.guid = handler.guid =
|
|
|
403 handler.guid || handlerProxy.guid || $.guid++;
|
|
|
404 }
|
|
|
405
|
|
|
406 var match = event.match( /^(\w+)\s*(.*)$/ ),
|
|
|
407 eventName = match[1] + instance.eventNamespace,
|
|
|
408 selector = match[2];
|
|
|
409 if ( selector ) {
|
|
|
410 delegateElement.delegate( selector, eventName, handlerProxy );
|
|
|
411 } else {
|
|
|
412 element.bind( eventName, handlerProxy );
|
|
|
413 }
|
|
|
414 });
|
|
|
415 },
|
|
|
416
|
|
|
417 _off: function( element, eventName ) {
|
|
|
418 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
|
|
|
419 element.unbind( eventName ).undelegate( eventName );
|
|
|
420 },
|
|
|
421
|
|
|
422 _delay: function( handler, delay ) {
|
|
|
423 function handlerProxy() {
|
|
|
424 return ( typeof handler === "string" ? instance[ handler ] : handler )
|
|
|
425 .apply( instance, arguments );
|
|
|
426 }
|
|
|
427 var instance = this;
|
|
|
428 return setTimeout( handlerProxy, delay || 0 );
|
|
|
429 },
|
|
|
430
|
|
|
431 _hoverable: function( element ) {
|
|
|
432 this.hoverable = this.hoverable.add( element );
|
|
|
433 this._on( element, {
|
|
|
434 mouseenter: function( event ) {
|
|
|
435 $( event.currentTarget ).addClass( "ui-state-hover" );
|
|
|
436 },
|
|
|
437 mouseleave: function( event ) {
|
|
|
438 $( event.currentTarget ).removeClass( "ui-state-hover" );
|
|
|
439 }
|
|
|
440 });
|
|
|
441 },
|
|
|
442
|
|
|
443 _focusable: function( element ) {
|
|
|
444 this.focusable = this.focusable.add( element );
|
|
|
445 this._on( element, {
|
|
|
446 focusin: function( event ) {
|
|
|
447 $( event.currentTarget ).addClass( "ui-state-focus" );
|
|
|
448 },
|
|
|
449 focusout: function( event ) {
|
|
|
450 $( event.currentTarget ).removeClass( "ui-state-focus" );
|
|
|
451 }
|
|
|
452 });
|
|
|
453 },
|
|
|
454
|
|
|
455 _trigger: function( type, event, data ) {
|
|
|
456 var prop, orig,
|
|
|
457 callback = this.options[ type ];
|
|
|
458
|
|
|
459 data = data || {};
|
|
|
460 event = $.Event( event );
|
|
|
461 event.type = ( type === this.widgetEventPrefix ?
|
|
|
462 type :
|
|
|
463 this.widgetEventPrefix + type ).toLowerCase();
|
|
|
464 // the original event may come from any element
|
|
|
465 // so we need to reset the target on the new event
|
|
|
466 event.target = this.element[ 0 ];
|
|
|
467
|
|
|
468 // copy original event properties over to the new event
|
|
|
469 orig = event.originalEvent;
|
|
|
470 if ( orig ) {
|
|
|
471 for ( prop in orig ) {
|
|
|
472 if ( !( prop in event ) ) {
|
|
|
473 event[ prop ] = orig[ prop ];
|
|
|
474 }
|
|
|
475 }
|
|
|
476 }
|
|
|
477
|
|
|
478 this.element.trigger( event, data );
|
|
|
479 return !( $.isFunction( callback ) &&
|
|
|
480 callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
|
|
|
481 event.isDefaultPrevented() );
|
|
|
482 }
|
|
|
483 };
|
|
|
484
|
|
|
485 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
|
|
|
486 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
|
|
|
487 if ( typeof options === "string" ) {
|
|
|
488 options = { effect: options };
|
|
|
489 }
|
|
|
490 var hasOptions,
|
|
|
491 effectName = !options ?
|
|
|
492 method :
|
|
|
493 options === true || typeof options === "number" ?
|
|
|
494 defaultEffect :
|
|
|
495 options.effect || defaultEffect;
|
|
|
496 options = options || {};
|
|
|
497 if ( typeof options === "number" ) {
|
|
|
498 options = { duration: options };
|
|
|
499 }
|
|
|
500 hasOptions = !$.isEmptyObject( options );
|
|
|
501 options.complete = callback;
|
|
|
502 if ( options.delay ) {
|
|
|
503 element.delay( options.delay );
|
|
|
504 }
|
|
|
505 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
|
|
|
506 element[ method ]( options );
|
|
|
507 } else if ( effectName !== method && element[ effectName ] ) {
|
|
|
508 element[ effectName ]( options.duration, options.easing, callback );
|
|
|
509 } else {
|
|
|
510 element.queue(function( next ) {
|
|
|
511 $( this )[ method ]();
|
|
|
512 if ( callback ) {
|
|
|
513 callback.call( element[ 0 ] );
|
|
|
514 }
|
|
|
515 next();
|
|
|
516 });
|
|
|
517 }
|
|
|
518 };
|
|
|
519 });
|
|
|
520
|
|
|
521 })( jQuery );
|
