scratch – Diff between revs 58 and 125

Subversion Repositories:

?pathlinks?

Rev 58 – Details – Blame – Last modification – View Log

Only display areas with differences – Ignore whitespace

-define( [
+define([
 	"./core",
-	"./var/rnothtmlwhite"
+	"./var/rnotwhite"
-], function( jQuery, rnothtmlwhite ) {
+], function( jQuery, rnotwhite ) {
+// String to Object options format cache
-"use strict";
+var optionsCache = {};
-// Convert String-formatted options into Object-formatted ones
+// Convert String-formatted options into Object-formatted ones and store in cache
 function createOptions( options ) {
-	var object = {};
+	var object = optionsCache[ options ] = {};
-	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
+	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
 		object[ flag ] = true;
-	} );
+	});
 	return object;
+}
 /*
  * Create a callback list using the following parameters:
+ *
  *	options: an optional list of space-separated options that will change how
  *			the callback list behaves or a more traditional option object
+ *
  * By default a callback list will act like an event callback list and can be
  * "fired" multiple times.
+ *
  * Possible options:
+ *
  *	once:			will ensure the callback list can only be fired once (like a Deferred)
+ *
  *	memory:			will keep track of previous values and will call any callback added
  *					after the list has been fired right away with the latest "memorized"
  *					values (like a Deferred)
+ *
  *	unique:			will ensure a callback can only be added once (no duplicate in the list)
+ *
  *	stopOnFalse:	interrupt callings when a callback returns false
+ *
  */
 jQuery.Callbacks = function( options ) {
 	// Convert options from String-formatted to Object-formatted if needed
 	// (we check in cache first)
 	options = typeof options === "string" ?
-		createOptions( options ) :
+		( optionsCache[ options ] || createOptions( options ) ) :
 		jQuery.extend( {}, options );
-	var // Flag to know if list is currently firing
-		firing,
-		// Last fire value for non-forgettable lists
+	var // Last fire value (for non-forgettable lists)
-		memory,
 		memory,
 		// Flag to know if list was already fired
+		fired,
-		fired,
+		// Flag to know if list is currently firing
+		firing,
+		// First callback to fire (used internally by add and fireWith)
+		firingStart,
+		// End of the loop when firing
+		firingLength,
-		// Flag to prevent firing
+		// Index of currently firing callback (modified by remove if needed)
-		locked,
 		firingIndex,
 		// Actual callback list
-		list = [],
+		list = [],
-		// Queue of execution data for repeatable lists
-		queue = [],
-		// Index of currently firing callback (modified by add/remove as needed)
+		// Stack of fire calls for repeatable lists
-		firingIndex = -1,
 		stack = !options.once && [],
 		// Fire callbacks
-		fire = function() {
+		fire = function( data ) {
-			// Enforce single-firing
+			memory = options.memory && data;
-			locked = options.once;
-			// Execute callbacks for all pending executions,
+			fired = true;
-			// respecting firingIndex overrides and runtime changes
+			firingIndex = firingStart || 0;
-			fired = firing = true;
+			firingStart = 0;
-			for ( ; queue.length; firingIndex = -1 ) {
+			firingLength = list.length;
-				memory = queue.shift();
+			firing = true;
-				while ( ++firingIndex < list.length ) {
-					// Run callback and check for early termination
+			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
-					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
-						options.stopOnFalse ) {
+				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
-						// Jump to end and forget the data so .add doesn't re-fire
-						firingIndex = list.length;
-						memory = false;
+					memory = false; // To prevent further calls using add
 					break;
+				}
-			}
-			// Forget the data if we're done with it
-			if ( !options.memory ) {
-				memory = false;
-			}
+			}
-			firing = false;
+			firing = false;
-			// Clean up if we're done firing for good
+			if ( list ) {
-			if ( locked ) {
+				if ( stack ) {
+					if ( stack.length ) {
+						fire( stack.shift() );
-				// Keep an empty list if we have data for future add calls
+					}
-				if ( memory ) {
+				} else if ( memory ) {
-					list = [];
-				// Otherwise, this object is spent
+					list = [];
 				} else {
-					list = "";
+					self.disable();
+				}
+			}
 		},
 		// Actual Callbacks object
 		self = {
 			// Add a callback or a collection of callbacks to the list
 			add: function() {
 				if ( list ) {
-					// If we have memory from a past run, we should fire after adding
-					if ( memory && !firing ) {
+					// First, we save the current length
-						firingIndex = list.length - 1;
+					var start = list.length;
-						queue.push( memory );
-					}
-					( function add( args ) {
+					(function add( args ) {
 						jQuery.each( args, function( _, arg ) {
+							var type = jQuery.type( arg );
-							if ( jQuery.isFunction( arg ) ) {
+							if ( type === "function" ) {
 								if ( !options.unique || !self.has( arg ) ) {
 									list.push( arg );
+								}
-							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
+							} else if ( arg && arg.length && type !== "string" ) {
 								// Inspect recursively
 								add( arg );
+							}
-						} );
+						});
-					} )( arguments );
+					})( arguments );
+					// Do we need to add the callbacks to the
+					// current firing batch?
-					if ( memory && !firing ) {
+					if ( firing ) {
+						firingLength = list.length;
+					// With memory, if we're not firing then
+					// we should call right away
+					} else if ( memory ) {
+						firingStart = start;
-						fire();
+						fire( memory );
+					}
+				}
 				return this;
 			},
 			// Remove a callback from the list
 			remove: function() {
+				if ( list ) {
-				jQuery.each( arguments, function( _, arg ) {
+					jQuery.each( arguments, function( _, arg ) {
-					var index;
+						var index;
-					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+						while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
-						list.splice( index, 1 );
+							list.splice( index, 1 );
-						// Handle firing indexes
+							// Handle firing indexes
+							if ( firing ) {
+								if ( index <= firingLength ) {
+									firingLength--;
+								}
-						if ( index <= firingIndex ) {
+								if ( index <= firingIndex ) {
-							firingIndex--;
+									firingIndex--;
+								}
+							}
+						}
-					}
+					});
-				} );
+				}
 				return this;
 			},
 			// Check if a given callback is in the list.
 			// If no argument is given, return whether or not list has callbacks attached.
 			has: function( fn ) {
-				return fn ?
-					jQuery.inArray( fn, list ) > -1 :
+				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
-					list.length > 0;
 			},
 			// Remove all callbacks from the list
 			empty: function() {
-				if ( list ) {
+				list = [];
-					list = [];
+				firingLength = 0;
-				}
 				return this;
 			},
-			// Disable .fire and .add
-			// Abort any current/pending executions
+			// Have the list do nothing anymore
-			// Clear all callbacks and values
 			disable: function() {
-				locked = queue = [];
-				list = memory = "";
+				list = stack = memory = undefined;
 				return this;
 			},
+			// Is it disabled?
 			disabled: function() {
 				return !list;
 			},
-			// Disable .fire
-			// Also disable .add unless we have memory (since it would have no effect)
-			// Abort any pending executions
+			// Lock the list in its current state
 			lock: function() {
-				locked = queue = [];
+				stack = undefined;
-				if ( !memory && !firing ) {
+				if ( !memory ) {
-					list = memory = "";
+					self.disable();
+				}
 				return this;
 			},
+			// Is it locked?
 			locked: function() {
-				return !!locked;
+				return !stack;
 			},
 			// Call all callbacks with the given context and arguments
 			fireWith: function( context, args ) {
-				if ( !locked ) {
+				if ( list && ( !fired || stack ) ) {
 					args = args || [];
 					args = [ context, args.slice ? args.slice() : args ];
+					if ( firing ) {
-					queue.push( args );
+						stack.push( args );
-					if ( !firing ) {
+					} else {
-						fire();
+						fire( args );
+					}
+				}
 				return this;
 			},
 			// Call all the callbacks with the given arguments
 			fire: function() {
 				self.fireWith( this, arguments );
 				return this;
 			},
 			// To know if the callbacks have already been called at least once
 			fired: function() {
 				return !!fired;
+			}
 		};
 	return self;
 };
 return jQuery;
-} );
+});