/*!
* jQuery UI Widget 1.8.2
*
* Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI/Widget
*/
(function( $ ) {

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() {
 $( this ).triggerHandler( "remove" );
 });
 }
 }
 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( {}, 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.substring( 0, 1 ) === "_" ) {
 return returnValue;
 }

 if ( isMethodCall ) {
 this.each(function() {
 var instance = $.data( this, name ),
 methodValue = instance && $.isFunction( instance[options] ) ?
 instance[ options ].apply( instance, args ) :
 instance;
 if ( methodValue !== instance && methodValue !== undefined ) {
 returnValue = methodValue;
 return false;
 }
 });
 } else {
this.each(function() {
 var instance = $.data( this, name );
 if ( instance ) {
 if ( options ) {
 instance.option( options );
 }
 instance._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
 this.element = $( element ).data( this.widgetName, this );
 this.options = $.extend( true, {},
 this.options,
 $.metadata && $.metadata.get( element )[ this.widgetName ],
 options );

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

 this._create();
 this._init();
 },
 _create: function() {},
 _init: function() {},

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

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

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

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

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

 $.each( options, function( key, value ) {
 self._setOption( key, value );
 });

 return self;
 },
 _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 callback = this.options[ type ];

event = $.Event( event );
 event.type = ( type === this.widgetEventPrefix ?
 type :
 this.widgetEventPrefix + type ).toLowerCase();
 data = data || {};

 // copy original event properties over to the new event
 // this would happen if we could call $.event.fix instead of $.Event
 // but we don't have a way to force an event to be fixed multiple times
 if ( event.originalEvent ) {
 for ( var i = $.event.props.length, prop; i; ) {
 prop = $.event.props[ --i ];
 event[ prop ] = event.originalEvent[ prop ];
 }
 }

 this.element.trigger( event, data );

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

})( jQuery );