jquery-ui-1.10.3/ui/jquery.ui.widget.js

/*!
 * jQuery UI Widget 1.10.3
 * http://jqueryui.com
 *
 * Copyright 2013 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/jQuery.widget/
 */
(function( $, undefined ) {

var uuid = 0,
        slice = Array.prototype.slice,
        _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 );
};

$.widget = function( name, base, prototype ) {
        var fullName, existingConstructor, constructor, basePrototype,
                // proxiedPrototype allows the provided prototype to remain unmodified
                // so that it can be used as a mixin for multiple widgets (#8876)
                proxiedPrototype = {},
                namespace = name.split( "." )[ 0 ];

        name = name.split( "." )[ 1 ];
        fullName = namespace + "-" + name;

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

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

        $[ namespace ] = $[ namespace ] || {};
        existingConstructor = $[ namespace ][ name ];
        constructor = $[ namespace ][ name ] = function( options, element ) {
                // allow instantiation without "new" keyword
                if ( !this._createWidget ) {
                        return new constructor( options, element );
                }

                // allow instantiation without initializing for simple inheritance
                // must use "new" keyword (the code above always passes args)
                if ( arguments.length ) {
                        this._createWidget( options, element );
                }
        };
        // extend with the existing constructor to carry over any static properties
        $.extend( constructor, existingConstructor, {
                version: prototype.version,
                // copy the object used to create the prototype in case we need to
                // redefine the widget later
                _proto: $.extend( {}, prototype ),
                // track widgets that inherit from this widget in case this widget is
                // redefined after a widget inherits from it
                _childConstructors: []
        });

        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
        basePrototype.options = $.widget.extend( {}, basePrototype.options );
        $.each( prototype, function( prop, value ) {
                if ( !$.isFunction( value ) ) {
                        proxiedPrototype[ prop ] = value;
                        return;
                }
                proxiedPrototype[ prop ] = (function() {
                        var _super = function() {
                                        return base.prototype[ prop ].apply( this, arguments );
                                },
                                _superApply = function( args ) {
                                        return base.prototype[ prop ].apply( this, args );
                                };
                        return function() {
                                var __super = this._super,
                                        __superApply = this._superApply,
                                        returnValue;

                                this._super = _super;
                                this._superApply = _superApply;

                                returnValue = value.apply( this, arguments );

                                this._super = __super;
                                this._superApply = __superApply;

                                return returnValue;
                        };
                })();
        });
        constructor.prototype = $.widget.extend( basePrototype, {
                // TODO: remove support for widgetEventPrefix
                // always use the name + a colon as the prefix, e.g., draggable:start
                // don't prefix for widgets that aren't DOM-based
                widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
        }, proxiedPrototype, {
                constructor: constructor,
                namespace: namespace,
                widgetName: name,
                widgetFullName: fullName
        });

        // If this widget is being redefined then we need to find all widgets that
        // are inheriting from it and redefine all of them so that they inherit from
        // the new version of this widget. We're essentially trying to replace one
        // level in the prototype chain.
        if ( existingConstructor ) {
                $.each( existingConstructor._childConstructors, function( i, child ) {
                        var childPrototype = child.prototype;

                        // redefine the child widget using the same prototype that was
                        // originally used, but inherit from the new version of the base
                        $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
                });
                // remove the list of existing child constructors from the old constructor
                // so the old child constructors can be garbage collected
                delete existingConstructor._childConstructors;
        } else {
                base._childConstructors.push( constructor );
        }

        $.widget.bridge( name, constructor );
};

