corrade-nucleus-nucleons – Blame information for rev 20
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
20 | office | 1 | define([ |
2 | "./core", |
||
3 | "./var/rnotwhite" |
||
4 | ], function( jQuery, rnotwhite ) { |
||
5 | |||
6 | // String to Object options format cache |
||
7 | var optionsCache = {}; |
||
8 | |||
9 | // Convert String-formatted options into Object-formatted ones and store in cache |
||
10 | function createOptions( options ) { |
||
11 | var object = optionsCache[ options ] = {}; |
||
12 | jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) { |
||
13 | object[ flag ] = true; |
||
14 | }); |
||
15 | return object; |
||
16 | } |
||
17 | |||
18 | /* |
||
19 | * Create a callback list using the following parameters: |
||
20 | * |
||
21 | * options: an optional list of space-separated options that will change how |
||
22 | * the callback list behaves or a more traditional option object |
||
23 | * |
||
24 | * By default a callback list will act like an event callback list and can be |
||
25 | * "fired" multiple times. |
||
26 | * |
||
27 | * Possible options: |
||
28 | * |
||
29 | * once: will ensure the callback list can only be fired once (like a Deferred) |
||
30 | * |
||
31 | * memory: will keep track of previous values and will call any callback added |
||
32 | * after the list has been fired right away with the latest "memorized" |
||
33 | * values (like a Deferred) |
||
34 | * |
||
35 | * unique: will ensure a callback can only be added once (no duplicate in the list) |
||
36 | * |
||
37 | * stopOnFalse: interrupt callings when a callback returns false |
||
38 | * |
||
39 | */ |
||
40 | jQuery.Callbacks = function( options ) { |
||
41 | |||
42 | // Convert options from String-formatted to Object-formatted if needed |
||
43 | // (we check in cache first) |
||
44 | options = typeof options === "string" ? |
||
45 | ( optionsCache[ options ] || createOptions( options ) ) : |
||
46 | jQuery.extend( {}, options ); |
||
47 | |||
48 | var // Last fire value (for non-forgettable lists) |
||
49 | memory, |
||
50 | // Flag to know if list was already fired |
||
51 | fired, |
||
52 | // Flag to know if list is currently firing |
||
53 | firing, |
||
54 | // First callback to fire (used internally by add and fireWith) |
||
55 | firingStart, |
||
56 | // End of the loop when firing |
||
57 | firingLength, |
||
58 | // Index of currently firing callback (modified by remove if needed) |
||
59 | firingIndex, |
||
60 | // Actual callback list |
||
61 | list = [], |
||
62 | // Stack of fire calls for repeatable lists |
||
63 | stack = !options.once && [], |
||
64 | // Fire callbacks |
||
65 | fire = function( data ) { |
||
66 | memory = options.memory && data; |
||
67 | fired = true; |
||
68 | firingIndex = firingStart || 0; |
||
69 | firingStart = 0; |
||
70 | firingLength = list.length; |
||
71 | firing = true; |
||
72 | for ( ; list && firingIndex < firingLength; firingIndex++ ) { |
||
73 | if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { |
||
74 | memory = false; // To prevent further calls using add |
||
75 | break; |
||
76 | } |
||
77 | } |
||
78 | firing = false; |
||
79 | if ( list ) { |
||
80 | if ( stack ) { |
||
81 | if ( stack.length ) { |
||
82 | fire( stack.shift() ); |
||
83 | } |
||
84 | } else if ( memory ) { |
||
85 | list = []; |
||
86 | } else { |
||
87 | self.disable(); |
||
88 | } |
||
89 | } |
||
90 | }, |
||
91 | // Actual Callbacks object |
||
92 | self = { |
||
93 | // Add a callback or a collection of callbacks to the list |
||
94 | add: function() { |
||
95 | if ( list ) { |
||
96 | // First, we save the current length |
||
97 | var start = list.length; |
||
98 | (function add( args ) { |
||
99 | jQuery.each( args, function( _, arg ) { |
||
100 | var type = jQuery.type( arg ); |
||
101 | if ( type === "function" ) { |
||
102 | if ( !options.unique || !self.has( arg ) ) { |
||
103 | list.push( arg ); |
||
104 | } |
||
105 | } else if ( arg && arg.length && type !== "string" ) { |
||
106 | // Inspect recursively |
||
107 | add( arg ); |
||
108 | } |
||
109 | }); |
||
110 | })( arguments ); |
||
111 | // Do we need to add the callbacks to the |
||
112 | // current firing batch? |
||
113 | if ( firing ) { |
||
114 | firingLength = list.length; |
||
115 | // With memory, if we're not firing then |
||
116 | // we should call right away |
||
117 | } else if ( memory ) { |
||
118 | firingStart = start; |
||
119 | fire( memory ); |
||
120 | } |
||
121 | } |
||
122 | return this; |
||
123 | }, |
||
124 | // Remove a callback from the list |
||
125 | remove: function() { |
||
126 | if ( list ) { |
||
127 | jQuery.each( arguments, function( _, arg ) { |
||
128 | var index; |
||
129 | while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { |
||
130 | list.splice( index, 1 ); |
||
131 | // Handle firing indexes |
||
132 | if ( firing ) { |
||
133 | if ( index <= firingLength ) { |
||
134 | firingLength--; |
||
135 | } |
||
136 | if ( index <= firingIndex ) { |
||
137 | firingIndex--; |
||
138 | } |
||
139 | } |
||
140 | } |
||
141 | }); |
||
142 | } |
||
143 | return this; |
||
144 | }, |
||
145 | // Check if a given callback is in the list. |
||
146 | // If no argument is given, return whether or not list has callbacks attached. |
||
147 | has: function( fn ) { |
||
148 | return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length ); |
||
149 | }, |
||
150 | // Remove all callbacks from the list |
||
151 | empty: function() { |
||
152 | list = []; |
||
153 | firingLength = 0; |
||
154 | return this; |
||
155 | }, |
||
156 | // Have the list do nothing anymore |
||
157 | disable: function() { |
||
158 | list = stack = memory = undefined; |
||
159 | return this; |
||
160 | }, |
||
161 | // Is it disabled? |
||
162 | disabled: function() { |
||
163 | return !list; |
||
164 | }, |
||
165 | // Lock the list in its current state |
||
166 | lock: function() { |
||
167 | stack = undefined; |
||
168 | if ( !memory ) { |
||
169 | self.disable(); |
||
170 | } |
||
171 | return this; |
||
172 | }, |
||
173 | // Is it locked? |
||
174 | locked: function() { |
||
175 | return !stack; |
||
176 | }, |
||
177 | // Call all callbacks with the given context and arguments |
||
178 | fireWith: function( context, args ) { |
||
179 | if ( list && ( !fired || stack ) ) { |
||
180 | args = args || []; |
||
181 | args = [ context, args.slice ? args.slice() : args ]; |
||
182 | if ( firing ) { |
||
183 | stack.push( args ); |
||
184 | } else { |
||
185 | fire( args ); |
||
186 | } |
||
187 | } |
||
188 | return this; |
||
189 | }, |
||
190 | // Call all the callbacks with the given arguments |
||
191 | fire: function() { |
||
192 | self.fireWith( this, arguments ); |
||
193 | return this; |
||
194 | }, |
||
195 | // To know if the callbacks have already been called at least once |
||
196 | fired: function() { |
||
197 | return !!fired; |
||
198 | } |
||
199 | }; |
||
200 | |||
201 | return self; |
||
202 | }; |
||
203 | |||
204 | return jQuery; |
||
205 | }); |