PageRenderTime 59ms CodeModel.GetById 21ms app.highlight 32ms RepoModel.GetById 1ms app.codeStats 1ms

/application/static/libs/adminlte/bower_components/jquery-ui/ui/widget.js

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