corrade-nucleus-nucleons – Blame information for rev 20

Subversion Repositories:
Rev:
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 });