☰

Timing_JQuery_Util

try to take over the world!

This script should not be not be installed directly. It is a library for other scripts to include with the meta directive // @require https://update.greatest.deepsurf.us/scripts/404470/812557/Timing_JQuery_Util.js 

  1. /**
  2.  * code from http: //creativecouple.github.io/jquery-timing/jquery-timing.js
  3.  * timing.jquery.js
  4.  * 
  5.  * JavaScript functions for waiting / repeating / stopping jQuery actions.
  6.  * 
  7.  * This code is published under the MIT License (MIT).
  8.  * http://www.opensource.org/licenses/mit-license.php
  9.  * 
  10.  * For examples, reference, and other information see
  11.  * http://creativecouple.github.com/jquery-timing/
  12.  * 
  13.  * @author CreativeCouple
  14.  * @author Peter Liske
  15.  * @copyright (c) 2011 by CreativeCouple
  16.  * @see http://creativecouple.github.com/jquery-timing/
  17.  */
  18.  
  19. (function(jQuery, window){
  20. 	/**
  21. 	 * object to store statically invoked threads
  22. 	 */
  23. 	var THREAD_GROUPS = {},
  24. 	
  25. 	/**
  26. 	 * unique timing identifier for different purposes
  27. 	 */
  28. 	tuid = 1,
  29.  
  30. 	/**
  31. 	 * remember original core function $.each()
  32. 	 */
  33. 	originalEach = jQuery.fn.each,
  34.  
  35. 	/**
  36. 	 * remember original core function $.on() (or $.bind())
  37. 	 */
  38. 	originalOn = jQuery.fn.on || jQuery.fn.bind,
  39. 	
  40. 	/**
  41. 	 * remember original core function $.off() (or $.unbind())
  42. 	 */
  43. 	originalOff = jQuery.fn.off || jQuery.fn.unbind,
  44. 	
  45. 	/**
  46. 	 * .until() and .all() have special meanings
  47. 	 */
  48. 	loopEndMethods = {};
  49. 	
  50. 	function sameOrNextJQuery(before, after) {
  51. 		after = jQuery(after);
  52. 		after.prevObject = before;
  53. 		var i = before.length;
  54. 		if (i !== after.length) {
  55. 			return after;
  56. 		}
  57. 		while (i--) {
  58. 			if (before[i] !== after[i]) {
  59. 				return after;
  60. 			}
  61. 		}
  62. 		return before;
  63. 	}
  64. 	
  65. 	function loopCounts(loops) {
  66. 		var ret = [], i = loops.length;
  67. 		while (i--) {
  68. 			ret[i] = loops[i]._count;
  69. 		}
  70. 		return ret;
  71. 	}
  72. 	
  73. 	/**
  74. 	 * Initialize a new timed invocation chain.
  75. 	 * 
  76. 	 * @author CreativeCouple
  77. 	 * @author Peter Liske
  78. 	 * 
  79. 	 * @param context initial context
  80. 	 * @param methodStack linked list of methods that has been or will be filled by someone else 
  81. 	 * @param ongoingLoops optional arguments for callback parameters
  82. 	 * @param onStepCallback function to call on each step
  83. 	 * @returns the timed invocation chain method
  84. 	 */
  85. 	function createTimedInvocationChain(context, methodStack, ongoingLoops, onStepCallback) {
  86. 		ongoingLoops = ongoingLoops || [];
  87. 		var executionState = {
  88. 				_context: context,
  89. 				_method: methodStack
  90. 		},
  91. 		preventRecursion = false,
  92. 		method, otherExecutionState, deferred;
  93. 		
  94. 		function hookupToProxy(state, mockup){
  95. 			state._canContinue = false;
  96. 			function fire(){
  97. 				state._next = sameOrNextJQuery(state._context, state._next);
  98. 				state._canContinue = true;
  99. 				timedInvocationChain();
  100. 			}
  101. 			return typeof mockup.promise == "function" ? mockup.promise().then(fire) : mockup.then(fire, true);
  102. 		}
  103. 		
  104. 		/**
  105. 		 * Invoke all the methods currently in the timed invocation chain.
  106. 		 * 
  107. 		 * @author CreativeCouple
  108. 		 * @author Peter Liske
  109. 		 */
  110. 		function timedInvocationChain(deferredReturnValue) {
  111. 			while (!preventRecursion) try {
  112. 				// keep recursive calls away
  113. 				preventRecursion = !preventRecursion;
  114. 				// save current context state
  115. 				if (typeof onStepCallback == "function") {
  116. 					onStepCallback(jQuery.makeArray(executionState._next || executionState._context));
  117. 				}
  118. 				// leave the chain when waiting for a trigger
  119. 				if (executionState._canContinue == false) {
  120. 					break;
  121. 				}
  122. 				// check end of chain
  123. 				if (!executionState._method._name) {
  124. 					if (deferred && (!ongoingLoops.length || ongoingLoops[0]._allowPromise)) {
  125. 						// resolve any waiting promise 
  126. 						if (executionState._context && typeof executionState._context.promise == "function") {
  127. 							executionState._context.promise().then(deferred.resolve);
  128. 						} else {
  129. 							deferred.resolveWith(executionState._context);
  130. 						}
  131. 						deferred = null;
  132. 					}
  133. 					if (!ongoingLoops.length) {
  134. 						/*
  135. 						 * We've reached the end of our TIC
  136. 						 * and there is nothing left to wait for.
  137. 						 * So we can safely return the original jQuery object
  138. 						 * hence enabling instant invocation.
  139. 						 */
  140. 						return executionState._context; 
  141. 					}
  142. 					/*
  143. 					 * Now we have ongoing loops but reached the chain's end.
  144. 					 */
  145. 					otherExecutionState = ongoingLoops[0]._openEndAction && ongoingLoops[0]._openEndAction(timedInvocationChain, executionState, ongoingLoops);
  146. 					if (!otherExecutionState) {
  147. 						// if innermost loop can't help us, just leave the chain
  148. 						break;
  149. 					}
  150. 					executionState = otherExecutionState;
  151. 					continue;
  152. 				}
  153. 				// check if user tries to use a non-existing function call
  154. 				method = executionState._context && executionState._context[executionState._method._name] || loopEndMethods[executionState._method._name];
  155. 				if (!method) {					
  156. 					throw 'no such method "'+executionState._method._name+'" on object ('+executionState._context+')';
  157. 				}
  158. 				// check whether we came here triggered or not
  159. 				if (method.timing && !executionState._canContinue) {
  160. 					// prevent automatic re-trigger in case of loops
  161. 					executionState._canContinue = false;
  162. 					// handle timing method
  163. 					executionState = method.timing(timedInvocationChain, executionState, ongoingLoops, onStepCallback) || executionState;
  164. 				} else {
  165. 					if (!method.timing && !executionState._canContinue) {
  166. 						// prevent automatic re-trigger in case of loops
  167. 						executionState._next = executionState._context[executionState._method._name].apply(executionState._context, executionState._method._arguments);
  168. 						if (ongoingLoops.length && executionState._next && executionState._next instanceof PredictingProxy) {
  169. 							hookupToProxy(executionState, executionState._next);
  170. 							continue;
  171. 						}
  172. 					}
  173. 					// go to next step
  174. 					otherExecutionState = {
  175. 							_context: executionState._next,
  176. 							_method: executionState._method._next
  177. 					};
  178. 					// prevent automatic re-trigger in case of loops
  179. 					executionState._canContinue = false;
  180. 					// invoke callback method with given arguments
  181. 					if (typeof executionState._callback == "function") {
  182. 						executionState._callback.apply(executionState._context, loopCounts(ongoingLoops));
  183. 					}
  184. 					executionState = otherExecutionState;
  185. 				}
  186. 			} catch(e) {
  187. 				/*
  188. 				 * We had a runtime exception.
  189. 				 * In plain JavaScript live the chain would break now.
  190. 				 * So we do, too.
  191. 				 */
  192. 				preventRecursion = !preventRecursion;
  193. 				throw e;
  194. 			} finally {
  195. 				preventRecursion = !preventRecursion;				
  196. 			}
  197. 			return deferredReturnValue;
  198. 		};
  199. 		if (jQuery.Deferred) {
  200. 			// add .promise() method to tic
  201. 			timedInvocationChain.promise = function(type, target){
  202. 				var ret = (deferred = deferred || jQuery.Deferred()).promise(target);
  203. 				timedInvocationChain();
  204. 				return ret;
  205. 			};
  206. 		}
  207. 		return timedInvocationChain;
  208. 	}
  209. 	
  210. 	/**
  211. 	 * Create a placeholder object to collect chained method calls.
  212. 	 * 
  213. 	 * @author CreativeCouple
  214. 	 * @author Peter Liske
  215. 	 *
  216. 	 * @param context initial context
  217. 	 * @param methodStack a linked list that this placeholder will fill with call parameters 
  218. 	 * @return the placeholder object
  219. 	 */
  220. 	function PredictingProxy(context, methodStack, onStepCallback) {
  221. 		this['.methods'] = methodStack;
  222. 		this['.callback'] = onStepCallback;
  223. 		this.length = 0;
  224. 		Array.prototype.push.apply(this, jQuery.makeArray(this._ = context._ = context));
  225. 		
  226. 		for (var key in context) {
  227. 			if (!(key in PredictingProxy.prototype) && typeof context[key] == "function") {
  228. 				this[key] = extendMockupPrototype(key);
  229. 			}
  230. 		}
  231. 	}
  232. 	
  233. 	// enabling jQuery.when(tic);
  234. 	if (jQuery.Deferred) {
  235. 		PredictingProxy.prototype.promise = function(type, target) {
  236. 			if (typeof type == "object") {
  237. 				target = type;
  238. 				type = null;
  239. 			}
  240. 			return (this['.callback'] && typeof this['.callback'].promise == "function") ? this['.callback'].promise(type, target) : jQuery.Deferred().resolveWith(this).promise(target);
  241. 		};
  242. 	}
  243. 	
  244. 	/**
  245. 	 * Create and return a new placeholder function on the prototype of PredictingProxy. 
  246. 	 */
  247. 	function extendMockupPrototype(name){
  248. 		return PredictingProxy.prototype[name] = function(){
  249. 			this['.methods']._name = name;
  250. 			this['.methods']._arguments = arguments;
  251. 			this['.methods'] = this['.methods']._next = {};
  252. 			return this['.callback'] ? this['.callback'](this, name, arguments) : this;
  253. 		};
  254. 	}
  255. 	
  256. 	
  257. 	/**
  258. 	 * Create replacement methods for .bind(), .on(), .one(), .live(), and .delegate()
  259. 	 * that support chaining instead of giving a callback function.
  260. 	 */
  261. 	jQuery.each(['bind','on','one','live','delegate'], function(index, name){
  262. 		if (jQuery.fn[name]) {
  263. 			var original = jQuery.fn[name];
  264. 			jQuery.fn[name] = function(){
  265. 				var i, methodStack, placeholder, timedInvocationChain, deferred, context = this;
  266. 				for(i=0; i<arguments.length; i++) {
  267. 					if (typeof arguments[i] == "function" || (arguments[i] && typeof arguments[i] == "object") || arguments[i] === false) {
  268. 						if (arguments[i] !== jQuery) {
  269. 							// fix for jQuery 1.6 .one() + .unbind()
  270. 							if (typeof arguments[i] == "function" && jQuery.guid) {
  271. 								arguments[i].guid = arguments[i].guid || jQuery.guid++;
  272. 							}
  273. 							return original.apply(context, arguments);
  274. 						}
  275. 						break;
  276. 					}
  277. 				}
  278. 				Array.prototype.splice.call(arguments, i, 1, function(){
  279. 					timedInvocationChain = createTimedInvocationChain(context.$(this), methodStack, [{
  280. 							_count: jQuery.extend(Array.prototype.shift.apply(arguments), arguments),
  281. 							_allowPromise: true
  282. 						}], function(elements){
  283. 						placeholder.length = 0;
  284. 						Array.prototype.push.apply(placeholder, elements);
  285. 					});
  286. 					if (deferred) {
  287. 						timedInvocationChain.promise().then(deferred.resolve);
  288. 						deferred = null;
  289. 					}
  290. 					return timedInvocationChain();
  291. 				});
  292. 				function fire(){
  293. 					return timedInvocationChain ? timedInvocationChain(placeholder) : placeholder;
  294. 				}
  295. 				if (jQuery.Deferred) {					
  296. 					fire.promise = function(type, target){
  297. 						if (typeof type == "object") {
  298. 							target = type;
  299. 							type = null;
  300. 						}
  301. 						return (timedInvocationChain && !type) ? timedInvocationChain.promise(type, target) : (deferred = deferred || jQuery.Deferred()).promise(target);
  302. 					};
  303. 				}
  304. 				return placeholder = new PredictingProxy(original.apply(context, arguments), methodStack = {}, fire);
  305. 			};
  306. 		}
  307. 	});
  308. 	
  309. 	/**
  310. 	 * Create replacement method for .animate() and .load()
  311. 	 * that support chaining if $ is given as callback function.
  312. 	 */
  313. 	jQuery.each(['animate','load'], function(index, name){
  314. 		if (jQuery.fn[name]) {
  315. 			var original = jQuery.fn[name];
  316. 			jQuery.fn[name] = function(){
  317. 				while (arguments.length && arguments[arguments.length-1] == null) {
  318. 					Array.prototype.pop.apply(arguments);
  319. 				}
  320. 				if (this.length && arguments.length > 1 && arguments[arguments.length-1] === jQuery) {
  321. 					var event = '_timing'+tuid++;
  322. 					arguments[arguments.length-1] = function(){
  323. 						jQuery(this).trigger(event);
  324. 					};
  325. 					return this.each().one(event).all(original.apply(this, arguments));
  326. 				}
  327. 				return original.apply(this, arguments);
  328. 			};
  329. 		}
  330. 	});
  331. 		
  332. 	/**
  333. 	 * Define new methods .wait(), .repeat(), .join(), .then()
  334. 	 * which will always start a new TIC if invoked outside of a TIC.  
  335. 	 */
  336. 	jQuery.each(['wait','repeat','join','then'], function(index, name){
  337. 		jQuery.fn[name] = function(){
  338. 			var methodStack = {},
  339. 			placeholder = new PredictingProxy(this, methodStack, createTimedInvocationChain(this, methodStack, [], function(elements){
  340. 					placeholder.length = 0;
  341. 					Array.prototype.push.apply(placeholder, elements);
  342. 				}));
  343. 			return placeholder[name].apply(placeholder, arguments);
  344. 		};
  345. 	});
  346. 	
  347. 	/**
  348. 	 * Define to wait for joining all animation queues.
  349. 	 * 
  350. 	 * @param timedInvocationChain
  351. 	 * @param executionState
  352. 	 */
  353. 	jQuery.fn.join.timing = function(timedInvocationChain, executionState) {
  354. 		var queueName,
  355. 		promising,
  356. 		waitingElements = executionState._context.length;
  357. 		
  358. 		if (typeof executionState._method._arguments[0] == "string") {
  359. 			queueName = executionState._method._arguments[0];
  360. 			if (typeof executionState._method._arguments[1] == "function") {
  361. 				executionState._callback = executionState._method._arguments[1];
  362. 			} else {
  363. 				promising = executionState._method._arguments[1];
  364. 				executionState._callback = executionState._method._arguments[2];
  365. 			}
  366. 		} else {
  367. 			if (typeof executionState._method._arguments[0] == "function") {
  368. 				executionState._callback = executionState._method._arguments[0];
  369. 			} else {
  370. 				promising = executionState._method._arguments[0];
  371. 				executionState._callback = executionState._method._arguments[1];
  372. 			}
  373. 		}
  374. 		
  375. 		executionState._next = executionState._context;
  376. 		executionState._canContinue = !waitingElements;
  377.  
  378. 		// wait for each element to reach the current end of its queue
  379. 		if (promising) {
  380. 			executionState._context.promise(queueName == null ? 'fx' : queueName).then(function(){
  381. 				executionState._canContinue = true;
  382. 				timedInvocationChain();
  383. 			});
  384. 		} else {
  385. 			executionState._context.queue(queueName == null ? 'fx' : queueName, function(next){
  386. 				executionState._canContinue = !--waitingElements;
  387. 				timedInvocationChain();
  388. 				next();
  389. 			});
  390. 		}
  391. 	};
  392.  
  393. 	/**
  394. 	 * Define to simply run callback method for .then()
  395. 	 * 
  396. 	 * @param timedInvocationChain
  397. 	 * @param executionState
  398. 	 */
  399. 	jQuery.fn.then.timing = function(timedInvocationChain, executionState){
  400. 		executionState._callback = executionState._method._arguments[0];
  401. 		executionState._next = executionState._context;
  402. 		executionState._canContinue = true;
  403. 		if (executionState._method._arguments[1]) {
  404. 			Array.prototype.shift.apply(executionState._method._arguments);
  405. 		}
  406. 	};
  407. 	
  408. 	/**
  409. 	 * Define timeout or binding to wait for.
  410. 	 * 
  411. 	 * @param timedInvocationChain
  412. 	 * @param executionState
  413. 	 */
  414. 	jQuery.fn.wait.timing = function(timedInvocationChain, executionState, ongoingLoops) {
  415. 		var trigger, event, timeout, context = executionState._context;
  416. 		
  417. 		trigger = executionState._method._arguments[0];
  418. 		executionState._callback = executionState._method._arguments[1];
  419.  
  420. 		function triggerAction() {
  421. 			originalOff.call(event ? originalOff.call(context, event, triggerAction) : context, 'unwait', unwaitAction);
  422. 			executionState._canContinue = true;
  423. 			executionState._next = sameOrNextJQuery(executionState._context, executionState._next);
  424. 			timedInvocationChain();
  425. 		}
  426. 		
  427. 		function unwaitAction(evt, skipWait){
  428. 			originalOff.call(event ? originalOff.call(jQuery(this), event, triggerAction) : jQuery(this), 'unwait', unwaitAction);
  429. 			context = context.not(this);
  430. 			if (!skipWait) {
  431. 				executionState._next = executionState._next.not(this);
  432. 			}
  433. 			if (!context.length) {
  434. 				executionState._canContinue = executionState._next.length;
  435. 				executionState._next = sameOrNextJQuery(executionState._context, executionState._next);
  436. 				window.clearTimeout(timeout);
  437. 				executionState = { _context: context };
  438. 			}
  439. 			// just update the snapshot info
  440. 			timedInvocationChain();
  441. 		}
  442.  
  443. 		originalOn.call(context, 'unwait', unwaitAction);
  444. 		executionState._next = context;
  445.  
  446. 		if (trigger == null || trigger == jQuery) {
  447. 			trigger = context;
  448. 		}	
  449. 		if (typeof trigger == "function") {
  450. 			trigger = trigger.apply(context, loopCounts(ongoingLoops));
  451. 		}
  452. 		if (typeof trigger == "string") {
  453.  
  454. 			originalOn.call(context, event = trigger, triggerAction);
  455.  
  456. 		} else if (trigger && typeof trigger.promise == "function") {
  457. 			
  458. 			trigger.promise().then(triggerAction);
  459. 			
  460. 		} else if (trigger && typeof trigger.then == "function") {
  461. 			
  462. 			trigger.then(triggerAction, true);
  463. 			
  464. 		} else {
  465.  
  466. 			timeout = window.setTimeout(triggerAction, Math.max(0,trigger));
  467.  
  468. 		}
  469. 	};
  470.  
  471. 	/**
  472. 	 * Define to simply run callback method for .then()
  473. 	 * 
  474. 	 * @param timedInvocationChain
  475. 	 * @param executionState
  476. 	 */
  477. 	jQuery.fn.each = function(callback){
  478. 		if (!callback || callback === jQuery) {
  479. 			var methodStack = {},
  480. 			placeholder = new PredictingProxy(this, methodStack, createTimedInvocationChain(this, methodStack, [], function(elements){
  481. 					placeholder.length = 0;
  482. 					Array.prototype.push.apply(placeholder, elements);
  483. 				}));
  484. 			return placeholder.each(callback);
  485. 		}
  486. 		return originalEach.apply(this, arguments);
  487. 	};
  488. 	
  489. 	/**
  490. 	 * Define interval or binding to repeat.
  491. 	 * 
  492. 	 * @param timedInvocationChain
  493. 	 * @param executionState
  494. 	 */
  495. 	jQuery.fn.each.timing = function(timedInvocationChain, executionState, ongoingLoops, onStepCallback) {
  496. 		if (executionState._method._arguments[0] && executionState._method._arguments[0] !== jQuery) {
  497. 			executionState._canContinue = true;
  498. 			executionState._next = originalEach.apply(executionState._context, executionState._method._arguments);
  499. 			return;
  500. 		}
  501. 		
  502. 		var size = Math.max(executionState._context.length, 1),
  503. 		finished = 0,
  504. 		key, methodToGoOn, openLoopTimeout,
  505. 		innerTICs = [],
  506. 		innerElements = [],
  507. 		proxyPlaceholder = jQuery.extend({}, executionState._context),
  508. 		stepByStep = executionState._method._arguments[0] === jQuery;
  509.  
  510. 		if (stepByStep) {
  511. 			window.setTimeout(function(){
  512. 				openLoopTimeout = true;
  513. 				timedInvocationChain();
  514. 			},0);
  515. 		}
  516. 		
  517. 		function spreadAction(){
  518. 			if (stepByStep) {
  519. 				if (finished < size) {
  520. 					(innerTICs[finished])();
  521. 				}
  522. 			} else {
  523. 				for (var i=0; i<size; i++) {
  524. 					(innerTICs[i])();
  525. 				}
  526. 			}
  527. 			return proxyPlaceholder;
  528. 		}
  529. 		
  530. 		for (key in PredictingProxy.prototype) {
  531. 			proxyPlaceholder[key] = spreadAction;
  532. 		}
  533. 		proxyPlaceholder.length = size;
  534. 		for(key=0; key<size; key++) (function(index){
  535. 			var innerLoops = ongoingLoops.slice(),
  536. 			context = executionState._context.eq(index);
  537. 			innerElements[index] = context.get();
  538. 			innerLoops.unshift({
  539. 				_count: index,
  540. 				_allAction: function(state){
  541. 					finished++;
  542. 					if (finished == size) {
  543. 						methodToGoOn = state._method._next;
  544. 					}
  545. 					timedInvocationChain();
  546. 				},
  547. 				_fixOpenLoop: loopEndMethods.all,
  548. 				_openEndAction: function(tic, state){
  549. 					if (openLoopTimeout) {
  550. 						finished++;
  551. 						if (finished == size) {
  552. 							methodToGoOn = state._method;
  553. 						}
  554. 						timedInvocationChain();
  555. 					}
  556. 				}
  557. 			});
  558. 			innerTICs[index] = createTimedInvocationChain(context, executionState._method._next, innerLoops, function(elements){
  559. 				innerElements[index] = elements;
  560. 				proxyPlaceholder.length = 0;
  561. 				for (var i=0; i<size; i++) {
  562. 					Array.prototype.push.apply(proxyPlaceholder, innerElements[i]);
  563. 				}
  564. 				if (onStepCallback)
  565. 					onStepCallback(jQuery.makeArray(proxyPlaceholder));
  566. 			});
  567. 		})(key);
  568.  
  569. 		executionState._next = proxyPlaceholder;
  570. 		executionState._canContinue = true;
  571. 		executionState._openEndAction = function(tic, state){			
  572. 			if (finished == size) {
  573. 				ongoingLoops.shift();
  574. 				return {
  575. 					_context: sameOrNextJQuery(executionState._context, proxyPlaceholder),
  576. 					_method: methodToGoOn
  577. 				};
  578. 			}
  579. 			var finishedBefore = finished;
  580. 			spreadAction();
  581. 			if (finished != finishedBefore) {
  582. 				return state;
  583. 			}
  584. 		};
  585. 		executionState._count = size;
  586. 		
  587. 		ongoingLoops.unshift(executionState);
  588. 	};
  589.  
  590. 	loopEndMethods.all = function(executionState){
  591. 		jQuery.extend(executionState._method, {
  592. 			_next: jQuery.extend({}, executionState._method),
  593. 			_name: 'all',
  594. 			_arguments: []
  595. 		});
  596. 		executionState._canContinue = null;
  597. 	};
  598. 	loopEndMethods.all.timing = function(timedInvocationChain, executionState, ongoingLoops) {
  599. 		if (!ongoingLoops.length || !ongoingLoops[0]._fixOpenLoop) {
  600. 			throw '.all() method must be used after .each() only';
  601. 		}
  602. 		if (!ongoingLoops[0]._allAction) {
  603. 			ongoingLoops[0]._fixOpenLoop(executionState);
  604. 			return;
  605. 		}
  606. 		
  607. 		ongoingLoops[0]._allAction(executionState);
  608. 	};
  609. 	
  610. 	/**
  611. 	 * Define interval or binding to repeat.
  612. 	 * 
  613. 	 * @param timedInvocationChain
  614. 	 * @param executionState
  615. 	 */
  616. 	jQuery.fn.repeat.timing = function(timedInvocationChain, executionState, ongoingLoops) {
  617. 		var trigger,
  618. 		firstRunNow,
  619. 		openLoopTimeout,
  620. 		event,
  621. 		interval;
  622.  
  623. 		if (typeof executionState._method._arguments[0] == "function") {
  624. 			executionState._callback = executionState._method._arguments[0];
  625. 		} else if (typeof executionState._method._arguments[1] == "function") {
  626. 			trigger = executionState._method._arguments[0];
  627. 			executionState._callback = executionState._method._arguments[1];
  628. 		} else {
  629. 			trigger = executionState._method._arguments[0];
  630. 			firstRunNow = executionState._method._arguments[1];
  631. 			executionState._callback = executionState._method._arguments[2];
  632. 		}
  633. 		
  634. 		function triggerAction() {
  635. 			executionState._next = executionState._next || executionState._context;
  636. 			executionState._canContinue = true;
  637. 			timedInvocationChain();
  638. 		}
  639. 		
  640. 		function unrepeatAction(){
  641. 			originalOff.call(event ? originalOff.call(jQuery(this), event, triggerAction) : jQuery(this), 'unrepeat', unrepeatAction);
  642. 			var context = executionState._context.not(this);
  643. 			executionState._next = (executionState._next == executionState._context) ? context : executionState._next;
  644. 			executionState._context = context;
  645. 			executionState._canContinue = executionState._context.length && executionState._canContinue;
  646. 			trigger = executionState._context.length && trigger;
  647. 			window.clearInterval(!executionState._context.length && interval);
  648. 			// just update the snapshot info
  649. 			timedInvocationChain();
  650. 		}
  651. 		
  652. 		executionState._openEndAction = function(tic, state){
  653. 			if (executionState._canContinue || openLoopTimeout) {
  654. 				executionState._count++;
  655. 				executionState._next = executionState._next || executionState._context;
  656. 				executionState._canContinue = executionState._canContinue || (trigger && state._context && state._context.length);
  657. 				return executionState;
  658. 			}
  659. 		};
  660.  
  661. 		if (trigger == null) {
  662. 			
  663. 			firstRunNow = trigger = true;
  664. 			window.setTimeout(function(){
  665. 				openLoopTimeout = true;
  666. 				timedInvocationChain();
  667. 			},0);
  668. 			
  669. 		} else {
  670. 			if (typeof trigger == "string") {
  671. 				originalOn.call(executionState._context, event = trigger, triggerAction);
  672. 			} else {
  673. 				interval = window.setInterval(triggerAction, Math.max(0, trigger));				
  674. 			}
  675. 			trigger = false;
  676. 		}
  677.  
  678. 		originalOn.call(executionState._context, 'unrepeat', unrepeatAction);
  679. 		
  680. 		executionState._next = executionState._context;
  681. 		executionState._count = 0;
  682. 		executionState._untilAction = function(end){
  683. 			if (end) {
  684. 				unrepeatAction.apply(executionState._context);
  685. 			}
  686. 			if (trigger) {
  687. 				triggerAction();
  688. 			}
  689. 		};
  690. 		executionState._fixOpenLoop = loopEndMethods.until;
  691.  
  692. 		if (firstRunNow) {
  693. 			triggerAction();
  694. 		}
  695. 		
  696. 		ongoingLoops.unshift(executionState);
  697. 	};
  698.  
  699. 	/**
  700. 	 * Defined to evaluate condition when calling .until()
  701. 	 */
  702. 	loopEndMethods.until = function(executionState){
  703. 		jQuery.extend(executionState._method, {
  704. 			_next: jQuery.extend({}, executionState._method),
  705. 			_name: 'until',
  706. 			_arguments: []
  707. 		});
  708. 		executionState._canContinue = null;
  709. 	};
  710. 	loopEndMethods.until.timing = function(timedInvocationChain, executionState, ongoingLoops) {
  711. 		if (!ongoingLoops.length || !ongoingLoops[0]._fixOpenLoop) {
  712. 			throw '.until() method must be used after .repeat() only';
  713. 		}
  714. 		if (!ongoingLoops[0]._untilAction) {
  715. 			ongoingLoops[0]._fixOpenLoop(executionState);
  716. 			return;
  717. 		}
  718.  
  719. 		var condition = executionState._method._arguments[0],
  720. 		loopContext = executionState._method._arguments[1];
  721. 		if (condition === jQuery) {
  722. 			condition = null;
  723. 			loopContext = executionState._method._arguments.length <= 1 || loopContext;
  724. 		}
  725. 		if (typeof condition == "function") {
  726. 			condition = condition.apply(executionState._context, loopCounts(ongoingLoops));
  727. 		}
  728. 		if (condition == null) {
  729. 			condition = !executionState._context.size();
  730. 		}
  731. 		if (typeof condition == "object") {
  732. 			condition = condition.toString();
  733. 		}
  734. 		if (typeof condition == "number") {
  735. 			condition = ongoingLoops[0]._count >= condition-1;
  736. 		}
  737. 		if (condition) {
  738. 			executionState._canContinue = true;
  739. 			executionState._next = executionState._context;
  740. 			ongoingLoops.shift()._untilAction(condition);
  741. 		} else {
  742. 			if (loopContext) {
  743. 				ongoingLoops[0]._next = executionState._context;
  744. 			}
  745. 			executionState = ongoingLoops[0];
  746. 			executionState._count++;
  747. 			executionState._untilAction(condition);
  748. 			return executionState;
  749. 		}
  750. 	};
  751. 	
  752. 	// support .until() and .all()
  753. 	new PredictingProxy(loopEndMethods);
  754. 	
  755. 	/**
  756. 	 * Define unwait and unrepeat methods.
  757. 	 */
  758. 	jQuery.each(['unwait','unrepeat'], function(index, name){
  759. 		jQuery.fn[name] = function(){
  760. 			return this.trigger(name, arguments);
  761. 		};
  762. 	});
  763. 	
  764. 	/**
  765. 	 * define all static timing methods:
  766. 	 *  $.wait, $.repeat ,$.join, $.then, $.unwait, $.unrepeat
  767. 	 */
  768. 	jQuery.each(['wait','repeat','join','then','unwait','unrepeat'], function(index, name){
  769. 		jQuery[name] = function(){
  770. 			var group = typeof arguments[0] == "string" ? Array.prototype.shift.apply(arguments) : '';
  771. 			return jQuery.fn[name].apply(THREAD_GROUPS[group] = (THREAD_GROUPS[group] || jQuery('<div>').text(group)), arguments);
  772. 		};
  773. 	});
  774.  
  775. 	/**
  776. 	 * X defines deferred variables that can be used in timed invocation chains 
  777. 	 * 
  778. 	 * @author CreativeCouple
  779. 	 * @author Peter Liske
  780. 	 */
  781. 	function X(compute, Var, calculation){
  782. 		if (typeof compute == "string") {
  783. 			calculation = new Function('x','return ['+compute+'\n,x]');
  784. 			compute = function(x, result){
  785. 				result = calculation(x);
  786. 				callbackVariable.x = result[1];
  787. 				return result[0];
  788. 			};
  789. 		}
  790. 		var hasRelatedVariable = typeof Var == "function",
  791. 		hasComputation = typeof compute == "function",
  792. 		
  793. 		callbackVariable = function(value) {
  794. 			if (arguments.length == 1) {
  795. 				callbackVariable.x = value;
  796. 				if (hasRelatedVariable) {
  797. 					Var(value);
  798. 				}
  799. 			} else {
  800. 				return evaluate();
  801. 			}
  802. 		};
  803. 		function evaluate(value){
  804. 			value = hasRelatedVariable ? Var() : callbackVariable.x;
  805. 			return hasComputation ? compute(value) : value;				
  806. 		}
  807. 		
  808. 		callbackVariable.x = 0;
  809. 		callbackVariable._ = { toString: callbackVariable.$ = callbackVariable.toString = evaluate.toString = evaluate };
  810. 		callbackVariable.mod = function(val){
  811. 			return X(function(x){
  812. 				return x % val;
  813. 			}, callbackVariable);
  814. 		};
  815. 		callbackVariable.add = function(val){
  816. 			return X(function(x){
  817. 				return x + val;
  818. 			}, callbackVariable);
  819. 		};
  820. 		callbackVariable.neg = function(){
  821. 			return X('-x', callbackVariable);
  822. 		};
  823. 		// $$ only for backward compatibility
  824. 		callbackVariable.$$ = callbackVariable.X = function(compute){
  825. 			return X(compute, callbackVariable);
  826. 		};
  827. 		jQuery.each(['a','b','c','d','e','f','g','h','i','j'], function(index, character){
  828. 			callbackVariable[index] = callbackVariable[character] = function(){
  829. 				callbackVariable(arguments[index]);
  830. 			};
  831. 		});
  832. 		
  833. 		return callbackVariable;
  834. 	};
  835. 	
  836. 	// $$ only for backward compatibility
  837. 	window.$$ = jQuery.$$ = jQuery.X = X;
  838. 	
  839. 	/**
  840. 	 * Define chained version of $().
  841. 	 * This allows to use .end() to come back to previous jQuery selection.
  842. 	 */
  843. 	jQuery.fn.$ = function(){
  844. 		var ret = jQuery.apply(window, arguments);
  845. 		ret.prevObject = this;
  846. 		return ret;
  847. 	};
  848. 	
  849. })(jQuery, window);