← Back to branch summary

~noskcaj/ubuntu/utopic/jquery/merge

« back to all changes in this revision

Viewing changes to src/queue.js

  • Committer: Bazaar Package Importer
  • Author(s): Marcelo Jorge Vieira (metal)
  • Date: 2011-05-29 20:21:27 UTC
  • mfrom: (0.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20110529202127-yo710urpsj87oqnh
Tags: 1.6.1-1
http://bugs.debian.org/628052
New upstream release (Closes: #628052)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/queue.js
1
1
(function( jQuery ) {
2
2
 
 
3
function handleQueueMarkDefer( elem, type, src ) {
 
4
        var deferDataKey = type + "defer",
 
5
                queueDataKey = type + "queue",
 
6
                markDataKey = type + "mark",
 
7
                defer = jQuery.data( elem, deferDataKey, undefined, true );
 
8
        if ( defer &&
 
9
                ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
 
10
                ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
 
11
                // Give room for hard-coded callbacks to fire first
 
12
                // and eventually mark/queue something else on the element
 
13
                setTimeout( function() {
 
14
                        if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
 
15
                                !jQuery.data( elem, markDataKey, undefined, true ) ) {
 
16
                                jQuery.removeData( elem, deferDataKey, true );
 
17
                                defer.resolve();
 
18
                        }
 
19
                }, 0 );
 
20
        }
 
21
}
 
22
 
3
23
jQuery.extend({
 
24
 
 
25
        _mark: function( elem, type ) {
 
26
                if ( elem ) {
 
27
                        type = (type || "fx") + "mark";
 
28
                        jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
 
29
                }
 
30
        },
 
31
 
 
32
        _unmark: function( force, elem, type ) {
 
33
                if ( force !== true ) {
 
34
                        type = elem;
 
35
                        elem = force;
 
36
                        force = false;
 
37
                }
 
38
                if ( elem ) {
 
39
                        type = type || "fx";
 
40
                        var key = type + "mark",
 
41
                                count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
 
42
                        if ( count ) {
 
43
                                jQuery.data( elem, key, count, true );
 
44
                        } else {
 
45
                                jQuery.removeData( elem, key, true );
 
46
                                handleQueueMarkDefer( elem, type, "mark" );
 
47
                        }
 
48
                }
 
49
        },
 
50
 
4
51
        queue: function( elem, type, data ) {
5
 
                if ( !elem ) {
6
 
                        return;
7
 
                }
8
 
 
9
 
                type = (type || "fx") + "queue";
10
 
                var q = jQuery._data( elem, type );
11
 
 
12
 
                // Speed up dequeue by getting out quickly if this is just a lookup
13
 
                if ( !data ) {
 
52
                if ( elem ) {
 
53
                        type = (type || "fx") + "queue";
 
54
                        var q = jQuery.data( elem, type, undefined, true );
 
55
                        // Speed up dequeue by getting out quickly if this is just a lookup
 
56
                        if ( data ) {
 
57
                                if ( !q || jQuery.isArray(data) ) {
 
58
                                        q = jQuery.data( elem, type, jQuery.makeArray(data), true );
 
59
                                } else {
 
60
                                        q.push( data );
 
61
                                }
 
62
                        }
14
63
                        return q || [];
15
64
                }
16
 
 
17
 
                if ( !q || jQuery.isArray(data) ) {
18
 
                        q = jQuery._data( elem, type, jQuery.makeArray(data) );
19
 
 
20
 
                } else {
21
 
                        q.push( data );
22
 
                }
23
 
 
24
 
                return q;
25
65
        },
26
66
 
27
67
        dequeue: function( elem, type ) {
28
68
                type = type || "fx";
29
69
 
30
70
                var queue = jQuery.queue( elem, type ),
31
 
                        fn = queue.shift();
 
71
                        fn = queue.shift(),
 
72
                        defer;
32
73
 
33
74
                // If the fx queue is dequeued, always remove the progress sentinel
34
75
                if ( fn === "inprogress" ) {
49
90
 
50
91
                if ( !queue.length ) {
51
92
                        jQuery.removeData( elem, type + "queue", true );
 
93
                        handleQueueMarkDefer( elem, type, "queue" );
52
94
                }
53
95
        }
54
96
});
63
105
                if ( data === undefined ) {
64
106
                        return jQuery.queue( this[0], type );
65
107
                }
66
 
                return this.each(function( i ) {
 
108
                return this.each(function() {
67
109
                        var queue = jQuery.queue( this, type, data );
68
110
 
69
111
                        if ( type === "fx" && queue[0] !== "inprogress" ) {
76
118
                        jQuery.dequeue( this, type );
77
119
                });
78
120
        },
79
 
 
80
121
        // Based off of the plugin by Clint Helfers, with permission.
81
122
        // http://blindsignals.com/index.php/2009/07/jquery-delay/
82
123
        delay: function( time, type ) {
90
131
                        }, time );
91
132
                });
92
133
        },
93
 
 
94
134
        clearQueue: function( type ) {
95
135
                return this.queue( type || "fx", [] );
 
136
        },
 
137
        // Get a promise resolved when queues of a certain type
 
138
        // are emptied (fx is the type by default)
 
139
        promise: function( type, object ) {
 
140
                if ( typeof type !== "string" ) {
 
141
                        object = type;
 
142
                        type = undefined;
 
143
                }
 
144
                type = type || "fx";
 
145
                var defer = jQuery.Deferred(),
 
146
                        elements = this,
 
147
                        i = elements.length,
 
148
                        count = 1,
 
149
                        deferDataKey = type + "defer",
 
150
                        queueDataKey = type + "queue",
 
151
                        markDataKey = type + "mark",
 
152
                        tmp;
 
153
                function resolve() {
 
154
                        if ( !( --count ) ) {
 
155
                                defer.resolveWith( elements, [ elements ] );
 
156
                        }
 
157
                }
 
158
                while( i-- ) {
 
159
                        if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
 
160
                                        ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
 
161
                                                jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
 
162
                                        jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
 
163
                                count++;
 
164
                                tmp.done( resolve );
 
165
                        }
 
166
                }
 
167
                resolve();
 
168
                return defer.promise();
96
169
        }
97
170
});
98
171