1 /*! |
|
2 * jQuery UI Widget 1.10.3 |
|
3 * http://jqueryui.com |
|
4 * |
|
5 * Copyright 2013 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 |
|
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 ( value === undefined ) { |
|
319 return curOption[ key ] === undefined ? null : curOption[ key ]; |
|
320 } |
|
321 curOption[ key ] = value; |
|
322 } else { |
|
323 if ( value === undefined ) { |
|
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 ); |
|