CLICK HERE TO BUY IT TODAY! OR GET IT FREE VIA TRIALPAY  

PHP Demo Application - Source Code

/Framework/Model/Vendor/jquery-ui/development-bundle/ui/jquery.ui.widget.js



/*!
 * jQuery UI Widget 1.8.4
 *
 * Copyright 2010, 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 ) {
	var _remove = $.fn.remove;
	$.fn.remove = function( selectorkeepData ) {
		    return this.each(function() {
			        if ( !keepData ) {
				            if ( !selector || $.filterselector, [ this ] ).length ) {
					                $( "*"this ).add( [ this ] ).each(function() {
						                    $( this ).triggerHandler"remove" );
						                });
					            }
				        }
			        return _remove.call( $(this), selectorkeepData );
			    });
		};
	$.widget = function( namebaseprototype ) {
		    var namespace = name.split"." )[ ],
		        fullName;
		    name name.split"." )[ ];
		    fullName = namespace + "-" name;
		    if ( !prototype ) {
			        prototype base;
			        base = $.Widget;
			    }
		    // create selector for plugin
		    $.expr":" ][ fullName ] = function( elem ) {
			        return !!$.dataelemname );
			    };
		    $[ namespace ] = $[ namespace ] || {};
		    $[ namespace ][ name ] = function( optionselement ) {
			        // allow instantiation without initializing for simple inheritance
			        if ( arguments.length ) {
				            this._createWidgetoptionselement );
				        }
			    };
		    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 = $.extendtrue{}basePrototype.options );
		    $[ namespace ][ name ].prototype = $.extendtruebasePrototype, {
			        namespace: namespace,
			        widgetNamename,
			        widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
			        widgetBaseClassfullName
			    }, prototype );
		    $.widget.bridgename, $[ namespace ][ name ] );
		};
	$.widget.bridge = function( nameobject ) {
		    $.fnname ] = function( options ) {
			        var isMethodCall typeof options === "string",
			            args = Array.prototype.slice.callarguments),
			            returnValue this;
			        // allow multiple hashes to be passed on init
			        options = !isMethodCall && args.length ?
			            $.extend.applynull, [ trueoptions ].concat(args) ) :
			            options;
			        // prevent calls to internal methods
			        if ( isMethodCall && options.substring0) === "_" ) {
				            return returnValue;
				        }
			        if ( isMethodCall ) {
				            this.each(function() {
					                var instance = $.datathisname ),
					                    methodValue instance && $.isFunctioninstance[options] ) ?
					                        instanceoptions ].applyinstanceargs ) :
					                        instance;
					                if ( methodValue !== instance && methodValue !== undefined ) {
						                    returnValue methodValue;
						                    return false;
						                }
					            });
				        } else {
				            this.each(function() {
					                var instance = $.datathisname );
					                if ( instance ) {
						                    if ( options ) {
							                        instance.optionoptions );
							                    }
						                    instance._init();
						                } else {
						                    $.datathisname, new objectoptionsthis ) );
						                }
					            });
				        }
			        return returnValue;
			    };
		};
	$.Widget = function( optionselement ) {
		    // allow instantiation without initializing for simple inheritance
		    if ( arguments.length ) {
			        this._createWidgetoptionselement );
			    }
		};
	$.Widget.prototype = {
		    widgetName"widget",
		    widgetEventPrefix"",
		    options: {
			        disabledfalse
			    },
		    _createWidget: function( optionselement ) {
			        // $.widget.bridge stores the plugin instance, but we do it anyway
			        // so that it's stored even before the _create function runs
			        $.dataelementthis.widgetNamethis );
			        this.element = $( element );
			        this.options = $.extendtrue{},
			            this.options,
			            $.metadata && $.metadata.getelement )[ 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 )
			            .removeDatathis.widgetName );
			        this.widget()
			            .unbind"." this.widgetName )
			            .removeAttr"aria-disabled" )
			            .removeClass(
			                this.widgetBaseClass "-disabled " +
			                "ui-state-disabled" );
			    },
		    widget: function() {
			        return this.element;
			    },
		    option: function( keyvalue ) {
			        var options key,
			            self this;
			        if ( arguments.length === ) {
				            // don't return a reference to the internal hash
				            return $.extend{}self.options );
				        }
			        if  (typeof key === "string" ) {
				            if ( value === undefined ) {
					                return this.optionskey ];
					            }
				            options {};
				            optionskey ] = value;
				        }
			        $.eachoptions, function( keyvalue ) {
				            self._setOptionkeyvalue );
				        });
			        return self;
			    },
		    _setOption: function( keyvalue ) {
			        this.optionskey ] = 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( typeeventdata ) {
			        var callback this.optionstype ];
			        event = $.Eventevent );
			        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 = $.event.props.lengthprop;
				 i;
				 ) {
					                prop = $.event.props[ --];
					                eventprop ] = event.originalEventprop ];
					            }
				        }
			        this.element.triggereventdata );
			        return !( $.isFunction(callback) &&
			            callback.callthis.element[0], eventdata ) === false ||
			            event.isDefaultPrevented() );
			    }
		};
	})( jQuery );





PHP Demo Source Code Index