Projet

Général

Profil

Paste
Télécharger (3 ko) Statistiques
| Branche: | Révision:

root / drupal7 / sites / all / libraries / flexslider-2.5.0 / bower_components / jquery / src / queue.js @ 0aee3c58

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, or returns the current one
63
        _queueHooks: function( elem, type ) {
64
                var key = type + "queueHooks";
65
                return jQuery._data( elem, key ) || jQuery._data( elem, key, {
66
                        empty: jQuery.Callbacks("once memory").add(function() {
67
                                jQuery._removeData( elem, type + "queue" );
68
                                jQuery._removeData( elem, key );
69
                        })
70
                });
71
        }
72
});
73

    
74
jQuery.fn.extend({
75
        queue: function( type, data ) {
76
                var setter = 2;
77

    
78
                if ( typeof type !== "string" ) {
79
                        data = type;
80
                        type = "fx";
81
                        setter--;
82
                }
83

    
84
                if ( arguments.length < setter ) {
85
                        return jQuery.queue( this[0], type );
86
                }
87

    
88
                return data === undefined ?
89
                        this :
90
                        this.each(function() {
91
                                var queue = jQuery.queue( this, type, data );
92

    
93
                                // ensure a hooks for this queue
94
                                jQuery._queueHooks( this, type );
95

    
96
                                if ( type === "fx" && queue[0] !== "inprogress" ) {
97
                                        jQuery.dequeue( this, type );
98
                                }
99
                        });
100
        },
101
        dequeue: function( type ) {
102
                return this.each(function() {
103
                        jQuery.dequeue( this, type );
104
                });
105
        },
106
        clearQueue: function( type ) {
107
                return this.queue( type || "fx", [] );
108
        },
109
        // Get a promise resolved when queues of a certain type
110
        // are emptied (fx is the type by default)
111
        promise: function( type, obj ) {
112
                var tmp,
113
                        count = 1,
114
                        defer = jQuery.Deferred(),
115
                        elements = this,
116
                        i = this.length,
117
                        resolve = function() {
118
                                if ( !( --count ) ) {
119
                                        defer.resolveWith( elements, [ elements ] );
120
                                }
121
                        };
122

    
123
                if ( typeof type !== "string" ) {
124
                        obj = type;
125
                        type = undefined;
126
                }
127
                type = type || "fx";
128

    
129
                while ( i-- ) {
130
                        tmp = jQuery._data( elements[ i ], type + "queueHooks" );
131
                        if ( tmp && tmp.empty ) {
132
                                count++;
133
                                tmp.empty.add( resolve );
134
                        }
135
                }
136
                resolve();
137
                return defer.promise( obj );
138
        }
139
});
140

    
141
return jQuery;
142
});