src/queue.js

   1 define([
   2         "./core",
   3         "./deferred",
   4         "./callbacks"
   5 ], function( jQuery ) {
   6
   7 jQuery.extend({
   8         queue: function( elem, type, data ) {
   9                 var queue;
  10
  11                 if ( elem ) {
  12                         type = ( type || "fx" ) + "queue";
  13                         queue = jQuery._data( elem, type );
  14
  15                         // Speed up dequeue by getting out quickly if this is just a lookup
  16                         if ( data ) {
  17                                 if ( !queue || jQuery.isArray(data) ) {
  18                                         queue = jQuery._data( elem, type, jQuery.makeArray(data) );
  19                                 } else {
  20                                         queue.push( data );
  21                                 }
  22                         }
  23                         return queue || [];
  24                 }
  25         },
  26
  27         dequeue: function( elem, type ) {
  28                 type = type || "fx";
  29
  30                 var queue = jQuery.queue( elem, type ),
  31                         startLength = queue.length,
  32                         fn = queue.shift(),
  33                         hooks = jQuery._queueHooks( elem, type ),
  34                         next = function() {
  35                                 jQuery.dequeue( elem, type );
  36                         };
  37
  38                 // If the fx queue is dequeued, always remove the progress sentinel
  39                 if ( fn === "inprogress" ) {
  40                         fn = queue.shift();
  41                         startLength--;
  42                 }
  43
  44                 if ( fn ) {
  45
  46                         // Add a progress sentinel to prevent the fx queue from being
  47                         // automatically dequeued
  48                         if ( type === "fx" ) {
  49                                 queue.unshift( "inprogress" );
  50                         }
  51
  52                         // clear up the last queue stop function
  53                         delete hooks.stop;
  54                         fn.call( elem, next, hooks );
  55                 }
  56
  57                 if ( !startLength && hooks ) {
  58                         hooks.empty.fire();
  59                 }
  60         },
  61
  62         // not intended for public consumption - generates a queueHooks object,
  63         // or returns the current one
  64         _queueHooks: function( elem, type ) {
  65                 var key = type + "queueHooks";
  66                 return jQuery._data( elem, key ) || jQuery._data( elem, key, {
  67                         empty: jQuery.Callbacks("once memory").add(function() {
  68                                 jQuery._removeData( elem, type + "queue" );
  69                                 jQuery._removeData( elem, key );
  70                         })
  71                 });
  72         }
  73 });
  74
  75 jQuery.fn.extend({
  76         queue: function( type, data ) {
  77                 var setter = 2;
  78
  79                 if ( typeof type !== "string" ) {
  80                         data = type;
  81                         type = "fx";
  82                         setter--;
  83                 }
  84
  85                 if ( arguments.length < setter ) {
  86                         return jQuery.queue( this[0], type );
  87                 }
  88
  89                 return data === undefined ?
  90                         this :
  91                         this.each(function() {
  92                                 var queue = jQuery.queue( this, type, data );
  93
  94                                 // ensure a hooks for this queue
  95                                 jQuery._queueHooks( this, type );
  96
  97                                 if ( type === "fx" && queue[0] !== "inprogress" ) {
  98                                         jQuery.dequeue( this, type );
  99                                 }
 100                         });
 101         },
 102         dequeue: function( type ) {
 103                 return this.each(function() {
 104                         jQuery.dequeue( this, type );
 105                 });
 106         },
 107         clearQueue: function( type ) {
 108                 return this.queue( type || "fx", [] );
 109         },
 110         // Get a promise resolved when queues of a certain type
 111         // are emptied (fx is the type by default)
 112         promise: function( type, obj ) {
 113                 var tmp,
 114                         count = 1,
 115                         defer = jQuery.Deferred(),
 116                         elements = this,
 117                         i = this.length,
 118                         resolve = function() {
 119                                 if ( !( --count ) ) {
 120                                         defer.resolveWith( elements, [ elements ] );
 121                                 }
 122                         };
 123
 124                 if ( typeof type !== "string" ) {
 125                         obj = type;
 126                         type = undefined;
 127                 }
 128                 type = type || "fx";
 129
 130                 while ( i-- ) {
 131                         tmp = jQuery._data( elements[ i ], type + "queueHooks" );
 132                         if ( tmp && tmp.empty ) {
 133                                 count++;
 134                                 tmp.empty.add( resolve );
 135                         }
 136                 }
 137                 resolve();
 138                 return defer.promise( obj );
 139         }
 140 });
 141
 142 return jQuery;
 143 });