Permalink
Show file tree
Hide file tree
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Showing
22 changed files
with
787 additions
and
273 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| @@ -1,5 +1,6 @@ | ||
| src/selector.js | ||
| dist | ||
| .project | ||
| .settings | ||
| *~ | ||
| *.diff | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| @@ -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 ); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.