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	torben	2125	/*!
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 );