filex/static/filex/fileupload/jquery.ui.widget.js

   1 /*! jQuery UI - v1.11.1+CommonJS - 2014-09-17
   2 * http://jqueryui.com
   3 * Includes: widget.js
   4 * Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */
   5
   6 (function( factory ) {
   7         if ( typeof define === "function" && define.amd ) {
   8
   9                 // AMD. Register as an anonymous module.
  10                 define([ "jquery" ], factory );
  11
  12         } else if (typeof exports === "object") {
  13                 // Node/CommonJS:
  14                 factory(require("jquery"));
  15
  16         } else {
  17
  18                 // Browser globals
  19                 factory( jQuery );
  20         }
  21 }(function( $ ) {
  22 /*!
  23  * jQuery UI Widget 1.11.1
  24  * http://jqueryui.com
  25  *
  26  * Copyright 2014 jQuery Foundation and other contributors
  27  * Released under the MIT license.
  28  * http://jquery.org/license
  29  *
  30  * http://api.jqueryui.com/jQuery.widget/
  31  */
  32
  33
  34 var widget_uuid = 0,
  35         widget_slice = Array.prototype.slice;
  36
  37 $.cleanData = (function( orig ) {
  38         return function( elems ) {
  39                 var events, elem, i;
  40                 for ( i = 0; (elem = elems[i]) != null; i++ ) {
  41                         try {
  42
  43                                 // Only trigger remove when necessary to save time
  44                                 events = $._data( elem, "events" );
  45                                 if ( events && events.remove ) {
  46                                         $( elem ).triggerHandler( "remove" );
  47                                 }
  48
  49                         // http://bugs.jquery.com/ticket/8235
  50                         } catch( e ) {}
  51                 }
  52                 orig( elems );
  53         };
  54 })( $.cleanData );
  55
  56 $.widget = function( name, base, prototype ) {
  57         var fullName, existingConstructor, constructor, basePrototype,
  58                 // proxiedPrototype allows the provided prototype to remain unmodified
  59                 // so that it can be used as a mixin for multiple widgets (#8876)
  60                 proxiedPrototype = {},
  61                 namespace = name.split( "." )[ 0 ];
  62
  63         name = name.split( "." )[ 1 ];
  64         fullName = namespace + "-" + name;
  65
  66         if ( !prototype ) {
  67                 prototype = base;
  68                 base = $.Widget;
  69         }
  70
  71         // create selector for plugin
  72         $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
  73                 return !!$.data( elem, fullName );
  74         };
  75
  76         $[ namespace ] = $[ namespace ] || {};
  77         existingConstructor = $[ namespace ][ name ];
  78         constructor = $[ namespace ][ name ] = function( options, element ) {
  79                 // allow instantiation without "new" keyword
  80                 if ( !this._createWidget ) {
  81                         return new constructor( options, element );
  82                 }
  83
  84                 // allow instantiation without initializing for simple inheritance
  85                 // must use "new" keyword (the code above always passes args)
  86                 if ( arguments.length ) {
  87                         this._createWidget( options, element );
  88                 }
  89         };
  90         // extend with the existing constructor to carry over any static properties
  91         $.extend( constructor, existingConstructor, {
  92                 version: prototype.version,
  93                 // copy the object used to create the prototype in case we need to
  94                 // redefine the widget later
  95                 _proto: $.extend( {}, prototype ),
  96                 // track widgets that inherit from this widget in case this widget is
  97                 // redefined after a widget inherits from it
  98                 _childConstructors: []
  99         });
 100
 101         basePrototype = new base();
 102         // we need to make the options hash a property directly on the new instance
 103         // otherwise we'll modify the options hash on the prototype that we're
 104         // inheriting from
 105         basePrototype.options = $.widget.extend( {}, basePrototype.options );
 106         $.each( prototype, function( prop, value ) {
 107                 if ( !$.isFunction( value ) ) {
 108                         proxiedPrototype[ prop ] = value;
 109                         return;
 110                 }
 111                 proxiedPrototype[ prop ] = (function() {
 112                         var _super = function() {
 113                                         return base.prototype[ prop ].apply( this, arguments );
 114                                 },
 115                                 _superApply = function( args ) {
 116                                         return base.prototype[ prop ].apply( this, args );
 117                                 };
 118                         return function() {
 119                                 var __super = this._super,
 120                                         __superApply = this._superApply,
 121                                         returnValue;
 122
 123                                 this._super = _super;
 124                                 this._superApply = _superApply;
 125
 126                                 returnValue = value.apply( this, arguments );
 127
 128                                 this._super = __super;
 129                                 this._superApply = __superApply;
 130
 131                                 return returnValue;
 132                         };
 133                 })();
 134         });
 135         constructor.prototype = $.widget.extend( basePrototype, {
 136                 // TODO: remove support for widgetEventPrefix
 137                 // always use the name + a colon as the prefix, e.g., draggable:start
 138                 // don't prefix for widgets that aren't DOM-based
 139                 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
 140         }, proxiedPrototype, {
 141                 constructor: constructor,
 142                 namespace: namespace,
 143                 widgetName: name,
 144                 widgetFullName: fullName
 145         });
 146
 147         // If this widget is being redefined then we need to find all widgets that
 148         // are inheriting from it and redefine all of them so that they inherit from
 149         // the new version of this widget. We're essentially trying to replace one
 150         // level in the prototype chain.
 151         if ( existingConstructor ) {
 152                 $.each( existingConstructor._childConstructors, function( i, child ) {
 153                         var childPrototype = child.prototype;
 154
 155                         // redefine the child widget using the same prototype that was
 156                         // originally used, but inherit from the new version of the base
 157                         $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
 158                 });
 159                 // remove the list of existing child constructors from the old constructor
 160                 // so the old child constructors can be garbage collected
 161                 delete existingConstructor._childConstructors;
 162         } else {
 163                 base._childConstructors.push( constructor );
 164         }
 165
 166         $.widget.bridge( name, constructor );
 167
 168         return constructor;
 169 };
 170
 171 $.widget.extend = function( target ) {
 172         var input = widget_slice.call( arguments, 1 ),
 173                 inputIndex = 0,
 174                 inputLength = input.length,
 175                 key,
 176                 value;
 177         for ( ; inputIndex < inputLength; inputIndex++ ) {
 178                 for ( key in input[ inputIndex ] ) {
 179                         value = input[ inputIndex ][ key ];
 180                         if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
 181                                 // Clone objects
 182                                 if ( $.isPlainObject( value ) ) {
 183                                         target[ key ] = $.isPlainObject( target[ key ] ) ?
 184                                                 $.widget.extend( {}, target[ key ], value ) :
 185                                                 // Don't extend strings, arrays, etc. with objects
 186                                                 $.widget.extend( {}, value );
 187                                 // Copy everything else by reference
 188                                 } else {
 189                                         target[ key ] = value;
 190                                 }
 191                         }
 192                 }
 193         }
 194         return target;
 195 };
 196
 197 $.widget.bridge = function( name, object ) {
 198         var fullName = object.prototype.widgetFullName || name;
 199         $.fn[ name ] = function( options ) {
 200                 var isMethodCall = typeof options === "string",
 201                         args = widget_slice.call( arguments, 1 ),
 202                         returnValue = this;
 203
 204                 // allow multiple hashes to be passed on init
 205                 options = !isMethodCall && args.length ?
 206                         $.widget.extend.apply( null, [ options ].concat(args) ) :
 207                         options;
 208
 209                 if ( isMethodCall ) {
 210                         this.each(function() {
 211                                 var methodValue,
 212                                         instance = $.data( this, fullName );
 213                                 if ( options === "instance" ) {
 214                                         returnValue = instance;
 215                                         return false;
 216                                 }
 217                                 if ( !instance ) {
 218                                         return $.error( "cannot call methods on " + name + " prior to initialization; " +
 219                                                 "attempted to call method '" + options + "'" );
 220                                 }
 221                                 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
 222                                         return $.error( "no such method '" + options + "' for " + name + " widget instance" );
 223                                 }
 224                                 methodValue = instance[ options ].apply( instance, args );
 225                                 if ( methodValue !== instance && methodValue !== undefined ) {
 226                                         returnValue = methodValue && methodValue.jquery ?
 227                                                 returnValue.pushStack( methodValue.get() ) :
 228                                                 methodValue;
 229                                         return false;
 230                                 }
 231                         });
 232                 } else {
 233                         this.each(function() {
 234                                 var instance = $.data( this, fullName );
 235                                 if ( instance ) {
 236                                         instance.option( options || {} );
 237                                         if ( instance._init ) {
 238                                                 instance._init();
 239                                         }
 240                                 } else {
 241                                         $.data( this, fullName, new object( options, this ) );
 242                                 }
 243                         });
 244                 }
 245
 246                 return returnValue;
 247         };
 248 };
 249
 250 $.Widget = function( /* options, element */ ) {};
 251 $.Widget._childConstructors = [];
 252
 253 $.Widget.prototype = {
 254         widgetName: "widget",
 255         widgetEventPrefix: "",
 256         defaultElement: "<div>",
 257         options: {
 258                 disabled: false,
 259
 260                 // callbacks
 261                 create: null
 262         },
 263         _createWidget: function( options, element ) {
 264                 element = $( element || this.defaultElement || this )[ 0 ];
 265                 this.element = $( element );
 266                 this.uuid = widget_uuid++;
 267                 this.eventNamespace = "." + this.widgetName + this.uuid;
 268                 this.options = $.widget.extend( {},
 269                         this.options,
 270                         this._getCreateOptions(),
 271                         options );
 272
 273                 this.bindings = $();
 274                 this.hoverable = $();
 275                 this.focusable = $();
 276
 277                 if ( element !== this ) {
 278                         $.data( element, this.widgetFullName, this );
 279                         this._on( true, this.element, {
 280                                 remove: function( event ) {
 281                                         if ( event.target === element ) {
 282                                                 this.destroy();
 283                                         }
 284                                 }
 285                         });
 286                         this.document = $( element.style ?
 287                                 // element within the document
 288                                 element.ownerDocument :
 289                                 // element is window or document
 290                                 element.document || element );
 291                         this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
 292                 }
 293
 294                 this._create();
 295                 this._trigger( "create", null, this._getCreateEventData() );
 296                 this._init();
 297         },
 298         _getCreateOptions: $.noop,
 299         _getCreateEventData: $.noop,
 300         _create: $.noop,
 301         _init: $.noop,
 302
 303         destroy: function() {
 304                 this._destroy();
 305                 // we can probably remove the unbind calls in 2.0
 306                 // all event bindings should go through this._on()
 307                 this.element
 308                         .unbind( this.eventNamespace )
 309                         .removeData( this.widgetFullName )
 310                         // support: jquery <1.6.3
 311                         // http://bugs.jquery.com/ticket/9413
 312                         .removeData( $.camelCase( this.widgetFullName ) );
 313                 this.widget()
 314                         .unbind( this.eventNamespace )
 315                         .removeAttr( "aria-disabled" )
 316                         .removeClass(
 317                                 this.widgetFullName + "-disabled " +
 318                                 "ui-state-disabled" );
 319
 320                 // clean up events and states
 321                 this.bindings.unbind( this.eventNamespace );
 322                 this.hoverable.removeClass( "ui-state-hover" );
 323                 this.focusable.removeClass( "ui-state-focus" );
 324         },
 325         _destroy: $.noop,
 326
 327         widget: function() {
 328                 return this.element;
 329         },
 330
 331         option: function( key, value ) {
 332                 var options = key,
 333                         parts,
 334                         curOption,
 335                         i;
 336
 337                 if ( arguments.length === 0 ) {
 338                         // don't return a reference to the internal hash
 339                         return $.widget.extend( {}, this.options );
 340                 }
 341
 342                 if ( typeof key === "string" ) {
 343                         // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
 344                         options = {};
 345                         parts = key.split( "." );
 346                         key = parts.shift();
 347                         if ( parts.length ) {
 348                                 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
 349                                 for ( i = 0; i < parts.length - 1; i++ ) {
 350                                         curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
 351                                         curOption = curOption[ parts[ i ] ];
 352                                 }
 353                                 key = parts.pop();
 354                                 if ( arguments.length === 1 ) {
 355                                         return curOption[ key ] === undefined ? null : curOption[ key ];
 356                                 }
 357                                 curOption[ key ] = value;
 358                         } else {
 359                                 if ( arguments.length === 1 ) {
 360                                         return this.options[ key ] === undefined ? null : this.options[ key ];
 361                                 }
 362                                 options[ key ] = value;
 363                         }
 364                 }
 365
 366                 this._setOptions( options );
 367
 368                 return this;
 369         },
 370         _setOptions: function( options ) {
 371                 var key;
 372
 373                 for ( key in options ) {
 374                         this._setOption( key, options[ key ] );
 375                 }
 376
 377                 return this;
 378         },
 379         _setOption: function( key, value ) {
 380                 this.options[ key ] = value;
 381
 382                 if ( key === "disabled" ) {
 383                         this.widget()
 384                                 .toggleClass( this.widgetFullName + "-disabled", !!value );
 385
 386                         // If the widget is becoming disabled, then nothing is interactive
 387                         if ( value ) {
 388                                 this.hoverable.removeClass( "ui-state-hover" );
 389                                 this.focusable.removeClass( "ui-state-focus" );
 390                         }
 391                 }
 392
 393                 return this;
 394         },
 395
 396         enable: function() {
 397                 return this._setOptions({ disabled: false });
 398         },
 399         disable: function() {
 400                 return this._setOptions({ disabled: true });
 401         },
 402
 403         _on: function( suppressDisabledCheck, element, handlers ) {
 404                 var delegateElement,
 405                         instance = this;
 406
 407                 // no suppressDisabledCheck flag, shuffle arguments
 408                 if ( typeof suppressDisabledCheck !== "boolean" ) {
 409                         handlers = element;
 410                         element = suppressDisabledCheck;
 411                         suppressDisabledCheck = false;
 412                 }
 413
 414                 // no element argument, shuffle and use this.element
 415                 if ( !handlers ) {
 416                         handlers = element;
 417                         element = this.element;
 418                         delegateElement = this.widget();
 419                 } else {
 420                         element = delegateElement = $( element );
 421                         this.bindings = this.bindings.add( element );
 422                 }
 423
 424                 $.each( handlers, function( event, handler ) {
 425                         function handlerProxy() {
 426                                 // allow widgets to customize the disabled handling
 427                                 // - disabled as an array instead of boolean
 428                                 // - disabled class as method for disabling individual parts
 429                                 if ( !suppressDisabledCheck &&
 430                                                 ( instance.options.disabled === true ||
 431                                                         $( this ).hasClass( "ui-state-disabled" ) ) ) {
 432                                         return;
 433                                 }
 434                                 return ( typeof handler === "string" ? instance[ handler ] : handler )
 435                                         .apply( instance, arguments );
 436                         }
 437
 438                         // copy the guid so direct unbinding works
 439                         if ( typeof handler !== "string" ) {
 440                                 handlerProxy.guid = handler.guid =
 441                                         handler.guid || handlerProxy.guid || $.guid++;
 442                         }
 443
 444                         var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
 445                                 eventName = match[1] + instance.eventNamespace,
 446                                 selector = match[2];
 447                         if ( selector ) {
 448                                 delegateElement.delegate( selector, eventName, handlerProxy );
 449                         } else {
 450                                 element.bind( eventName, handlerProxy );
 451                         }
 452                 });
 453         },
 454
 455         _off: function( element, eventName ) {
 456                 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
 457                 element.unbind( eventName ).undelegate( eventName );
 458         },
 459
 460         _delay: function( handler, delay ) {
 461                 function handlerProxy() {
 462                         return ( typeof handler === "string" ? instance[ handler ] : handler )
 463                                 .apply( instance, arguments );
 464                 }
 465                 var instance = this;
 466                 return setTimeout( handlerProxy, delay || 0 );
 467         },
 468
 469         _hoverable: function( element ) {
 470                 this.hoverable = this.hoverable.add( element );
 471                 this._on( element, {
 472                         mouseenter: function( event ) {
 473                                 $( event.currentTarget ).addClass( "ui-state-hover" );
 474                         },
 475                         mouseleave: function( event ) {
 476                                 $( event.currentTarget ).removeClass( "ui-state-hover" );
 477                         }
 478                 });
 479         },
 480
 481         _focusable: function( element ) {
 482                 this.focusable = this.focusable.add( element );
 483                 this._on( element, {
 484                         focusin: function( event ) {
 485                                 $( event.currentTarget ).addClass( "ui-state-focus" );
 486                         },
 487                         focusout: function( event ) {
 488                                 $( event.currentTarget ).removeClass( "ui-state-focus" );
 489                         }
 490                 });
 491         },
 492
 493         _trigger: function( type, event, data ) {
 494                 var prop, orig,
 495                         callback = this.options[ type ];
 496
 497                 data = data || {};
 498                 event = $.Event( event );
 499                 event.type = ( type === this.widgetEventPrefix ?
 500                         type :
 501                         this.widgetEventPrefix + type ).toLowerCase();
 502                 // the original event may come from any element
 503                 // so we need to reset the target on the new event
 504                 event.target = this.element[ 0 ];
 505
 506                 // copy original event properties over to the new event
 507                 orig = event.originalEvent;
 508                 if ( orig ) {
 509                         for ( prop in orig ) {
 510                                 if ( !( prop in event ) ) {
 511                                         event[ prop ] = orig[ prop ];
 512                                 }
 513                         }
 514                 }
 515
 516                 this.element.trigger( event, data );
 517                 return !( $.isFunction( callback ) &&
 518                         callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
 519                         event.isDefaultPrevented() );
 520         }
 521 };
 522
 523 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
 524         $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
 525                 if ( typeof options === "string" ) {
 526                         options = { effect: options };
 527                 }
 528                 var hasOptions,
 529                         effectName = !options ?
 530                                 method :
 531                                 options === true || typeof options === "number" ?
 532                                         defaultEffect :
 533                                         options.effect || defaultEffect;
 534                 options = options || {};
 535                 if ( typeof options === "number" ) {
 536                         options = { duration: options };
 537                 }
 538                 hasOptions = !$.isEmptyObject( options );
 539                 options.complete = callback;
 540                 if ( options.delay ) {
 541                         element.delay( options.delay );
 542                 }
 543                 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
 544                         element[ method ]( options );
 545                 } else if ( effectName !== method && element[ effectName ] ) {
 546                         element[ effectName ]( options.duration, options.easing, callback );
 547                 } else {
 548                         element.queue(function( next ) {
 549                                 $( this )[ method ]();
 550                                 if ( callback ) {
 551                                         callback.call( element[ 0 ] );
 552                                 }
 553                                 next();
 554                         });
 555                 }
 556         };
 557 });
 558
 559 var widget = $.widget;
 560
 561
 562
 563 }));