$.widget.extend = function( target ) {
        var input = slice.call( arguments, 1 ),
                inputIndex = 0,
                inputLength = input.length,
                key,
                value;
        for ( ; inputIndex < inputLength; inputIndex++ ) {
                for ( key in input[ inputIndex ] ) {
                        value = input[ inputIndex ][ key ];
                        if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
                                // Clone objects
                                if ( $.isPlainObject( value ) ) {
                                        target[ key ] = $.isPlainObject( target[ key ] ) ?
                                                $.widget.extend( {}, target[ key ], value ) :
                                                // Don't extend strings, arrays, etc. with objects
                                                $.widget.extend( {}, value );
                                // Copy everything else by reference
                                } else {
                                        target[ key ] = value;
                                }
                        }
                }
        }
        return target;
};

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

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

                if ( isMethodCall ) {
                        this.each(function() {
                                var methodValue,
                                        instance = $.data( this, fullName );
                                if ( !instance ) {
                                        return $.error( "cannot call methods on " + name + " prior to initialization; " +
                                                "attempted to call method '" + options + "'" );
                                }
                                if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
                                        return $.error( "no such method '" + options + "' for " + name + " widget instance" );
                                }
                                methodValue = instance[ options ].apply( instance, args );
                                if ( methodValue !== instance && methodValue !== undefined ) {
                                        returnValue = methodValue && methodValue.jquery ?
                                                returnValue.pushStack( methodValue.get() ) :
                                                methodValue;
                                        return false;
                                }
                        });
                } else {
                        this.each(function() {
                                var instance = $.data( this, fullName );
                                if ( instance ) {
                                        instance.option( options || {} )._init();
                                } else {
                                        $.data( this, fullName, new object( options, this ) );
                                }
                        });
                }

                return returnValue;
        };
};

$.Widget = function( /* options, element */ ) {};
$.Widget._childConstructors = [];

