☰

Timing_JQuery

try to take over the world!

当前为 2020-06-01 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.cn-greasyfork.org/scripts/404470/811202/Timing_JQuery.js 

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