Permalink
Showing
with
787 additions
and 273 deletions.
- +1 −0 .gitignore
- +2 −0 Makefile
- +4 −4 src/ajax.js
- +257 −0 src/callbacks.js
- +3 −3 src/core.js
- +86 −146 src/deferred.js
- +3 −3 src/queue.js
- +45 −0 src/topic.js
- +2 −0 test/data/offset/absolute.html
- +2 −0 test/data/offset/body.html
- +2 −0 test/data/offset/fixed.html
- +2 −0 test/data/offset/relative.html
- +2 −0 test/data/offset/scroll.html
- +2 −0 test/data/offset/static.html
- +2 −0 test/data/offset/table.html
- +2 −0 test/data/support/bodyBackground.html
- +2 −0 test/data/support/boxModelIE.html
- +2 −0 test/data/support/hiddenIFrameFF.html
- +4 −0 test/index.html
- +194 −0 test/unit/callbacks.js
- +100 −117 test/unit/deferred.js
- +68 −0 test/unit/topic.js
| @@ -0,0 +1,257 @@ | ||
| (function( jQuery ) { | ||
|
|
||
| // String to Object flags format cache | ||
| var flagsCache = {}; | ||
|
|
||
| // Convert String-formatted flags into Object-formatted ones and store in cache | ||
| function createFlags( flags ) { | ||
| var object = flagsCache[ flags ] = {}, | ||
| i, length; | ||
| flags = flags.split( /\s+/ ); | ||
| for ( i = 0, length = flags.length; i < length; i++ ) { | ||
| object[ flags[i] ] = true; | ||
| } | ||
| return object; | ||
| } | ||
|
|
||
| /* | ||
| * Create a callback list using the following parameters: | ||
| * | ||
| * flags: an optional list of space-separated flags that will change how | ||
| * the callback list behaves | ||
| * | ||
| * filter: an optional function that will be applied to each added callbacks, | ||
| * what filter returns will then be added provided it is not falsy. | ||
| * | ||
| * By default a callback list will act like an event callback list and can be | ||
| * "fired" multiple times. | ||
| * | ||
| * Possible flags: | ||
| * | ||
| * 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) | ||
| * | ||
| * queue: only first callback in the list is called each time the list is fired | ||
| * (cannot be used in conjunction with memory) | ||
| * | ||
| * unique: will ensure a callback can only be added once (no duplicate in the list) | ||
| * | ||
| * relocate: like "unique" but will relocate the callback at the end of the list | ||
| * | ||
| * stopOnFalse: interrupt callings when a callback returns false | ||
| * | ||
| * addAfterFire: if callbacks are added while firing, then they are not executed until after | ||
| * the next call to fire/fireWith | ||
| * | ||
| */ | ||
| jQuery.Callbacks = function( flags, filter ) { | ||
|
|
||
| // flags are optional | ||
| if ( typeof flags !== "string" ) { | ||
| filter = flags; | ||
| flags = undefined; | ||
| } | ||
|
|
||
| // Convert flags from String-formatted to Object-formatted | ||
| // (we check in cache first) | ||
| flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; | ||
|
|
||
| var // Actual callback list | ||
| list = [], | ||
| // Stack of fire calls for repeatable lists | ||
| stack = [], | ||
| // Last fire value (for non-forgettable lists) | ||
| memory, | ||
| // 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, | ||
| // Index of currently firing callback (modified by remove if needed) | ||
| firingIndex, | ||
| // Add one or several callbacks to the list | ||
| add = function( args ) { | ||
| var i, | ||
| length, | ||
| elem, | ||
| type, | ||
| actual; | ||
| for ( i = 0, length = args.length; i < length; i++ ) { | ||
| elem = args[ i ]; | ||
| type = jQuery.type( elem ); | ||
| if ( type === "array" ) { | ||
| // Inspect recursively | ||
| add( elem ); | ||
| } else if ( type === "function" ) { | ||
| // If we have to relocate, we remove the callback | ||
| // if it already exists | ||
| if ( flags.relocate ) { | ||
| self.remove( elem ); | ||
| // Skip if we're in unique mode and callback is already in | ||
| } else if ( flags.unique && self.has( elem ) ) { | ||
| continue; | ||
| } | ||
| // Get the filtered function if needs be | ||
| actual = filter ? filter( elem ) : elem; | ||
| if ( actual ) { | ||
| list.push( [ elem, actual ] ); | ||
| } | ||
| } | ||
| } | ||
| }, | ||
| // Fire callbacks | ||
| fire = function( context, args ) { | ||
| args = args || []; | ||
| memory = !flags.memory || [ context, args ]; | ||
| firing = true; | ||
| firingIndex = firingStart || 0; | ||
| firingStart = 0; | ||
| firingLength = list.length; | ||
| for ( ; list && firingIndex < firingLength; firingIndex++ ) { | ||
| if ( list[ firingIndex ][ 1 ].apply( context, args ) === false && flags.stopOnFalse ) { | ||
| memory = true; // Mark as halted | ||
| break; | ||
| } else if ( flags.queue ) { | ||
| list.splice( firingIndex, 1 ); | ||
| break; | ||
| } | ||
| } | ||
| firing = false; | ||
| if ( list ) { | ||
| if ( !flags.once ) { | ||
| if ( stack && stack.length ) { | ||
| memory = stack.shift(); | ||
| self.fireWith( memory[ 0 ], memory[ 1 ] ); | ||
| } | ||
| } else if ( memory === true ) { | ||
| self.disable(); | ||
| } else { | ||
| list = []; | ||
| } | ||
| } | ||
| }, | ||
| // Actual Callbacks object | ||
| self = { | ||
| // Add a callback or a collection of callbacks to the list | ||
| add: function() { | ||
| if ( list ) { | ||
| var length = list.length; | ||
| add( arguments ); | ||
| // Do we need to add the callbacks to the | ||
| // current firing batch? | ||
| if ( firing ) { | ||
| if ( !flags.addAfterFire ) { | ||
| firingLength = list.length; | ||
| } | ||
| // With memory, if we're not firing then | ||
| // we should call right away, unless previous | ||
| // firing was halted (stopOnFalse) | ||
| } else if ( memory && memory !== true ) { | ||
| firingStart = length; | ||
| fire( memory[ 0 ], memory[ 1 ] ); | ||
| } | ||
| } | ||
| return this; | ||
| }, | ||
| // Remove a callback from the list | ||
| remove: function() { | ||
| if ( list ) { | ||
| var args = arguments, | ||
| argIndex = 0, | ||
| argLength = args.length; | ||
| for ( ; argIndex < argLength ; argIndex++ ) { | ||
| for ( var i = 0; i < list.length; i++ ) { | ||
| if ( args[ argIndex ] === list[ i ][ 0 ] ) { | ||
| // Handle firingIndex and firingLength | ||
| if ( firing ) { | ||
| if ( i <= firingLength ) { | ||
| firingLength--; | ||
| if ( i <= firingIndex ) { | ||
| firingIndex--; | ||
| } | ||
| } | ||
| } | ||
| // Remove the element | ||
| list.splice( i--, 1 ); | ||
| // If we have some unicity property then | ||
| // we only need to do this once | ||
| if ( flags.unique || flags.relocate ) { | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } | ||
| return this; | ||
| }, | ||
| // Control if a given callback is in the list | ||
| has: function( fn ) { | ||
| if ( list ) { | ||
| var i = 0, | ||
| length = list.length; | ||
| for ( ; i < length; i++ ) { | ||
| if ( fn === list[ i ][ 0 ] ) { | ||
| return true; | ||
| } | ||
| } | ||
| } | ||
| return false; | ||
| }, | ||
| // Remove all callbacks from the list | ||
| empty: function() { | ||
| list = []; | ||
| return this; | ||
| }, | ||
| // Have the list do nothing anymore | ||
| disable: function() { | ||
| list = stack = memory = undefined; | ||
| return this; | ||
| }, | ||
| // Is it disabled? | ||
| disabled: function() { | ||
| return !list; | ||
| }, | ||
| // Lock the list in its current state | ||
| lock: function() { | ||
| stack = undefined; | ||
| if ( !memory || memory === true ) { | ||
| self.disable(); | ||
| } | ||
| return this; | ||
| }, | ||
| // Is it locked? | ||
| locked: function() { | ||
| return !stack; | ||
| }, | ||
| // Call all callbacks with the given context and arguments | ||
| fireWith: function( context, args ) { | ||
| if ( stack ) { | ||
| if ( firing ) { | ||
| if ( !flags.once ) { | ||
| stack.push( [ context, args ] ); | ||
| } | ||
| } else if ( !( flags.once && memory ) ) { | ||
| fire( context, 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 !!memory; | ||
| } | ||
| }; | ||
|
|
||
| return self; | ||
| }; | ||
|
|
||
| })( jQuery ); |
Oops, something went wrong.