hesabixCore/public_html/betheme/js/ui/jquery.ui.widget.js

/*!
 * jQuery UI Widget 1.8.22
 *
 * Copyright 2012, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Widget
 */
(function ($, undefined) {
	// jQuery 1.4+
	if ($.cleanData) {
		var _cleanData = $.cleanData;
		$.cleanData = function (elems) {
			for (var i = 0, elem; (elem = elems[i]) != null; i++) {
				try {
					$(elem).triggerHandler('remove');
					// http://bugs.jquery.com/ticket/8235
				} catch (e) {}
			}
			_cleanData(elems);
		};
	} else {
		var _remove = $.fn.remove;
		$.fn.remove = function (selector, keepData) {
			return this.each(function () {
				if (!keepData) {
					if (!selector || $.filter(selector, [this]).length) {
						$('*', this)
							.add([this])
							.each(function () {
								try {
									$(this).triggerHandler('remove');
									// http://bugs.jquery.com/ticket/8235
								} catch (e) {}
							});
					}
				}
				return _remove.call($(this), selector, keepData);
			});
		};
	}

	$.widget = function (name, base, prototype) {
		var namespace = name.split('.')[0],
			fullName;
		name = name.split('.')[1];
		fullName = namespace + '-' + name;

		if (!prototype) {
			prototype = base;
			base = $.Widget;
		}

		// create selector for plugin
		$.expr[':'][fullName] = function (elem) {
			return !!$.data(elem, name);
		};

		$[namespace] = $[namespace] || {};
		$[namespace][name] = function (options, element) {
			// allow instantiation without initializing for simple inheritance
			if (arguments.length) {
				this._createWidget(options, element);
			}
		};

		var basePrototype = new base();
		// we need to make the options hash a property directly on the new instance
		// otherwise we'll modify the options hash on the prototype that we're
		// inheriting from
		//	$.each( basePrototype, function( key, val ) {
		//		if ( $.isPlainObject(val) ) {
		//			basePrototype[ key ] = $.extend( {}, val );
		//		}
		//	});
		basePrototype.options = $.extend(true, {}, basePrototype.options);
		$[namespace][name].prototype = $.extend(
			true,
			basePrototype,
			{
				namespace: namespace,
				widgetName: name,
				widgetEventPrefix:
					$[namespace][name].prototype.widgetEventPrefix || name,
				widgetBaseClass: fullName,
			},
			prototype
		);

		$.widget.bridge(name, $[namespace][name]);
	};

	$.widget.bridge = function (name, object) {
		$.fn[name] = function (options) {
			var isMethodCall = typeof options === 'string',
				args = Array.prototype.slice.call(arguments, 1),
				returnValue = this;

			// allow multiple hashes to be passed on init
			options =
				!isMethodCall && args.length
					? $.extend.apply(null, [true, options].concat(args))
					: options;

			// prevent calls to internal methods
			if (isMethodCall && options.charAt(0) === '_') {
				return returnValue;
			}

			if (isMethodCall) {
				this.each(function () {
					var instance = $.data(this, name),
						methodValue =
							instance && $.isFunction(instance[options])
								? instance[options].apply(instance, args)
								: instance;
					// TODO: add this back in 1.9 and use $.error() (see #5972)
					//				if ( !instance ) {
					//					throw "cannot call methods on " + name + " prior to initialization; " +
					//						"attempted to call method '" + options + "'";
					//				}
					//				if ( !$.isFunction( instance[options] ) ) {
					//					throw "no such method '" + options + "' for " + name + " widget instance";
					//				}
					//				var methodValue = instance[ options ].apply( instance, args );
					if (methodValue !== instance && methodValue !== undefined) {
						returnValue = methodValue;
						return false;
					}
				});
			} else {
				this.each(function () {
					var instance = $.data(this, name);
					if (instance) {
						instance.option(options || {})._init();
					} else {
						$.data(this, name, new object(options, this));
					}
				});
			}

			return returnValue;
		};
	};

	$.Widget = function (options, element) {
		// allow instantiation without initializing for simple inheritance
		if (arguments.length) {
			this._createWidget(options, element);
		}
	};

	$.Widget.prototype = {
		widgetName: 'widget',
		widgetEventPrefix: '',
		options: {
			disabled: false,
		},
		_createWidget: function (options, element) {
			// $.widget.bridge stores the plugin instance, but we do it anyway
			// so that it's stored even before the _create function runs
			$.data(element, this.widgetName, this);
			this.element = $(element);
			this.options = $.extend(
				true,
				{},
				this.options,
				this._getCreateOptions(),
				options
			);

			var self = this;
			this.element.bind('remove.' + this.widgetName, function () {
				self.destroy();
			});

			this._create();
			this._trigger('create');
			this._init();
		},
		_getCreateOptions: function () {
			return $.metadata && $.metadata.get(this.element[0])[this.widgetName];
		},
		_create: function () {},
		_init: function () {},

		destroy: function () {
			this.element.off('.' + this.widgetName).removeData(this.widgetName);
			this.widget()
				.off('.' + this.widgetName)
				.removeAttr('aria-disabled')
				.removeClass(this.widgetBaseClass + '-disabled ' + 'ui-state-disabled');
		},

		widget: function () {
			return this.element;
		},

		option: function (key, value) {
			var options = key;

			if (arguments.length === 0) {
				// don't return a reference to the internal hash
				return $.extend({}, this.options);
			}

			if (typeof key === 'string') {
				if (value === undefined) {
					return this.options[key];
				}
				options = {};
				options[key] = value;
			}

			this._setOptions(options);

			return this;
		},
		_setOptions: function (options) {
			var self = this;
			$.each(options, function (key, value) {
				self._setOption(key, value);
			});

			return this;
		},
		_setOption: function (key, value) {
			this.options[key] = value;

			if (key === 'disabled') {
				this.widget()
					[value ? 'addClass' : 'removeClass'](
						this.widgetBaseClass + '-disabled' + ' ' + 'ui-state-disabled'
					)
					.attr('aria-disabled', value);
			}

			return this;
		},

		enable: function () {
			return this._setOption('disabled', false);
		},
		disable: function () {
			return this._setOption('disabled', true);
		},

		_trigger: function (type, event, data) {
			var prop,
				orig,
				callback = this.options[type];

			data = data || {};
			event = $.Event(event);
			event.type = (
				type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type
			).toLowerCase();
			// the original event may come from any element
			// so we need to reset the target on the new event
			event.target = this.element[0];

			// copy original event properties over to the new event
			orig = event.originalEvent;
			if (orig) {
				for (prop in orig) {
					if (!(prop in event)) {
						event[prop] = orig[prop];
					}
				}
			}

			this.element.trigger(event, data);

			return !(
				($.isFunction(callback) &&
					callback.call(this.element[0], event, data) === false) ||
				event.isDefaultPrevented()
			);
		},
	};
})(jQuery);