5 ], function( jQuery, slice ) {
9 Deferred: function( func ) {
12 // action, add listener, listener list, final state
13 [ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
14 [ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
15 [ "notify", "progress", jQuery.Callbacks( "memory" ) ]
23 deferred.done( arguments ).fail( arguments );
26 then: function( /* fnDone, fnFail, fnProgress */ ) {
28 return jQuery.Deferred( function( newDefer ) {
29 jQuery.each( tuples, function( i, tuple ) {
30 var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
32 // deferred[ done | fail | progress ] for forwarding actions to newDefer
33 deferred[ tuple[ 1 ] ]( function() {
34 var returned = fn && fn.apply( this, arguments );
35 if ( returned && jQuery.isFunction( returned.promise ) ) {
37 .progress( newDefer.notify )
38 .done( newDefer.resolve )
39 .fail( newDefer.reject );
41 newDefer[ tuple[ 0 ] + "With" ](
42 this === promise ? newDefer.promise() : this,
43 fn ? [ returned ] : arguments
52 // Get a promise for this deferred
53 // If obj is provided, the promise aspect is added to the object
54 promise: function( obj ) {
55 return obj != null ? jQuery.extend( obj, promise ) : promise;
60 // Keep pipe for back-compat
61 promise.pipe = promise.then;
63 // Add list-specific methods
64 jQuery.each( tuples, function( i, tuple ) {
65 var list = tuple[ 2 ],
66 stateString = tuple[ 3 ];
68 // promise[ done | fail | progress ] = list.add
69 promise[ tuple[ 1 ] ] = list.add;
73 list.add( function() {
75 // state = [ resolved | rejected ]
78 // [ reject_list | resolve_list ].disable; progress_list.lock
79 }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
82 // deferred[ resolve | reject | notify ]
83 deferred[ tuple[ 0 ] ] = function() {
84 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
87 deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
90 // Make the deferred a promise
91 promise.promise( deferred );
93 // Call given func if any
95 func.call( deferred, deferred );
103 when: function( subordinate /* , ..., subordinateN */ ) {
105 resolveValues = slice.call( arguments ),
106 length = resolveValues.length,
108 // the count of uncompleted subordinates
109 remaining = length !== 1 ||
110 ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
112 // the master Deferred.
113 // If resolveValues consist of only a single Deferred, just use that.
114 deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
116 // Update function for both resolve and progress values
117 updateFunc = function( i, contexts, values ) {
118 return function( value ) {
119 contexts[ i ] = this;
120 values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
121 if ( values === progressValues ) {
122 deferred.notifyWith( contexts, values );
123 } else if ( !( --remaining ) ) {
124 deferred.resolveWith( contexts, values );
129 progressValues, progressContexts, resolveContexts;
131 // Add listeners to Deferred subordinates; treat others as resolved
133 progressValues = new Array( length );
134 progressContexts = new Array( length );
135 resolveContexts = new Array( length );
136 for ( ; i < length; i++ ) {
137 if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
138 resolveValues[ i ].promise()
139 .progress( updateFunc( i, progressContexts, progressValues ) )
140 .done( updateFunc( i, resolveContexts, resolveValues ) )
141 .fail( deferred.reject );
148 // If we're not waiting on anything, resolve the master
150 deferred.resolveWith( resolveContexts, resolveValues );
153 return deferred.promise();