$.Widget.prototype = {
        widgetName: "widget",
        widgetEventPrefix: "",
        defaultElement: "<div>",
        options: {
                disabled: false,

                // callbacks
                create: null
        },
        _createWidget: function( options, element ) {
                element = $( element || this.defaultElement || this )[ 0 ];
                this.element = $( element );
                this.uuid = uuid++;
                this.eventNamespace = "." + this.widgetName + this.uuid;
                this.options = $.widget.extend( {},
                        this.options,
                        this._getCreateOptions(),
                        options );

                this.bindings = $();
                this.hoverable = $();
                this.focusable = $();

                if ( element !== this ) {
                        $.data( element, this.widgetFullName, this );
                        this._on( true, this.element, {
                                remove: function( event ) {
                                        if ( event.target === element ) {
                                                this.destroy();
                                        }
                                }
                        });
                        this.document = $( element.style ?
                                // element within the document
                                element.ownerDocument :
                                // element is window or document
                                element.document || element );
                        this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
                }

                this._create();
                this._trigger( "create", null, this._getCreateEventData() );
                this._init();
        },
        _getCreateOptions: $.noop,
        _getCreateEventData: $.noop,
        _create: $.noop,
        _init: $.noop,

        destroy: function() {
                this._destroy();
                // we can probably remove the unbind calls in 2.0
                // all event bindings should go through this._on()
                this.element
                        .unbind( this.eventNamespace )
                        // 1.9 BC for #7810
                        // TODO remove dual storage
                        .removeData( this.widgetName )
                        .removeData( this.widgetFullName )
                        // support: jquery <1.6.3
                        // http://bugs.jquery.com/ticket/9413
                        .removeData( $.camelCase( this.widgetFullName ) );
                this.widget()
                        .unbind( this.eventNamespace )
                        .removeAttr( "aria-disabled" )
                        .removeClass(
                                this.widgetFullName + "-disabled " +
                                "ui-state-disabled" );

                // clean up events and states
                this.bindings.unbind( this.eventNamespace );
                this.hoverable.removeClass( "ui-state-hover" );
                this.focusable.removeClass( "ui-state-focus" );
        },
        _destroy: $.noop,

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

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

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

                if ( typeof key === "string" ) {
                        // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
                        options = {};
                        parts = key.split( "." );
                        key = parts.shift();
                        if ( parts.length ) {
                                curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
                                for ( i = 0; i < parts.length - 1; i++ ) {
                                        curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
                                        curOption = curOption[ parts[ i ] ];
                                }
                                key = parts.pop();
                                if ( value === undefined ) {
                                        return curOption[ key ] === undefined ? null : curOption[ key ];
                                }
                                curOption[ key ] = value;
                        } else {
                                if ( value === undefined ) {
                                        return this.options[ key ] === undefined ? null : this.options[ key ];
                                }
                                options[ key ] = value;
                        }
                }

                this._setOptions( options );

                return this;
        },
        _setOptions: function( options ) {
                var key;

                for ( key in options ) {
                        this._setOption( key, options[ key ] );
                }

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

                if ( key === "disabled" ) {
                        this.widget()
                                .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
                                .attr( "aria-disabled", value );
                        this.hoverable.removeClass( "ui-state-hover" );
                        this.focusable.removeClass( "ui-state-focus" );
                }

                return this;
        },

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

        _on: function( suppressDisabledCheck, element, handlers ) {
                var delegateElement,
                        instance = this;

                // no suppressDisabledCheck flag, shuffle arguments
                if ( typeof suppressDisabledCheck !== "boolean" ) {
                        handlers = element;
                        element = suppressDisabledCheck;
                        suppressDisabledCheck = false;
                }

                // no element argument, shuffle and use this.element
                if ( !handlers ) {
                        handlers = element;
                        element = this.element;
                        delegateElement = this.widget();
                } else {
                        // accept selectors, DOM elements
                        element = delegateElement = $( element );
                        this.bindings = this.bindings.add( element );
                }

                $.each( handlers, function( event, handler ) {
                        function handlerProxy() {
                                // allow widgets to customize the disabled handling
                                // - disabled as an array instead of boolean
                                // - disabled class as method for disabling individual parts
                                if ( !suppressDisabledCheck &&
                                                ( instance.options.disabled === true ||
                                                        $( this ).hasClass( "ui-state-disabled" ) ) ) {
                                        return;
                                }
                                return ( typeof handler === "string" ? instance[ handler ] : handler )
                                        .apply( instance, arguments );
                        }

                        // copy the guid so direct unbinding works
                        if ( typeof handler !== "string" ) {
                                handlerProxy.guid = handler.guid =
                                        handler.guid || handlerProxy.guid || $.guid++;
                        }

                        var match = event.match( /^(\w+)\s*(.*)$/ ),
                                eventName = match[1] + instance.eventNamespace,
                                selector = match[2];
                        if ( selector ) {
                                delegateElement.delegate( selector, eventName, handlerProxy );
                        } else {
                                element.bind( eventName, handlerProxy );
                        }
                });
        },

        _off: function( element, eventName ) {
                eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
                element.unbind( eventName ).undelegate( eventName );
        },

        _delay: function( handler, delay ) {
                function handlerProxy() {
                        return ( typeof handler === "string" ? instance[ handler ] : handler )
                                .apply( instance, arguments );
                }
                var instance = this;
                return setTimeout( handlerProxy, delay || 0 );
        },

        _hoverable: function( element ) {
                this.hoverable = this.hoverable.add( element );
                this._on( element, {
                        mouseenter: function( event ) {
                                $( event.currentTarget ).addClass( "ui-state-hover" );
                        },
                        mouseleave: function( event ) {
                                $( event.currentTarget ).removeClass( "ui-state-hover" );
                        }
                });
        },

        _focusable: function( element ) {
                this.focusable = this.focusable.add( element );
                this._on( element, {
                        focusin: function( event ) {
                                $( event.currentTarget ).addClass( "ui-state-focus" );
                        },
                        focusout: function( event ) {
                                $( event.currentTarget ).removeClass( "ui-state-focus" );
                        }
                });
        },

        _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.apply( this.element[0], [ event ].concat( data ) ) === false ||
                        event.isDefaultPrevented() );
        }
};

$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
        $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
                if ( typeof options === "string" ) {
                        options = { effect: options };
                }
                var hasOptions,
                        effectName = !options ?
                                method :
                                options === true || typeof options === "number" ?
                                        defaultEffect :
                                        options.effect || defaultEffect;
                options = options || {};
                if ( typeof options === "number" ) {
                        options = { duration: options };
                }
                hasOptions = !$.isEmptyObject( options );
                options.complete = callback;
                if ( options.delay ) {
                        element.delay( options.delay );
                }
                if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
                        element[ method ]( options );
                } else if ( effectName !== method && element[ effectName ] ) {
                        element[ effectName ]( options.duration, options.easing, callback );
                } else {
                        element.queue(function( next ) {
                                $( this )[ method ]();
                                if ( callback ) {
                                        callback.call( element[ 0 ] );
                                }
                                next();
                        });
                }
        };
});

})( jQuery );
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 );