Compare Revisions

J.D.M.

Revision 348297:

Revision 348297 by fusionchess on

Revision 348299:

Revision 348299 by fusionchess on

Title:
Javascript Daemons Management
J.D.M.
Slug:
User:fusionchess/Sandbox/Daemon
User:fusionchess/Sandbox/Daemon
Content:

Revision 348297
Revision 348299
n8      In Computer science a <em>daemon</em> is a task that runs an8      The content of this page has been moved <a href="/en-US/doc
>s a background process, rather than being under the direct contro>s/JavaScript/Timers/Daemons" title="/en-US/docs/JavaScript/Timers
>l of an interactive user. In JavaScript programming language, are>/Daemons">here</a>.
> called <em>daemons</em> all processes created by JavaScript time 
>rs or by a <a href="https://developer.mozilla.org/en-US/docs/DOM/ 
>Worker" title="/en-US/docs/DOM/Worker"><code>Worker</code></a> in 
>stantiation. Here are some code snippets which simplify and abstr 
>act the management of daemons. 
n10    <p>n
11      The following <em>daemons management framework</em> is <str
>ong>the major version of <a href="/en-US/docs/DOM/window.setInter 
>val#A_little_framework" title="/en-US/docs/DOM/window.setInterval 
>#A_little_framework">setInterval – <em>A little framework</em></a 
>></strong>. 
12    </p>
13    <h2 id="Introduction">
14      Introduction
15    </h2>
16    <p>
17      Sometimes a page uses dozens and dozens of animations. In s
>uch a condition is difficult and unnatural to keep track of all e 
>vents started and then to stop them when appropriate through the  
><code>clearTimeout()</code> function. A possible approach to solv 
>e this problem is to nest all the informations needed by each ani 
>mation to start, stop, etc. etc. in different objects (<em>daemon 
>s</em>) and then to create a constructor for such class of object 
>s (<code>Daemon</code>) in order to standardize and simplify the  
>instantiation of them. 
18    </p>
19    <div class="note">
20      <strong>Note:</strong> A minimalistic version of it (<code>
><em>MiniDaemon</em></code>) is published <strong><a href="/en-US/ 
>docs/DOM/window.setInterval#A_little_framework" title="/en-US/doc 
>s/DOM/window.setInterval#A_little_framework">here</a></strong>. T 
>his more complex version of it is nothing but a big and scalable  
>collection of methods for the <code><em>Daemon</em></code> constr 
>uctor. But the <code><em>Daemon</em></code> constructor itself is 
> nothing but a clone of <code><em>MiniDaemon</em></code> with an  
>added support for <em>init</em> and <em>onstart</em> functions de 
>clarable during the instantiation of the <code><em>daemon</em></c 
>ode>. <strong>So the <code><em>MiniDaemon</em></code> framework w 
>ill remain the recommended way for simple animations</strong>, be 
>cause <code><em>Daemon</em></code> without its collection of meth 
>ods is essentially a clone of it. 
21    </div>
22    <p>
23      The architecture of the <code>Daemon</code> constructor exp
>licitly avoids the use of closures. It also offers an alternative 
> way to pass the <a href="https://developer.mozilla.org/en-US/doc 
>s/JavaScript/Reference/Operators/this" title="en-US/docs/JavaScri 
>pt/Reference/Operators/this"><code>this</code></a> object to the  
>callback functions (see <a href="https://developer.mozilla.org/en 
>-US/docs/DOM/window.setInterval#The_.22this.22_problem" title="Th 
>e 'this' problem">The "this" problem</a> for details). 
24    </p>
25    <p>
26      Advantages of this approch:
27    </p>
28    <ul>
29      <li>abstraction,
30      </li>
31      <li>passage of <a href="/en-US/docs/JavaScript/Reference/Op
>erators/this" title="en-US/docs/JavaScript/Reference/Operators/th 
>is"><code>this</code></a> object to JavaScript timers (both <a hr 
>ef="https://developer.mozilla.org/en-US/docs/DOM/window.setInterv 
>al" title="https://developer.mozilla.org/en-US/docs/DOM/window.se 
>tInterval"><code>setInterval</code></a> and <a href="https://deve 
>loper.mozilla.org/en-US/docs/DOM/window.setTimeout" title="https: 
>//developer.mozilla.org/en-US/docs/DOM/window.setTimeout"><code>s 
>etTimeout</code></a>), 
32      </li>
33      <li>optimisation (avoiding <a href="/en-US/docs/JavaScript/
>Guide/Closures" title="/en-US/docs/JavaScript/Guide/Closures">clo 
>sures</a>), 
34      </li>
35      <li>modularity.
36      </li>
37    </ul>
38    <h2 id="The_code">
39      The code
40    </h2>
41    <p>
42      The code of this framework is splitted into three files:
43    </p>
44    <ul>
45      <li>
46        <strong>fork.js</strong> (the core),
47      </li>
48      <li>
49        <strong>daemon-safe.js</strong> (an extension of the core
> which <em>adds</em> a replacement of <a href="https://developer. 
>mozilla.org/en-US/docs/DOM/window.setInterval" title="https://dev 
>eloper.mozilla.org/en-US/docs/DOM/window.setInterval"><code>setIn 
>terval</code></a> with a recursive invocation of <a href="https:/ 
>/developer.mozilla.org/en-US/docs/DOM/window.setTimeout" title="h 
>ttps://developer.mozilla.org/en-US/docs/DOM/window.setTimeout"><c 
>ode>setTimeout</code></a>), 
50      </li>
51      <li>
52        <strong>daemon-methods.js</strong> (a wide and highly sca
>lable collection of methods). 
53      </li>
54    </ul>
55    <p>
56      The only indipendent module is <strong>fork.js</strong>: bo
>th <strong>daemon-safe.js</strong> module and <strong>daemon-meth 
>ods.js</strong> module require <strong>fork.js</strong> to work. 
57    </p>
58    <h4 id="About_the_.E2.80.9Ccallback_arguments.E2.80.9D_polyfi
>ll"> 
59      About the <a href="/en-US/docs/DOM/window.setInterval#Callb
>ack_arguments" title="/en-US/docs/DOM/window.setInterval#Callback 
>_arguments">“callback arguments” polyfill</a> 
60    </h4>
61    <p>
62      In order to make this framework compatible with Internet Ex
>plorer (which doesn't support <a href="/en-US/docs/DOM/window.set 
>Interval#Callback_arguments" title="/en-US/docs/DOM/window.setInt 
>erval#Callback_arguments">sending additional parameters to timers 
>' callback function</a>, neither with <code>setTimeout()</code> o 
>r <code>setInterval()</code>) we included <a href="/en-US/docs/DO 
>M/window.setInterval#Callback_arguments" title="/en-US/docs/DOM/w 
>indow.setInterval#Callback_arguments">the <em>IE-specific</em> co 
>mpatibility code</a>, which enables the HTML5 standard parameters 
> passage functionality in that browser for both timers (polyfill) 
>, at the end of the <strong>fork.js</strong> module. 
63    </p>
64    <h3 id="fork.js">
65      fork.js
66    </h3>
67    <p>
68      What follows is the module which declare the <code>Daemon</
>code> constructor (the core of this framework). The <code>Daemon< 
>/code> constructor itself is nothing but a clone of <a href="/en- 
>US/docs/DOM/window.setInterval#A_little_framework" title="/en-US/ 
>docs/DOM/window.setInterval#A_little_framework">the little framew 
>ork <code>MiniDaemon</code></a> with an added support for <code>i 
>nit</code> and <code>onstart</code> functions (declarable during  
>the instantiation of the daemon). <strong>So the <code>MiniDaemon 
></code> framework will remain the recommended way for simple anim 
>ations</strong>, because <code>Daemon</code> without its collecti 
>on of methods is essentially a clone of it. 
69    </p>
70    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
71      <pre class="brush: js">
72 /*\
73 |*|
74 |*|                     *******************************
75 |*|                     *           fork.js           *
76 |*|                     *******************************
77 |*|
78 |*|
79 |*|
80 |*|  A JAVASCRIPT HIGLY SCALABLE DAEMONS MANAGER.
81 |*|
82 |*|  https://developer.mozilla.org/en-US/docs/JavaScript/Timers/
>Daemons 
83 |*|  https://developer.mozilla.org/User:fusionchess
84 |*|
85 |*|  This framework is released under the GNU Public License, ve
>rsion 3 or later. 
86 |*|  http://www.gnu.org/licenses/gpl-3.0-standalone.html
87 |*|
88 |*|
89 |*|  :: Content of this file ::
90 |*|
91 |*|
92 |*|  The Daemon base system.
93 |*|
94 |*|
95 |*|  :: The constructor ::
96 |*|
97 |*|
98 |*|  Syntax
99 |*|
100 |*|       var myDaemon = new Daemon(@thisObject, @callback[, @le
>ngth, @rate, @init, @onstart]); 
101 |*|
102 |*|
103 |*|  Description
104 |*|
105 |*|  Constructs a JavaScript Object containing all informations 
>needed by an animation (like the "this" 
106 |*|  object, the callback function, the length, the frame-rate, 
>the number of cycles, the "init" and 
107 |*|  the "onstart" functions).
108 |*|
109 |*|
110 |*|  Arguments
111 |*|
112 |*|  - @thisObject -
113 |*|  The "this" object on which will be called the callback func
>tion. It can be an object or null. If 
114 |*|  is null, the "this" object will point to the global "Deamon
>.context" object (see below). 
115 |*|
116 |*|  - @callback -
117 |*|  The function which will be invoked repeatedly. It will be c
>alled with three parameters: @index 
118 |*|  (the iterative index of each invocation), @length (the numb
>er of total invocations assigned to the 
119 |*|  daemon - finite or Infinity) and @backwards (a boolean expr
>essing whether the process is going 
120 |*|  backwards or not).
121 |*|  It will be something like @callback.call(@thisObject, @inde
>x, @length, @backwards). 
122 |*|  If the @callback function returns a "false" value the daemo
>n will be paused. 
123 |*|
124 |*|  - @length [optional] -
125 |*|  The total number of invocations. It can be a positive integ
>er or Infinity. The default value is 
126 |*|  Infinity.
127 |*|
128 |*|  - @rate [optional] -
129 |*|  The time lapse (in number of milliseconds) between each inv
>ocation. The default value is 100. 
130 |*|
131 |*|  - @init [optional] -
132 |*|  The function which will be synchronously invoked once durin
>g the creation of the daemon and 
133 |*|  then assigned to the "onstop" property.
134 |*|  It will be called with the same three arguments of the @cal
>lback function. They will also have the 
135 |*|  same values of the last invocation of the @callback functio
>n. 
136 |*|
137 |*|  - @onstart -
138 |*|  The function which will be synchronously invoked on wheneve
>r the "start" event occurs. It will be 
139 |*|  assigned to the "onstart" property.
140 |*|  It will be called with three arguments: @index (the actual 
>index), @length (the number of total 
141 |*|  invocations assigned to the daemon - finite or Infinity) an
>d @backwards (a boolean expressing 
142 |*|  whether the @index will go decreasing or not).
143 |*|
144 |*|
145 |*|  :: Daemon global object properties ::
146 |*|
147 |*|
148 |*|  - Daemon.context -
149 |*|  An empty object used as default *this* object when the @thi
>sObject is not specified during the 
150 |*|  construction of the daemon. If you want your callback funct
>ion to be invoked with a "null" *this* 
151 |*|  object you have to manually set the "owner" property to "nu
>ll". 
152 |*|
153 |*|
154 |*|  :: Daemon global object methods ::
155 |*|
156 |*|
157 |*|  - Daemon.forceCall(@daemonInstance) -
158 |*|  Forces a callback to the @daemonInstance.task function rega
>rdless of the fact that the end has 
159 |*|  been reached or not. In any case the internal "INDEX" prope
>rty will be increased/decreased 
160 |*|  (depending on the actual direction of the daemon).
161 |*|
162 |*|  - Daemon.construct(@arrayOfArguments) -
163 |*|  Returns a new daemon constructed upon an array of arguments
>. It is very similar to the 
164 |*|  Function.prototype.apply() method.
165 |*|
166 |*|  - Daemon.buildAround(@context[, @length, @rate]) -
167 |*|  Returns a new daemon built around a @context object. The @c
>ontext object must cointain *at least* 
168 |*|  a "perform" property pointing to what you want to be the @c
>allback function of the daemon. 
169 |*|  It can also optionally contain a "create" and a "prepare" p
>roperties pointing respectively to the 
170 |*|  two functions you want to be the @init and @onstart functio
>ns of Daemon constructor's arguments. 
171 |*|  The @context object will be also the *this* object of your 
>callback function. So you can populate 
172 |*|  it with all your custom properties. and methods. The only r
>equired one property is "perform". 
173 |*|    
174 |*|    Sample usage:
175 |*|
176 |*|      var myDaemon = Daemon.buildAround({
177 |*|        "create": function () { [custom code] },  // optional
178 |*|        "prepare": function () { [custom code] },  // optiona
>l 
179 |*|        "perform": function () { [custom code] },  // require
>d 
180 |*|        "customProperty": [custom value],
181 |*|        "myCustomMethod": function () { [custom code] },
182 |*|        "anotherCustomProperty": [custom value],
183 |*|        "etc.": "etc."
184 |*|      }, 30, 200);
185 |*|    
186 |*|
187 |*|  - Daemon.incorporate(@function) -
188 |*|  The @function.prototype property will replaced with a *new 
>Daemon()* object. The old replaced 
189 |*|  prototype will be preserved within a new property of the ne
>w @function.prototype object named "legacy". 
190 |*|
191 |*|
192 |*|  :: Other constructors ::
193 |*|
194 |*|
195 |*|  - Daemon.blank -
196 |*|  Constructs a new instance of Daemon without own properties.
> This constructor is useful in order to 
197 |*|  create your own *MySomeDaemon* constructors through the *My
>SomeDaemon.prototype = new Daemon.blank();* 
198 |*|  assignment.
199 |*|
200 |*|  - Daemon.safe [optional module] -
201 |*|  A clone of the Daemon constructor based on setTimeout rathe
>r than on setInterval. See the Daemon.safe 
202 |*|  module for details.
203 |*|  NOTE: The Daemon.safe constructor is not part of the base s
>ystem. 
204 |*|
205 |*|  - Daemon.safe.blank [optional module] -
206 |*|  The same as for Daemon.blank, but applied to the Daemon.saf
>e constructor. 
207 |*|  NOTE: The Daemon.safe constructor is not part of the base s
>ystem. 
208 |*|
209 |*|
210 |*|  :: Daemon instances properties ::
211 |*|
212 |*|
213 |*|  - myDaemon.owner -
214 |*|  The "this" object on which is executed the daemon (read/wri
>te). It can be an object or null. Its default 
215 |*|  value is Daemon.context.
216 |*|
217 |*|  - myDaemon.task -
218 |*|  The function which will be repeatedly invoked (read/write).
> It will be called with three 
219 |*|  arguments: @index (the iterative index of each invocation),
> @length (the number of total 
220 |*|  invocations assigned to the daemon - finite or Infinity) an
>d @backwards (a boolean expressing 
221 |*|  whether the @index is decreasing or not). See above.
222 |*|  If the myDaemon.task function returns a "false" the Daemon 
>will be paused. 
223 |*|
224 |*|  - myDaemon.length -
225 |*|  The total number of invocations. It can be a positive integ
>er or Infinity (read/write). 
226 |*|
227 |*|  - myDaemon.rate -
228 |*|  The time lapse (in number of milliseconds) between each inv
>ocation (read/write). 
229 |*|
230 |*|  - myDaemon.reversals -
231 |*|  The number of times the daemon must be restarted (read/writ
>e). Set it to Infinity for a "loop mode". 
232 |*|
233 |*|  - myDaemon.onstart -
234 |*|  The "start" listener (read/write).
235 |*|  It will be called with three arguments: @index (the actual 
>index), @length (the number of total 
236 |*|  invocations assigned to the daemon - finite or Infinity) an
>d @backwards (a boolean expressing 
237 |*|  whether the @index will go decreasing or not).
238 |*|
239 |*|  - myDaemon.onstop -
240 |*|  The "stop" listener (read/write).
241 |*|  It will be called with three arguments: @index (the index o
>f the last invocation), @length (the 
242 |*|  number of total invocations assigned to the daemon - finite
> or Infinity) and @backwards (a boolean 
243 |*|  expressing whether the @index of the last execution was dec
>reasing or not). 
244 |*|  NOTE: The stop() method is not part of the base system.
245 |*|
246 |*|
247 |*|  :: Daemon instances methods ::
248 |*|
249 |*|
250 |*|  - myDaemon.isAtEnd() -
251 |*|  Returns a boolean expressing whether the daemon is at the s
>tart/end position or not. 
252 |*|
253 |*|  - myDaemon.synchronize() -
254 |*|  Synchronize the timer of a started daemon with the time of 
>invocation of myDaemon.synchronize(). If 
255 |*|  the rate property has been changed the daemon will be updat
>ed with the new rate value. 
256 |*|
257 |*|  - myDaemon.pause() -
258 |*|  Pauses the daemon.
259 |*|
260 |*|  - myDaemon.start([@backwards]) -
261 |*|  Starts the daemon forward (index of each invocation increas
>ing) or backwards (index decreasing). 
262 |*|
263 \*/
264 
265"use strict";
266 
267 
268      /****************************
269      *     THE DAEMON SYSTEM     *
270      ****************************/
271 
272 
273 
274/* The global "Daemon" constructor */
275 
276  function Daemon (oOwner, fTask, nLen, nRate, fInit, fOnstart) {
277    if (!(this &amp;&amp; this instanceof Daemon)) { return; }
278    if (arguments.length &lt; 2) { throw new TypeError("Daemon - 
>not enough arguments"); } 
279    if (oOwner) { this.owner = oOwner };
280    this.task = fTask;
281    if (nLen &gt; 0) { this.length = Math.floor(nLen); }
282    if (isFinite(nRate) &amp;&amp; nRate &gt; 0) { this.rate = Ma
>th.floor(nRate); } 
283    if (fOnstart) { this.onstart = fOnstart; }
284    if (fInit) {
285      this.onstop = fInit;
286      fInit.call(oOwner, this.INDEX, this.length, this.BACKW);
287    }
288  }
289 
290    /* Create the Daemon.blank() constructor and the global Daemo
>n.context object */ 
291 
292  Daemon.blank = function () {};
293  Daemon.context = Daemon.blank.prototype; /* Make love with the 
>GC :-) */ 
294  Daemon.blank.prototype = /* Important! */ Daemon.prototype;
295  Daemon.context.constructor = Object;
296 
297    /* These properties can be manually reconfigured after the cr
>eation of the daemon */ 
298 
299  Daemon.prototype.owner = Daemon.context;
300  Daemon.prototype.task = null;
301  Daemon.prototype.length = Infinity;
302  Daemon.prototype.rate = 100;
303  Daemon.prototype.reversals = 0;
304  Daemon.prototype.onstart = null;
305  Daemon.prototype.onstop = null;
306 
307    /* These properties should be read-only after the creation of
> the daemon */ 
308 
309  Daemon.prototype.SESSION = -1;
310  Daemon.prototype.INDEX = 0;
311  Daemon.prototype.PAUSED = true;
312  Daemon.prototype.BACKW = true;
313 
314 
315/* SYSTEM REQUIRED Daemon global object methods */
316 
317  Daemon.forceCall = function (oDmn) {
318 
319    oDmn.INDEX += oDmn.BACKW ? -1 : 1;
320 
321    var
322      bBreak = oDmn.task.call(oDmn.owner, oDmn.INDEX, oDmn.length
>, oDmn.BACKW) === false, 
323      bEnd = oDmn.isAtEnd(), bInvert = oDmn.reversals &gt; 0;
324 
325    if (bEnd &amp;&amp; !bInvert || bBreak) {
326      oDmn.pause();
327      return false;
328    }
329 
330    if (bEnd &amp;&amp; bInvert) {
331      oDmn.BACKW = !oDmn.BACKW;
332      oDmn.reversals--;
333    }
334 
335    return true;
336 
337  };
338 
339 
340/* SYSTEM NOT REQUIRED Daemon global object methods */
341 
342  /**
343  * Daemon global object optional methods (shortcurts). You could
> safely remove all or some of them, 
344  * depending on your needs. If you want to remove them and are u
>sing the Daemon.safe subsystem you 
345  * should remove also the Daemon.safe global object methods whic
>h require them. 
346  **/
347 
348  Daemon.construct = function (aArgs) {
349    var oDmn = new this.blank();
350    this.apply(oDmn, aArgs);
351    return oDmn;
352  };
353 
354  Daemon.buildAround = function (oCtx, nLen, nRate) {
355    if (!oCtx.perform) { throw new TypeError("You can not create 
>a daemon around an object devoid of a \"perform\" function"); } 
356    return new this(oCtx, oCtx.perform, nLen || null, nRate || nu
>ll, oCtx.create || null, oCtx.prepare || null); 
357  };
358 
359    /* Warning! Calling Daemon.incorporate(@func) will modify the
> @func.prototype property! */ 
360 
361  Daemon.incorporate = function (fConstr) {
362    var oLegacy = fConstr.prototype;
363    fConstr.prototype = new Daemon.blank();
364    fConstr.prototype.legacy = oLegacy;
365    return fConstr;
366  };
367 
368 
369/* SYSTEM REQUIRED Daemon instances methods */
370 
371  Daemon.prototype.isAtEnd = function () {
372    return this.BACKW ? isFinite(this.length) &amp;&amp; this.IND
>EX &lt; 1 : this.INDEX + 1 &gt; this.length; 
373  };
374 
375  Daemon.prototype.synchronize = function () {
376    if (this.PAUSED) { return; }
377    clearInterval(this.SESSION);
378    this.SESSION = setInterval(Daemon.forceCall, this.rate, this)
>; 
379  };
380 
381  Daemon.prototype.pause = function () {
382    clearInterval(this.SESSION);
383    this.PAUSED = true;
384  };
385 
386 
387/* SYSTEM NOT REQUIRED Daemon instances methods */
388 
389  /**
390  * Basical user interface. You could remove this method, but you
>r daemon will be virtually unusable. 
391  * All other optional instances methods depend on this one or on
> the previous ones. 
392  **/
393 
394  Daemon.prototype.start = function (bReverse) {
395    var bBackw = Boolean(bReverse);
396    if (this.BACKW === bBackw &amp;&amp; (this.isAtEnd() || !this
>.PAUSED)) { return false; } 
397    this.BACKW = bBackw;
398    this.PAUSED = false;
399    if (this.onstart) { this.onstart.call(this.owner, this.INDEX,
> this.length, this.BACKW); } 
400    this.synchronize();
401    return true;
402  };
403 
404 
405 
406      /*******************************
407      *     DAEMON IS NOW READY!     *
408      *******************************/
409 
410 
411 
412 
413      /*******************************
414      *          POLYFILLS           *
415      *******************************/
416 
417 
418 
419 /*\
420 |*|
421 |*|  IE-specific polyfill which enables the passage of arbitrary
> arguments to the 
422 |*|  callback functions of JavaScript timers (HTML5 standard syn
>tax). 
423 |*|
424 |*|  https://developer.mozilla.org/en-US/docs/DOM/window.setInte
>rval 
425 |*|
426 |*|  Syntax:
427 |*|  var timeoutID = window.setTimeout(func, delay, [param1, par
>am2, ...]); 
428 |*|  var timeoutID = window.setTimeout(code, delay);
429 |*|  var intervalID = window.setInterval(func, delay[, param1, p
>aram2, ...]); 
430 |*|  var intervalID = window.setInterval(code, delay);
431 |*|
432 \*/
433 
434  if (document.all &amp;&amp; !window.setTimeout.isPolyfill) {
435    var __nativeST__ = window.setTimeout;
436    window.setTimeout = function (vCallback, nDelay /*, argumentT
>oPass1, argumentToPass2, etc. */) { 
437      var aArgs = Array.prototype.slice.call(arguments, 2);
438      return __nativeST__(vCallback instanceof Function ? functio
>n () { 
439        vCallback.apply(null, aArgs);
440      } : vCallback, nDelay);
441    };
442    window.setTimeout.isPolyfill = true;
443  }
444   
445  if (document.all &amp;&amp; !window.setInterval.isPolyfill) {
446    var __nativeSI__ = window.setInterval;
447    window.setInterval = function (vCallback, nDelay /*, argument
>ToPass1, argumentToPass2, etc. */) { 
448      var aArgs = Array.prototype.slice.call(arguments, 2);
449      return __nativeSI__(vCallback instanceof Function ? functio
>n () { 
450        vCallback.apply(null, aArgs);
451      } : vCallback, nDelay);
452    };
453    window.setInterval.isPolyfill = true;
454  }
455</pre>
456    </div>
457    <h3 id="daemon-safe.js">
458      daemon-safe.js
459    </h3>
460    <p>
461      What follows is the module which extends the <code>Daemon</
>code> constructor with a <code>Daemon.safe</code> sub-system. Thi 
>s library requires <strong>fork.js</strong> to work. <strong>The  
><code>Daemon.safe</code> constructor is as a dependent-clone of < 
>code>Daemon</code> which uses a recursive invocation of the <code 
>>setTimeout</code> timer rather than a single invocation of <code 
>>setInterval</code>.</strong> 
462    </p>
463    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
464      <pre class="brush: js">
465 /*\
466 |*|
467 |*|                     *******************************
468 |*|                     *        daemon-safe.js       *
469 |*|                     *******************************
470 |*|
471 |*|
472 |*|
473 |*|  A JAVASCRIPT HIGLY SCALABLE DAEMONS MANAGER
474 |*|
475 |*|  https://developer.mozilla.org/en-US/docs/JavaScript/Timers/
>Daemons 
476 |*|  https://developer.mozilla.org/User:fusionchess
477 |*|
478 |*|  This framework is released under the GNU Public License, ve
>rsion 3 or later. 
479 |*|  http://www.gnu.org/licenses/gpl-3.0-standalone.html
480 |*|
481 |*|
482 |*|  :: Content of this file ::
483 |*|
484 |*|
485 |*|  The Daemon.safe sub-system. This library requires "fork.js"
>. 
486 |*|  Daemon.safe constructor is as a dependent-clone of Daemon w
>hich uses a recursive invocation of the 
487 |*|  setTimeout() timer rather than a single invocation of setIn
>terval(). 
488 |*|
489 |*|
490 |*|  :: The constructor ::
491 |*|
492 |*|
493 |*|  Syntax
494 |*|
495 |*|       var mysafeDaemon = new Daemon.safe(@thisObject, @callb
>ack[, @length, @rate, @init, @onstart]); 
496 |*|
497 |*|
498 |*|  Description
499 |*|
500 |*|  Constructs a JavaScript Object containing all informations 
>needed by an animation (see the Daemon 
501 |*|  constructor for details).
502 |*|
503 |*|
504 |*|  Arguments
505 |*|
506 |*|  [the same as Daemon]
507 |*|
508 |*|
509 |*|  :: Daemon.safe global object properties ::
510 |*|
511 |*|
512 |*|  - Daemon.safe.context -
513 |*|  See: Daemon.context.
514 |*|  This context will not used by default. It will be used the 
>global Daemon.context instead. 
515 |*|
516 |*|
517 |*|  :: Daemon.safe global object methods ::
518 |*|
519 |*|
520 |*|  - Daemon.safe.forceCall(@daemonInstance) -
521 |*|  See: Daemon.forceCall()
522 |*|
523 |*|  - Daemon.safe.construct(@arrayOfArguments) -
524 |*|  See: Daemon.construct()
525 |*|
526 |*|  - Daemon.safe.buildAround(@object) -
527 |*|  See: Daemon.buildAround()
528 |*|
529 |*|  - Daemon.safe.incorporate(@function) -
530 |*|  See: Daemon.incorporate()
531 |*|
532 |*|
533 |*|  :: Other constructors ::
534 |*|
535 |*|
536 |*|  - Daemon.safe.blank -
537 |*|  The same as Daemon.blank, but applied to the Daemon.safe co
>nstructor. 
538 |*|
539 |*|
540 |*|  :: Daemon.safe instances properties ::
541 |*|
542 |*|  [inherited from Daemon.prototype]
543 |*|
544 |*|
545 |*|  :: Daemon.safe instances methods ::
546 |*|
547 |*|  [inherited from Daemon.prototype]
548 |*|
549 \*/
550 
551"use strict";
552 
553 
554      /**************************************
555      *     THE SAFE-DAEMON SUB-SYSTEM     *
556      **************************************/
557 
558 
559 
560/* The "Daemon.safe" constructor */
561 
562  Daemon.safe = function () { Daemon.apply(this, arguments); };
563 
564    /* Create the Daemon.safe.blank() constructor and the Daemon.
>safe.context object */ 
565 
566  Daemon.safe.blank = function () {};
567  Daemon.TO_BE_DEFINED = Daemon.safe.prototype;
568  Daemon.safe.context = Daemon.safe.blank.prototype; /* Make love
> with the GC :-) */ 
569  Daemon.safe.blank.prototype = /* Important! */ Daemon.safe.prot
>otype = /* Important! */ new Daemon.blank(); 
570  Daemon.safe.prototype.constructor = Daemon.safe;
571  Daemon.TO_BE_DEFINED.constructor = Daemon.safe.context.construc
>tor = Object; 
572 
573 
574/* SYSTEM REQUIRED Daemon.safe global object methods */
575 
576  Daemon.safe.forceCall = function (oDmn) {
577 
578    oDmn.INDEX += oDmn.BACKW ? -1 : 1;
579 
580    var
581      bBreak = oDmn.task.call(oDmn.owner, oDmn.INDEX, oDmn.length
>, oDmn.BACKW) === false, 
582      bEnd = oDmn.isAtEnd(), bInvert = oDmn.reversals &gt; 0;
583 
584    if (bEnd &amp;&amp; !bInvert || bBreak) {
585      oDmn.PAUSED = true;
586      return false;
587    }
588 
589    if (bEnd &amp;&amp; bInvert) {
590      oDmn.BACKW = !oDmn.BACKW;
591      oDmn.reversals--;
592    }
593 
594    oDmn.synchronize();
595 
596    return true;
597 
598  };
599 
600 
601/* SYSTEM NOT REQUIRED Daemon.safe global object methods */
602 
603  /**
604  * Daemon.safe global object optional methods (shortcurts). You 
>could safely remove all or some of 
605  * them, depending on your needs.
606  **/
607 
608    /* Warnign: this method requires the global Daemon.construct(
>) method */ 
609  Daemon.safe.construct = Daemon.construct;
610 
611    /* Warnign: this method requires the global Daemon.buildAroun
>d() method */ 
612  Daemon.safe.buildAround = Daemon.buildAround;
613 
614    /* Warnign: this method requires the global Daemon.incorporat
>e() method */ 
615  Daemon.safe.incorporate = Daemon.incorporate;
616 
617 
618/* SYSTEM REQUIRED Daemon.safe instances methods */
619 
620  Daemon.safe.prototype.synchronize = function () {
621    if (this.PAUSED) { return; }
622    clearTimeout(this.SESSION);
623    this.SESSION = setTimeout(Daemon.safe.forceCall, this.rate, t
>his); 
624  };
625 
626  Daemon.safe.prototype.pause = function () {
627    clearTimeout(this.SESSION);
628    this.PAUSED = true;
629  };
630 
631 
632/* SYSTEM NOT REQUIRED Daemon.safe instances methods */
633 
634  /* [inherited from Daemon.prototype] */
635 
636 
637 
638      /*****************************************
639      *     THE SAFE-DAEMON IS NOW READY!     *
640      *****************************************/
641</pre>
642    </div>
643    <h3 id="daemon-methods.js">
644      daemon-methods.js
645    </h3>
646    <p>
647      What follows is a module which collects a wide and scalable
> list of additional methods for instances of <code>Daemon</code>  
>(and <code>Daemon.safe</code>). This module requires <strong>fork 
>.js</strong> to work.&nbsp; <strong>You can safely remove all or  
>some of these methods, depending on your needs (modularity).</str 
>ong>&nbsp; When a method requires the presence of another method  
>(it is relatively rare) there is a comment which explains why. If 
> there are not comments to that method it depends only on the bas 
>e system. 
648    </p>
649    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
650      <pre class="brush: js">
651 /*\
652 |*|
653 |*|                     *******************************
654 |*|                     *       daemon-methods.js     *
655 |*|                     *******************************
656 |*|
657 |*|
658 |*|
659 |*|  A JAVASCRIPT HIGLY SCALABLE DAEMONS MANAGER
660 |*|
661 |*|  https://developer.mozilla.org/en-US/docs/JavaScript/Timers/
>Daemons 
662 |*|  https://developer.mozilla.org/User:fusionchess
663 |*|
664 |*|  This framework is released under the GNU Public License, ve
>rsion 3 or later. 
665 |*|  http://www.gnu.org/licenses/gpl-3.0-standalone.html
666 |*|
667 |*|
668 |*|  :: Content of this file ::
669 |*|
670 |*|
671 |*|  Additional methods for the instances of Daemon. This module
> requires "fork.js" to work. 
672 |*|  You can safely remove all or some of these methods, dependi
>ng on your needs. 
673 |*|  When a method requires the presence of another method (it i
>s relatively rare) there is a comment 
674 |*|  which explains why. If there are not comments to that metho
>d it depends only on the base system. 
675 |*|
676 |*|
677 |*|  :: Daemon instances methods ::
678 |*|
679 |*|
680 |*|  - myDaemon.stop() -
681 |*|  Stops the daemon. All original properties will be restored.
> If it exists a "stop" listener it will 
682 |*|  be called with three arguments: @index (the index of the la
>st invocation), @length (the number of 
683 |*|  total invocations assigned to the daemon - finite or Infini
>ty) and @backwards (a boolean expressing 
684 |*|  whether the @index of the last execution was decreasing or 
>not). 
685 |*|
686 |*|  - myDaemon.syncStart([@backwards]) -
687 |*|  Starts the daemon with the first callback synchronous.
688 |*|
689 |*|  - myDaemon.play([@synchronous]) -
690 |*|  Starts the daemon forward. If the daemon was running in the
> same direction nothing will happen. 
691 |*|  If the argument is "true" the first callback will be synchr
>onous. 
692 |*|
693 |*|  - myDaemon.reversePlay([@synchronous]) -
694 |*|  Starts the daemon backwards. If the daemon was running in t
>he same direction nothing will happen. 
695 |*|  If the argument is "true" the first callback will be synchr
>onous. 
696 |*|
697 |*|  - myDaemon.move([@synchronous, @reversals, @backwards]) -
698 |*|  Starts a daemon synchronously or not.
699 |*|  If the @reversals argument is specified the myDaemon.revers
>als property will be setted on it. 
700 |*|  If the @backwards argument is specified the daemon will mov
>e forward (false) or backwards (true). If 
701 |*|  it is not specified the daemon will start in the same direc
>tion in which it has been left. If the 
702 |*|  daemon was running in the same direction, only the reversal
>s property will be possibly updated. 
703 |*|
704 |*|  - myDaemon.turn() -
705 |*|  Inverts the direction of the daemon. The reversals property
> will not be decreased. 
706 |*|
707 |*|  - myDaemon.makeLoop() -
708 |*|  Sets the reversals property equal to Infinity.
709 |*|
710 |*|  - myDaemon.unmakeLoop() -
711 |*|  Sets the reversals property equal to 0.
712 |*|
713 |*|  - myDaemon.setRate(@milliseconds) -
714 |*|  Sets the time lapse between calls (in milliseconds). If the
> daemon is running it will be immediately 
715 |*|  updated with the new property.
716 |*|
717 |*|  - myDaemon.forcePosition(@index) -
718 |*|  Sets the internal INDEX property equal to the @index argume
>nt without any kind of control about the range. 
719 |*|
720 |*|  - myDaemon.getDuration() -
721 |*|  Returns the duration of the daemon in milliseconds.
722 |*|
723 |*|  - myDaemon.getPosition() -
724 |*|  Returns the internal INDEX property.
725 |*|
726 |*|  - myDaemon.makeSteps(@howMany[, @backwards, @force]) -
727 |*|  Calls synchronously the callback function @howMany times. F
>orwards or backwards. If the 
728 |*|  @force argument is setted to "true" the possible "return fa
>lse" of the callback function will be ignored. 
729 |*|
730 |*|  - myDaemon.skipTo(@index[, @force]) -
731 |*|  Calls synchronously the callback function the number of tim
>es needed to reach the @index position. 
732 |*|  If the @force argument is setted to "true" the possible "re
>turn false" of the callback function will 
733 |*|  be ignored.
734 |*|
735 |*|  - myDaemon.skipFor(@delta[, @force]) -
736 |*|  Calls synchronously the callback function @howMany times in
> the same direction in which it was 
737 |*|  oriented. If the @force argument is setted to "true" the po
>ssible "return false" of the callback 
738 |*|  function will be ignored.
739 |*|
740 |*|  - myDaemon.close([@backwards, @force]) -
741 |*|  Closes the daemon, doing SYNCHRONOUSLY all pending operatio
>ns forward (index of each invocation 
742 |*|  increasing) or backwards (index decreasing). If the @force 
>argument is setted to "true" the 
743 |*|  possible "return false" of the callback function will be ig
>nored. 
744 |*|
745 |*|  - myDaemon.reclose([@force]) -
746 |*|  Closes the daemon, doing SYNCHRONOUSLY all pending operatio
>ns in the same direction in which is 
747 |*|  oriented the daemon. If the @force argument is setted to "t
>rue" the possible "return false" of the 
748 |*|  callback function will be ignored.
749 |*|
750 |*|  - myDaemon.restart() -
751 |*|  Stops and restarts the daemon.
752 |*|
753 |*|  - myDaemon.loopUntil(@date) -
754 |*|  Sets the reversals property in function of a future @date. 
>The @date argument can be a Date object, a string 
755 |*|  expressing the date in GMTString format, or a number expres
>sing the number of milliseconds since 
756 |*|  January 1, 1970, 00:00:00 UTC.
757 |*|
758 |*|  - myDaemon.spread(@milliseconds) -
759 |*|  Sets the the total duration of the daemon in milliseconds. 
>Only the rate property will be modified. 
760 |*|
761 |*|  - myDaemon.adaptLength(@milliseconds) -
762 |*|  Sets the internal length property equal to milliseconds / r
>ate. 
763 |*|
764 |*|  - myDaemon.playUntil(@date) -
765 |*|  Starts the daemon forward and sets the the total duration o
>f it in function of a future date. The @date 
766 |*|  argument can be a Date object, a string expressing the date
> in GMTString format, or a number expressing 
767 |*|  the number of milliseconds since January 1, 1970, 00:00:00 
>UTC. Only the length property will be 
768 |*|  modified.
769 |*|
770 \*/
771 
772"use strict";
773 
774 
775/* SYSTEM NOT REQUIRED Daemon instances methods */
776 
777    /* Status */
778 
779  Daemon.prototype.stop = function () {
780    this.pause();
781    if (this.onstop) { this.onstop.call(this.owner, this.INDEX, t
>his.length, this.BACKW); } 
782    delete this.INDEX;
783    delete this.BACKW;
784    delete this.reversals;
785  };
786 
787    /* Movement */
788 
789  Daemon.prototype.syncStart = function (bReverse) {
790    this.synchronize();
791    if (this.start(bReverse || false)) {
792      Daemon.forceCall(this);
793      return true;
794    }
795    return false;
796  };
797 
798  Daemon.prototype.play = function (bSync) {
799    /* Warnign: this method OPTIONALLY requires the Daemon.protot
>ype.syncStart() method */ 
800    return this[bSync ? "start" : "syncStart"]();
801  };
802 
803  Daemon.prototype.reversePlay = function (bSync) {
804    /* Warnign: this method OPTIONALLY requires the Daemon.protot
>ype.syncStart() method */ 
805    return this[bSync ? "start" : "syncStart"](true);
806  };
807 
808  Daemon.prototype.move = function (bSync, nCycles, bDirection) {
809    /* Warnign: this method OPTIONALLY requires the Daemon.protot
>ype.syncStart() method */ 
810    if (arguments.length &gt; 1 &amp;&amp; !isNaN(nCycles)) { thi
>s.reversals = Number(nCycles); } 
811    this[bSync ? "start" : "syncStart"](arguments.length &gt; 2 ?
> bDirection : this.isAtEnd() !== this.BACKW); 
812  };
813 
814  Daemon.prototype.turn = function (bSync) {
815    /* Warnign: this method OPTIONALLY requires the Daemon.protot
>ype.syncStart() method */ 
816    this[bSync ? "start" : "syncStart"](!this.BACKW);
817  };
818 
819    /* Settings tools */
820 
821  Daemon.prototype.makeLoop = function () {
822    this.reversals = Infinity;
823  };
824 
825  Daemon.prototype.unmakeLoop = function () {
826    this.reversals = 0;
827  };
828 
829  Daemon.prototype.setRate = function (vTo) {
830    var nRate = Number(vTo);
831    if (!isFinite(nRate) || nRate &lt; 1) { return; }
832    this.rate = nRate;
833    this.synchronize();
834  };
835 
836  Daemon.prototype.forcePosition = function (vTo) {
837    if (isFinite(vTo)) { this.INDEX = Math.round(Math.abs(vTo)); 
>} 
838  };
839 
840  Daemon.prototype.getDuration = function () {
841    return this.rate * this.length;
842  };
843 
844  Daemon.prototype.getDirection = function () {
845    return this.isAtEnd() !== this.BACKW;
846  };
847 
848  Daemon.prototype.getPosition = function () {
849    return this.INDEX;
850  };
851 
852    /* Instantaneous movement (synchronous). */
853 
854  Daemon.prototype.makeSteps = function (nHowMany, bReverse, bFor
>ce) { 
855    if (nHowMany === 0) { return true; }
856    if (isNaN(nHowMany)) { return false; }
857    var nIdx = 0, nLen = Math.round(Math.abs(nHowMany)), bContinu
>e = true, bBackw = nHowMany &gt; 0 === Boolean(bReverse); 
858    this.BACKW = bBackw;
859    for (nIdx; nIdx &lt; nLen &amp;&amp; bContinue; nIdx++) {
860      if (this.BACKW === bBackw &amp;&amp; this.isAtEnd()) {
861        if (this.reversals &gt; 0) { this.BACKW = bBackw = !this.
>BACKW; } 
862        else { break; }
863      }
864      bContinue = Daemon.forceCall(this) || bForce;
865    }
866    return nIdx === nLen;
867  };
868 
869  Daemon.prototype.skipTo = function (nIdx, bForce) {
870    /* Warnign: this method requires the Daemon.prototype.makeSte
>ps() method */ 
871    if (nIdx === this.INDEX) { return; }
872    if (isFinite(this.length) &amp;&amp; nIdx &lt; 0 || nIdx &gt;
> this.length) { return; } 
873 
874    var
875      bDirection = (this.INDEX !== 0 &amp;&amp; this.INDEX !== th
>is.length) === this.BACKW, 
876      bSuccess = this.makeSteps(this.INDEX - nIdx, true, bForce);
877 
878    if (this.INDEX !== 0 &amp;&amp; this.INDEX !== this.length) {
> this.BACKW = bDirection; } 
879    return bSuccess;
880  };
881 
882  Daemon.prototype.skipFor = function (nDelta, bForce) {
883    /* Warnign: this method requires the Daemon.prototype.makeSte
>ps() method */ 
884    return this.makeSteps(nDelta, this.isAtEnd() !== this.BACKW, 
>bForce); 
885  };
886 
887  Daemon.prototype.close = function (bReverse, bForce) {
888    /* Warnign: this method requires the Daemon.prototype.makeSte
>ps() method */ 
889    if (!isFinite(this.length)) { return false; }
890    this.pause();
891    this.reversals = 0;
892    return this.makeSteps(bReverse ? this.INDEX : this.length - t
>his.INDEX, bReverse, bForce); 
893  };
894 
895  Daemon.prototype.reclose = function (bForce) {
896    /* Warnign: this method requires the Daemon.prototype.makeSte
>ps() and Daemon.prototype.close() methods */ 
897    return this.close(this.isAtEnd() !== this.BACKW, bForce || fa
>lse); 
898  };
899 
900  /* Others */
901 
902  Daemon.prototype.restart = function () {
903    this.stop();
904    this.start();
905  };
906 
907  Daemon.prototype.loopUntil = function (vDate) {
908    if (!isFinite(this.length)) { return; }
909    var nTime = vDate.constructor === Date ? vDate.getTime() : is
>NaN(vDate) ? Date.parse(vDate) : vDate; 
910    if (isFinite(nTime) &amp;&amp; nTime &gt; Date.now()) {
911      this.reversals = Math.floor((nTime - Date.now() - (this.BAC
>KW ? this.INDEX : this.length - this.INDEX) * this.rate) / (this. 
>length * this.rate)); 
912      this.start(this.isAtEnd() !== this.BACKW);
913    }
914  };
915 
916  Daemon.prototype.spread = function (nTime) {
917    if (!isFinite(this.length)) { throw new TypeError("Daemon.pro
>totype.spread - the length is not a finite number. Use Daemon.pro 
>totype.adaptLength()."); } 
918    if (nTime &gt; 0) {
919      this.rate = Math.floor(nTime / this.length);
920      this.synchronize();
921    }
922    return this.rate;
923  };
924 
925  Daemon.prototype.adaptLength = function (nTime) {
926    this.length = Math.floor(nTime / this.rate);
927    return this.length;
928  };
929 
930  Daemon.prototype.playUntil = function (vDate) {
931    var nTime = vDate.constructor === Date ? vDate.getTime() : is
>NaN(vDate) ? Date.parse(vDate) : vDate; 
932    if (isFinite(nTime) &amp;&amp; nTime &gt; Date.now()) {
933      this.length = Math.floor((nTime - Date.now()) / this.rate) 
>+ this.INDEX; 
934      this.pause();
935      this.start();
936    }
937    return this.length;
938  };
939</pre>
940    </div>
941    <h2 id="Manual">
942      Manual
943    </h2>
944    <h3 id="The_constructor">
945      The constructor
946    </h3>
947    <h4 id="Syntax">
948      Syntax
949    </h4>
950    <pre class="syntaxbox">
951var myDaemon = new Daemon(<em>thisObject</em>, <em>callback</em>[
>, <em>length</em>[, <em>rate</em>[, <em>init</em>[, <em>onstart</ 
>em>]]]]); 
952</pre>
953    <h4 id="Description">
954      Description
955    </h4>
956    <p>
957      Constructs a JavaScript Object containing all informations 
>needed by an animation (like the <a href="/en-US/docs/JavaScript/ 
>Reference/Operators/this" title="en-US/docs/JavaScript/Reference/ 
>Operators/this"><code>this</code></a> object, the callback functi 
>on, the length, the frame-rate, the number of cycles, the <code>i 
>nit</code> and the <code>onstart</code> functions). 
958    </p>
959    <h4 id="Arguments">
960      Arguments
961    </h4>
962    <dl>
963      <dt>
964        <code>thisObject</code>
965      </dt>
966      <dd>
967        The <a href="/en-US/docs/JavaScript/Reference/Operators/t
>his" title="en-US/docs/JavaScript/Reference/Operators/this"><code 
>>this</code></a> object on which will be called the callback func 
>tion. It can be an <a href="/en-US/docs/JavaScript/Reference/Glob 
>al_Objects/Object" title="/en-US/docs/JavaScript/Reference/Global 
>_Objects/Object">object</a> or <code>null</code>. If is <code>nul 
>l</code>, the <code>this</code> object will point to the global < 
>code>Deamon.context</code> object (see below). 
968      </dd>
969      <dt>
970        <code>callback</code>
971      </dt>
972      <dd>
973        The function which will be invoked repeatedly. It will be
> called with three parameters: <code><em>index</em></code> (the i 
>terative index of each invocation), <code><em>length</em></code>  
>(the <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Num 
>ber" title="/en-US/docs/JavaScript/Reference/Global_Objects/Numbe 
>r">number</a> of total invocations assigned to the daemon - finit 
>e or <code><a href="/en-US/docs/JavaScript/Reference/Global_Objec 
>ts/Infinity" title="/en-US/docs/JavaScript/Reference/Global_Objec 
>ts/Infinity">Infinity</a></code>) and <code><em>backwards</em></c 
>ode> (a <a href="/en-US/docs/JavaScript/Reference/Global_Objects/ 
>Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/B 
>oolean">boolean</a> expressing whether the process is going backw 
>ards or not). It will be something like <code><em>callback</em>.c 
>all(<em>thisObject</em>, <em>index</em>, <em>length</em>, <em>bac 
>kwards</em>)</code>. If the <code><em>callback</em></code> functi 
>on returns a <code>false</code> value the daemon will be paused. 
974      </dd>
975      <dt>
976        <code>length</code> [optional]
977      </dt>
978      <dd>
979        The total number of invocations. It can be a positive int
>eger or <code><a href="/en-US/docs/JavaScript/Reference/Global_Ob 
>jects/Infinity" title="/en-US/docs/JavaScript/Reference/Global_Ob 
>jects/Infinity">Infinity</a></code>. The default value is <code>< 
>a href="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity" 
> title="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity" 
>>Infinity</a></code>. 
980      </dd>
981      <dt>
982        <code>rate</code> [optional]
983      </dt>
984      <dd>
985        The time lapse (in <a href="/en-US/docs/JavaScript/Refere
>nce/Global_Objects/Number" title="/en-US/docs/JavaScript/Referenc 
>e/Global_Objects/Number">number</a> of milliseconds) between each 
> invocation. The default value is 100. 
986      </dd>
987      <dt>
988        <code>init</code> [optional]
989      </dt>
990      <dd>
991        The <a href="/en-US/docs/JavaScript/Reference/Global_Obje
>cts/Function" title="/en-US/docs/JavaScript/Reference/Global_Obje 
>cts/Function">function</a> which will be synchronously invoked on 
>ce during the creation of the daemon and then assigned to the <co 
>de>onstop</code> property. It will be called with the same three  
>arguments of the <code>callback</code> function. They will also h 
>ave the same values of the last invocation of the <code>callback< 
>/code> function. 
992      </dd>
993      <dt>
994        <code>onstart</code>
995      </dt>
996      <dd>
997        The <a href="/en-US/docs/JavaScript/Reference/Global_Obje
>cts/Function" title="/en-US/docs/JavaScript/Reference/Global_Obje 
>cts/Function">function</a> which will be synchronously invoked on 
> whenever the <code>start</code> event occurs. It will be assigne 
>d to the <code>onstart</code> property. It will be called with th 
>ree arguments: <code><em>index</em></code> (the iterative index o 
>f each invocation), <code><em>length</em></code> (the <a href="/e 
>n-US/docs/JavaScript/Reference/Global_Objects/Number" title="/en- 
>US/docs/JavaScript/Reference/Global_Objects/Number">number</a> of 
> total invocations assigned to the daemon - finite or <code><a hr 
>ef="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity" tit 
>le="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity">Inf 
>inity</a></code>) and <code><em>backwards</em></code> (a <a href= 
>"/en-US/docs/JavaScript/Reference/Global_Objects/Boolean" title=" 
>/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">boolean< 
>/a> expressing whether the process is going backwards or not). 
998      </dd>
999    </dl>
1000    <h3 id="Daemon_global_object_properties">
1001      Daemon global object properties
1002    </h3>
1003    <dl>
1004      <dt>
1005        <code>Daemon.context</code>
1006      </dt>
1007      <dd>
1008        An empty <a href="/en-US/docs/JavaScript/Reference/Global
>_Objects/Object" title="/en-US/docs/JavaScript/Reference/Global_O 
>bjects/Object">object</a> used as default&nbsp;<a href="/en-US/do 
>cs/JavaScript/Reference/Operators/this" title="en-US/docs/JavaScr 
>ipt/Reference/Operators/this"><code>this</code></a> object when t 
>he <code><em>thisObject</em></code> is not specified during the c 
>onstruction of the daemon. If you want your <code><em>callback</e 
>m></code> function to be invoked with a <code>null</code> <a href 
>="/en-US/docs/JavaScript/Reference/Operators/this" title="en-US/d 
>ocs/JavaScript/Reference/Operators/this"><code>this</code></a> ob 
>ject you have to manually set the <code>owner</code> property to  
><code>null</code>. 
1009      </dd>
1010    </dl>
1011    <h3 id="Daemon_global_object_methods">
1012      Daemon global object methods
1013    </h3>
1014    <dl>
1015      <dt>
1016        <code>Daemon.forceCall(<em>daemonInstance</em>)</code>
1017      </dt>
1018      <dd>
1019        Forces a callback to the <code><em>daemonInstance</em>.ta
>sk</code> function regardless of the fact that the end has been r 
>eached or not. In any case the internal <code>INDEX</code> proper 
>ty will be increased/decreased (depending on the actual direction 
> of the daemon). 
1020      </dd>
1021      <dt>
1022        <code>Daemon.construct(<em>arrayOfArguments</em>)</code>
1023      </dt>
1024      <dd>
1025        Returns a new daemon constructed upon an <a href="/en-US/
>docs/JavaScript/Reference/Global_Objects/Array" title="/en-US/doc 
>s/JavaScript/Reference/Global_Objects/Array">array</a> of argumen 
>ts. It is very similar to the <a href="/en-US/docs/JavaScript/Ref 
>erence/Global_Objects/Function/apply" title="/en-US/docs/JavaScri 
>pt/Reference/Global_Objects/Function/apply"><code>Function.protot 
>ype.apply()</code></a> method. 
1026      </dd>
1027      <dt>
1028        <code>Daemon.buildAround(<em>context</em>[, <em>length</e
>m>[, <em>rate</em>]])</code> 
1029      </dt>
1030      <dd>
1031        Returns a new daemon built around a <code><em>context</em
>></code> object. The <code><em>context</em></code> object must co 
>intain *at least* a <code>perform</code> property pointing to wha 
>t you want to be the <code><em>callback</em></code> function of t 
>he daemon. It can also optionally contain a <code>create</code> a 
>nd a <code>prepare</code> properties pointing respectively to the 
> two functions you want to be the <code><em>init</em></code> and  
><code><em>onstart</em></code> functions of <code>Daemon</code> co 
>nstructor's arguments. The <code><em>context</em></code> object w 
>ill be also the <a href="/en-US/docs/JavaScript/Reference/Operato 
>rs/this" title="en-US/docs/JavaScript/Reference/Operators/this">< 
>code>this</code></a> object of your <code>callback</code> functio 
>n. So you can populate it with all your custom properties. and me 
>thods. The only required one property is <code>perform</code>. 
1032        <h5 id="Sample_usage.3A">
1033          Sample usage:
1034        </h5>
1035        <pre class="syntaxbox">
1036var myDaemon = Daemon.buildAround({
1037        "create": function () { [custom code] },  // optional
1038        "prepare": function () { [custom code] },  // optional
1039        "perform": function () { [custom code] },  // required
1040        "customProperty": [custom value],
1041        "myCustomMethod": function () { [custom code] },
1042        "anotherCustomProperty": [custom value],
1043        "etc.": "etc."
1044}, 30, 200);
1045</pre>
1046      </dd>
1047      <dt>
1048        <code>Daemon.incorporate(<em>function</em>)</code>
1049      </dt>
1050      <dd>
1051        The <code><em>function</em>.prototype</code> property wil
>l replaced with a <code>new Daemon()</code> object. The old repla 
>ced prototype will be preserved within a new property of the new  
><code><em>function</em>.prototype</code> object named <code>legac 
>y</code>. 
1052      </dd>
1053    </dl>
1054    <h3 id="Other_constructors">
1055      Other constructors
1056    </h3>
1057    <dl>
1058      <dt>
1059        <code>Daemon.blank()</code>
1060      </dt>
1061      <dd>
1062        Constructs a new instance of <code>Daemon</code> without 
>own properties. This constructor is useful in order to create you 
>r own *MySomeDaemon* constructors through the <code>MySomeDaemon. 
>prototype = new Daemon.blank();</code> assignment. 
1063      </dd>
1064      <dt>
1065        <code>Daemon.safe()</code> [optional module daemon-safe.j
>s] 
1066      </dt>
1067      <dd>
1068        <h5 id="Syntax">
1069          Syntax
1070        </h5>
1071        <pre class="syntaxbox">
1072var myDaemon = new Daemon.safe(<em>thisObject</em>, <em>callback<
>/em>[, <em>length</em>[, <em>rate</em>[, <em>init</em>[, <em>onst 
>art</em>]]]]); 
1073</pre>
1074        <h5 id="Description">
1075          Description
1076        </h5>
1077        <p>
1078          <code>Daemon.safe</code> is a clone of the Daemon const
>ructor based on recursive invocations of <a href="/en-US/docs/DOM 
>/window.setTimeout" title="/en-US/docs/DOM/window.setTimeout"><co 
>de>setTimeout</code></a> rather than on a single invocation of <a 
> href="/en-US/docs/DOM/window.setInterval" title="/en-US/docs/DOM 
>/window.setInterval"><code>setInterval</code></a>. See the <stron 
>g>daemon-safe.js</strong> module for details. 
1079        </p>
1080        <div class="note">
1081          <strong>Note:</strong> The <code>Daemon.safe</code> con
>structor is not part of the base system. 
1082        </div>
1083      </dd>
1084      <dt>
1085        <code>Daemon.safe.blank()</code> [optional module daemon-
>safe.js] 
1086      </dt>
1087      <dd>
1088        <p>
1089          The same as for <code>Daemon.blank</code>, but applied 
>to the <code>Daemon.safe</code> constructor. 
1090        </p>
1091        <div class="note">
1092          <strong>Note:</strong> The <code>Daemon.safe</code> con
>structor is not part of the base system. 
1093        </div>
1094      </dd>
1095    </dl>
1096    <h3 id="Daemon_instances_properties">
1097      Daemon instances properties
1098    </h3>
1099    <dl>
1100      <dt>
1101        <code>myDaemon.owner</code>
1102      </dt>
1103      <dd>
1104        The <a href="/en-US/docs/JavaScript/Reference/Operators/t
>his" title="en-US/docs/JavaScript/Reference/Operators/this"><code 
>>this</code></a> object on which is executed the daemon (read/wri 
>te). It can be an <a href="/en-US/docs/JavaScript/Reference/Globa 
>l_Objects/Object" title="/en-US/docs/JavaScript/Reference/Global_ 
>Objects/Object">object</a> or <code>null</code>. Its default valu 
>e is <code>Daemon.context</code>. 
1105      </dd>
1106      <dt>
1107        <code>myDaemon.task</code>
1108      </dt>
1109      <dd>
1110        The function which will be repeatedly invoked (read/write
>). It will be called with three arguments: <code><em>index</em></ 
>code> (the iterative index of each invocation), <code><em>length< 
>/em></code> (the <a href="/en-US/docs/JavaScript/Reference/Global 
>_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_O 
>bjects/Number">number</a> of total invocations assigned to the da 
>emon - finite or <code><a href="/en-US/docs/JavaScript/Reference/ 
>Global_Objects/Infinity" title="/en-US/docs/JavaScript/Reference/ 
>Global_Objects/Infinity">Infinity</a></code>) and <code><em>backw 
>ards</em></code> (a <a href="/en-US/docs/JavaScript/Reference/Glo 
>bal_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Glob 
>al_Objects/Boolean">boolean</a> expressing whether the process is 
> going backwards or not). See above. If the myDaemon.task functio 
>n returns a <code>false</code> value the daemon will be paused. 
1111      </dd>
1112      <dt>
1113        <code>myDaemon.length</code>
1114      </dt>
1115      <dd>
1116        The total <a href="/en-US/docs/JavaScript/Reference/Globa
>l_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_ 
>Objects/Number">number</a> of invocations. It can be a positive i 
>nteger or <code><a href="/en-US/docs/JavaScript/Reference/Global_ 
>Objects/Infinity" title="/en-US/docs/JavaScript/Reference/Global_ 
>Objects/Infinity">Infinity</a></code> (read/write). 
1117      </dd>
1118      <dt>
1119        <code>myDaemon.rate</code>
1120      </dt>
1121      <dd>
1122        The time lapse (in number of milliseconds) between each i
>nvocation (read/write). 
1123      </dd>
1124      <dt>
1125        <code>myDaemon.reversals</code>
1126      </dt>
1127      <dd>
1128        The <a href="/en-US/docs/JavaScript/Reference/Global_Obje
>cts/Number" title="/en-US/docs/JavaScript/Reference/Global_Object 
>s/Number">number</a> of times the daemon must be restarted (read/ 
>write). Set it to <code><a href="/en-US/docs/JavaScript/Reference 
>/Global_Objects/Infinity" title="/en-US/docs/JavaScript/Reference 
>/Global_Objects/Infinity">Infinity</a></code> for a “loop mode”. 
1129      </dd>
1130      <dt>
1131        <code>myDaemon.onstart</code>
1132      </dt>
1133      <dd>
1134        The <code>start</code> listener (read/write). It will be 
>called with three arguments: <code><em>index</em></code> (the ite 
>rative index of each invocation), <code><em>length</em></code> (t 
>he <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Numbe 
>r" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number" 
>>number</a> of total invocations assigned to the daemon - finite  
>or <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects 
>/Infinity" title="/en-US/docs/JavaScript/Reference/Global_Objects 
>/Infinity">Infinity</a></code>) and <code><em>backwards</em></cod 
>e> (a <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Bo 
>olean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boo 
>lean">boolean</a> expressing whether the process is going backwar 
>ds or not). 
1135      </dd>
1136      <dt>
1137        <code>myDaemon.onstop</code>
1138      </dt>
1139      <dd>
1140        <p>
1141          The <code>stop</code> listener (read/write). It will be
> called with three arguments: <code><em>index</em></code> (the it 
>erative index of each invocation), <code><em>length</em></code> ( 
>the <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Numb 
>er" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number 
>">number</a> of total invocations assigned to the daemon - finite 
> or <code><a href="/en-US/docs/JavaScript/Reference/Global_Object 
>s/Infinity" title="/en-US/docs/JavaScript/Reference/Global_Object 
>s/Infinity">Infinity</a></code>) and <code><em>backwards</em></co 
>de> (a <a href="/en-US/docs/JavaScript/Reference/Global_Objects/B 
>oolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Bo 
>olean">boolean</a> expressing whether the process is going backwa 
>rds or not). 
1142        </p>
1143        <div class="note">
1144          <strong>Note:</strong> The <code>stop()</code> method i
>s not part of the base system. 
1145        </div>
1146      </dd>
1147    </dl>
1148    <h3 id="Daemon_instances_methods">
1149      Daemon instances methods
1150    </h3>
1151    <dl>
1152      <dt>
1153        <code>myDaemon.isAtEnd()</code>
1154      </dt>
1155      <dd>
1156        Returns a <a href="/en-US/docs/JavaScript/Reference/Globa
>l_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global 
>_Objects/Boolean">boolean</a> expressing whether the daemon is at 
> the start/end position or not. 
1157      </dd>
1158      <dt>
1159        <code>myDaemon.synchronize()</code>
1160      </dt>
1161      <dd>
1162        Synchronize the timer of a started daemon with the time o
>f invocation of <code>myDaemon.synchronize()</code>. If the <code 
>>rate</code> property has been changed the daemon will be updated 
> with the new <code>rate</code> value. 
1163      </dd>
1164      <dt>
1165        <code>myDaemon.pause()</code>
1166      </dt>
1167      <dd>
1168        Pauses the daemon.
1169      </dd>
1170      <dt>
1171        <code>myDaemon.start([<em>backwards</em>])</code>
1172      </dt>
1173      <dd>
1174        Starts the daemon forward (index of each invocation incre
>asing) or backwards (index decreasing). 
1175      </dd>
1176    </dl>
1177    <h3 id="Additional_instances_methods_.5Boptional_module_daemo
>n-methods.js.5D"> 
1178      Additional instances methods [optional module daemon-method
>s.js] 
1179    </h3>
1180    <dl>
1181      <dt>
1182        <code>myDaemon.stop()</code>
1183      </dt>
1184      <dd>
1185        Stops the daemon. All original properties will be restore
>d. If it exists a <code>stop</code> listener it will be called wi 
>th three arguments: <code><em>index</em></code> (the iterative in 
>dex of each invocation), <code><em>length</em></code> (the <a hre 
>f="/en-US/docs/JavaScript/Reference/Global_Objects/Number" title= 
>"/en-US/docs/JavaScript/Reference/Global_Objects/Number">number</ 
>a> of total invocations assigned to the daemon - finite or <code> 
><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity 
>" title="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity 
>">Infinity</a></code>) and <code><em>backwards</em></code> (a <a  
>href="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean" ti 
>tle="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">boo 
>lean</a> expressing whether the process is going backwards or not 
>). 
1186      </dd>
1187      <dt>
1188        <code>myDaemon.syncStart([<em>backwards</em>])</code>
1189      </dt>
1190      <dd>
1191        Starts the daemon with the first callback synchronous.
1192      </dd>
1193      <dt>
1194        <code>myDaemon.play([<em>synchronous</em>])</code>
1195      </dt>
1196      <dd>
1197        Starts the daemon forward. If the daemon was running in t
>he same direction nothing will happen. If the argument is <code>t 
>rue</code> the first callback will be synchronous. 
1198      </dd>
1199      <dt>
1200        <code>myDaemon.reversePlay([<em>synchronous</em>])</code>
1201      </dt>
1202      <dd>
1203        Starts the daemon backwards. If the daemon was running in
> the same direction nothing will happen. If the argument is <code 
>>true</code> the first callback will be synchronous. 
1204      </dd>
1205      <dt>
1206        <code>myDaemon.move([<em>synchronous</em>[, <em>reversals
></em>[, <em>backwards</em>]]])</code> 
1207      </dt>
1208      <dd>
1209        Starts a daemon synchronously or not. If the <code><em>re
>versals</em></code> argument is specified the <code>myDaemon.reve 
>rsals</code> property will be setted on it. If the <code><em>back 
>wards</em></code> argument is specified the daemon will move forw 
>ard (<code>false</code>) or backwards (<em>true</em>). If it is n 
>ot specified the daemon will start in the same direction in which 
> it has been left. If the daemon was running in the same directio 
>n, only the <code>reversals</code> property will be possibly upda 
>ted. 
1210      </dd>
1211      <dt>
1212        <code>myDaemon.turn()</code>
1213      </dt>
1214      <dd>
1215        Inverts the direction of the daemon. The <code>reversals<
>/code> property will not be decreased. 
1216      </dd>
1217      <dt>
1218        <code>myDaemon.makeLoop()</code>
1219      </dt>
1220      <dd>
1221        Sets the <code>reversals</code> property equal to <code><
>a href="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity" 
> title="/en-US/docs/JavaScript/Reference/Global_Objects/Infinity" 
>>Infinity</a></code>. 
1222      </dd>
1223      <dt>
1224        <code>myDaemon.unmakeLoop()</code>
1225      </dt>
1226      <dd>
1227        Sets the <code>reversals</code> property equal to 0.
1228      </dd>
1229      <dt>
1230        <code>myDaemon.setRate(<em>milliseconds</em>)</code>
1231      </dt>
1232      <dd>
1233        Sets the time lapse between calls (in milliseconds). If t
>he daemon is running it will be immediately updated with the new  
>property. 
1234      </dd>
1235      <dt>
1236        <code>myDaemon.forcePosition(<em>index</em>)</code>
1237      </dt>
1238      <dd>
1239        Sets the internal <code>INDEX</code> property equal to th
>e <code><em>index</em></code> argument without any kind of contro 
>l about the range. 
1240      </dd>
1241      <dt>
1242        <code>myDaemon.getDuration()</code>
1243      </dt>
1244      <dd>
1245        Returns the duration of the daemon in milliseconds.
1246      </dd>
1247      <dt>
1248        <code>myDaemon.getPosition()</code>
1249      </dt>
1250      <dd>
1251        Returns the internal <code>INDEX</code> property.
1252      </dd>
1253      <dt>
1254        <code>myDaemon.makeSteps(<em>howMany</em>[, <em>backwards
></em>[, <em>force</em>]])</code> 
1255      </dt>
1256      <dd>
1257        Calls synchronously the <code><em>callback</em></code> fu
>nction <code><em>howMany</em></code> times. Forwards or backwards 
>. If the <code><em>force</em></code> argument is setted to true t 
>he possible <code>return false</code> of the <code><em>callback</ 
>em></code> function will be ignored. 
1258      </dd>
1259      <dt>
1260        <code>myDaemon.skipTo(<em>index</em>[, <em>force</em>])</
>code> 
1261      </dt>
1262      <dd>
1263        Calls synchronously the <code><em>callback</em></code> fu
>nction the number of times needed to reach the <code><em>index</e 
>m></code> position. If the <code><em>force</em></code> argument i 
>s setted to true the possible <code>return false</code> of the <c 
>ode><em>callback</em></code> function will be ignored. 
1264      </dd>
1265      <dt>
1266        <code>myDaemon.skipFor(<em>delta</em>[, <em>force</em>])<
>/code> 
1267      </dt>
1268      <dd>
1269        Calls synchronously the <code><em>callback</em></code> fu
>nction <code><em>howMany</em></code> times in the same direction  
>in which it was oriented. If the <code><em>force</em></code> argu 
>ment is setted to true the possible <code>return false</code> of  
>the <code><em>callback</em></code> function will be ignored. 
1270      </dd>
1271      <dt>
1272        <code>myDaemon.close([<em>backwards</em>, <em>force</em>]
>)</code> 
1273      </dt>
1274      <dd>
1275        Closes the daemon, doing <strong>synchronously</strong> a
>ll pending operations forward (index of each invocation increasin 
>g) or backwards (index decreasing). If the <code><em>force</em></ 
>code> argument is setted to true the possible <code>return false< 
>/code> of the <code><em>callback</em></code> function will be ign 
>ored. 
1276      </dd>
1277      <dt>
1278        <code>myDaemon.reclose([<em>force</em>])</code>
1279      </dt>
1280      <dd>
1281        Closes the daemon, doing <strong>synchronously</strong> a
>ll pending operations in the same direction in which is oriented  
>the daemon. If the <code><em>force</em></code> argument is setted 
> to true the possible <code>return false</code> of the <code><em> 
>callback</em></code> function will be ignored. 
1282      </dd>
1283      <dt>
1284        <code>myDaemon.restart()</code>
1285      </dt>
1286      <dd>
1287        Stops and restarts the daemon.
1288      </dd>
1289      <dt>
1290        <code>myDaemon.loopUntil(<em>date</em>)</code>
1291      </dt>
1292      <dd>
1293        Sets the reversals property in function of a future <code
>><em>date</em></code>. The <code><em>date</em></code> argument ca 
>n be a <a href="/en-US/docs/JavaScript/Reference/Global_Objects/D 
>ate" title="/en-US/docs/JavaScript/Reference/Global_Objects/Date" 
>><code>Date</code></a> object, a <a href="/en-US/docs/JavaScript/ 
>Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Re 
>ference/Global_Objects/String">string</a> expressing the date in  
>GMTString format, or a <a href="/en-US/docs/JavaScript/Reference/ 
>Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Gl 
>obal_Objects/Number">number</a> expressing the number of millisec 
>onds since January 1, 1970, 00:00:00 UTC. 
1294      </dd>
1295      <dt>
1296        <code>myDaemon.spread(<em>milliseconds</em>)</code>
1297      </dt>
1298      <dd>
1299        Sets the the total duration of the daemon in milliseconds
>. Only the <code>rate</code> property will be modified. 
1300      </dd>
1301      <dt>
1302        <code>myDaemon.adaptLength(<em>milliseconds</em>)</code>
1303      </dt>
1304      <dd>
1305        Sets the internal <code>length</code> property equal to <
>code><em>milliseconds</em></code> / <code>myDaemon.rate</code>. 
1306      </dd>
1307      <dt>
1308        <code>myDaemon.playUntil(<em>date</em>)</code>
1309      </dt>
1310      <dd>
1311        Starts the daemon forward and sets the the total duration
> of it in function of a future <code><em>date</em></code>. The <c 
>ode><em>date</em></code> argument can be a <a href="/en-US/docs/J 
>avaScript/Reference/Global_Objects/Date" title="/en-US/docs/JavaS 
>cript/Reference/Global_Objects/Date"><code>Date</code></a> object 
>, a <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Stri 
>ng" title="/en-US/docs/JavaScript/Reference/Global_Objects/String 
>">string</a> expressing the date in GMTString format, or a <a hre 
>f="/en-US/docs/JavaScript/Reference/Global_Objects/Number" title= 
>"/en-US/docs/JavaScript/Reference/Global_Objects/Number">number</ 
>a> expressing the number of milliseconds since January 1, 1970, 0 
>0:00:00 UTC. Only the length property will be modified. 
1312      </dd>
1313    </dl>
1314    <h2 id="Examples">
1315      Examples
1316    </h2>
1317    <h4 id="Example_.231.3A_A_standard_instantiation_.E2.80.93_ne
>w_Daemon()"> 
1318      Example #1: A standard instantiation – <code>new Daemon()</
>code> 
1319    </h4>
1320    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
1321      <pre class="brush: html">
1322&lt;!doctype html&gt;
1323&lt;html&gt;
1324&lt;head&gt;
1325&lt;meta http-equiv="Content-Type" content="text/html; charset=UT
>F-8" /&gt; 
1326&lt;title&gt;new Daemon(&amp;hellip;)&lt;/title&gt;
1327&lt;script type="text/javascript" src="fork.js"&gt;&lt;/script&gt
>; 
1328&lt;script type="text/javascript" src="daemon-methods.js"&gt;&lt;
>/script&gt; 
1329&lt;script type="text/javascript"&gt;
1330 
1331function perform (nIndex, nLength, bBackw) {
1332  // http://tyleregeto.com/text-animation-in-javascript
1333  for (var oLetter, nLetter = 0; nLetter &lt; aLetters.length; nL
>etter++) { 
1334    oLetter = aLetters[nLetter];
1335    var nDist = nMaxDist - nMaxDist * nIndex / nLength;
1336    oLetter.pos += 0.08;
1337    oLetter.elem.style.top = Math.sin(oLetter.pos) * nDist + "px"
>; 
1338    oLetter.elem.style.left = Math.cos(oLetter.pos) * nDist * 5 +
> "px"; 
1339  }
1340}
1341 
1342function prepare () {
1343  // build letters list
1344  // http://tyleregeto.com/text-animation-in-javascript
1345  this.textContent = "";
1346  aLetters.length = 0;  
1347  for (var oSpan, oLetter, nLetter = 0, nLen = sText.length; nLet
>ter &lt; nLen; nLetter++) { 
1348    oSpan = document.createElement("span");
1349    oSpan.textContent = sText[nLetter];
1350    oLetter = { "elem": oSpan, "parent": this };
1351    aLetters.push(oLetter);
1352    oLetter.pos = Math.random() * 50;
1353    oLetter.elem.style.position = "relative";
1354    this.appendChild(oSpan);
1355  }
1356}
1357 
1358var
1359  nMaxDist = 25, aLetters = [], sText = "Do you feel lucky, punk?
>", 
1360  oRecompose = new Daemon(document.createElement("p"), perform, 3
>0, 33, prepare); 
1361 
1362onload = function () {
1363  oRecompose.owner.id = "perform-me";
1364  document.body.appendChild(oRecompose.owner);
1365  oRecompose.play();
1366};
1367 
1368&lt;/script&gt;
1369 
1370&lt;style type="text/css"&gt;
1371body {
1372  font-family: monospace, sans-serif;
1373  background: #DDDDDD;
1374  overflow: hidden;
1375}
1376 
1377#perform-me {
1378  margin: 50px;
1379  font-size: 20px;
1380  line-height: 20px;
1381}
1382&lt;/style&gt;
1383&lt;/head&gt;
1384 
1385&lt;body&gt;
1386 
1387&lt;h1&gt;new Daemon(&lt;em&gt;@thisObject&lt;/em&gt;, &lt;em&gt;
>@callback&lt;/em&gt;[, &lt;em&gt;@length&lt;/em&gt;, &lt;em&gt;@r 
>ate&lt;/em&gt;, &lt;em&gt;@init&lt;/em&gt;, &lt;em&gt;@onstart&lt 
>;/em&gt;])&lt;/h1&gt; 
1388 
1389&lt;p&gt;&lt;button onclick="oRecompose.skipTo(11);"&gt;skipTo(11
>)&lt;/button&gt; 
1390&lt;button onclick="oRecompose.makeSteps(29);"&gt;makeSteps(29)&l
>t;/button&gt; 
1391&lt;button onclick="oRecompose.fixPosition(-13);"&gt;fixPosition(
>-13)&lt;/button&gt; 
1392&lt;button onclick="oRecompose.play();"&gt;play&lt;/button&gt;
1393&lt;button onclick="oRecompose.turn();"&gt;turn&lt;/button&gt;
1394&lt;button onclick="oRecompose.pause();"&gt;pause&lt;/button&gt;
1395&lt;button onclick="oRecompose.reversePlay();"&gt;reversePlay&lt;
>/button&gt; 
1396&lt;button onclick="oRecompose.reversals = 2;alert('changed');"&g
>t;two reversals&lt;/button&gt; 
1397&lt;button onclick="oRecompose.makeLoop();alert('changed');"&gt;m
>akeLoop&lt;/button&gt; 
1398&lt;button onclick="oRecompose.unmakeLoop();alert('changed');"&gt
>;unmakeLoop&lt;/button&gt; 
1399&lt;button onclick="oRecompose.close();"&gt;close&lt;/button&gt;
1400&lt;button onclick="oRecompose.reclose();"&gt;reclose&lt;/button&
>gt;&lt;br /&gt; 
1401frame rate: &lt;input type="text" id="vello" value="33" style="wi
>dth: 40px;" onkeypress="return event.charCode===0||/\d/.test(Stri 
>ng.fromCharCode(event.charCode));" onkeyup="if(isFinite(this.valu 
>e)&amp;&amp;Number(this.value)&gt;0){oRecompose.setRate(this.valu 
>e);}" /&gt;&lt;/p&gt; 
1402 
1403&lt;/body&gt;
1404&lt;/html&gt;
1405</pre>
1406    </div>
1407    <h4 id="Example_.232.3A_A_practical_instantiation_.E2.80.93_D
>aemon.buildAround()"> 
1408      Example #2: A practical instantiation – <code>Daemon.buildA
>round()</code> 
1409    </h4>
1410    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
1411      <pre class="brush: html">
1412&lt;!doctype html&gt;
1413&lt;html&gt;
1414&lt;head&gt;
1415&lt;meta http-equiv="Content-Type" content="text/html; charset=UT
>F-8" /&gt; 
1416&lt;title&gt;Daemon.buildAround(&amp;hellip;)&lt;/title&gt;
1417&lt;script type="text/javascript" src="fork.js"&gt;&lt;/script&gt
>; 
1418&lt;script type="text/javascript" src="daemon-methods.js"&gt;&lt;
>/script&gt; 
1419&lt;script type="text/javascript"&gt;
1420 
1421 /*\
1422 |*|
1423 |*|  :: Daemon.buildAround(@context[, @length, @rate]) ::
1424 |*|
1425 |*|  Returns a new daemon built around a @context object. The @c
>ontext object must cointain *at least* 
1426 |*|  a "perform" property pointing to what you want to be the @c
>allback function of the daemon. 
1427 |*|  It can also optionally contain a "create" and a "prepare" p
>roperties pointing respectively to the 
1428 |*|  two functions you want to be the @init and @onstart functio
>ns of Daemon constructor's arguments. 
1429 |*|  The @context object will be also the *this* object of your 
>callback function. So you can populate 
1430 |*|  it with any custom properties and methods. The only require
>d one property is "perform". 
1431 |*|     
1432 |*|    Sample usage:
1433 |*|
1434 |*|      var myDaemon = Daemon.buildAround({
1435 |*|        "customProperty": [custom value],
1436 |*|        "myCustomMethod": function () { [custom code] },
1437 |*|        "anotherCustomProperty": [custom value],
1438 |*|        "etc.": "etc."
1439 |*|        "create": function () { [custom code] },  // optional
1440 |*|        "prepare": function () { [custom code] },  // optiona
>l 
1441 |*|        "perform": function () { [custom code] },  // require
>d 
1442 |*|      }, 30, 200);
1443 |*|
1444 \*/
1445 
1446var sText = "Do you feel lucky, punk?", oUnhide = Daemon.buildAro
>und({ 
1447  // http://tyleregeto.com/text-animation-in-javascript
1448  "letters": [],
1449  "numletters": 0,
1450  "clock": 0,
1451  "interval": 0.0,
1452  "delta": 33,
1453  "letters": [],
1454  "pool": ["0","1","2","3","4","5","6","7","8","9"],
1455  "target": document.createElement("p"),
1456  "create": function () {
1457    // build letters list
1458    this.target.textContent = "";
1459    this.letters.length = 0;
1460    for (var oSpan, oLetter, nLetter = 0, nLen = sText.length; nL
>etter &lt; nLen; nLetter++) { 
1461      oSpan = document.createElement("span");
1462      oSpan.textContent = sText[nLetter];
1463      oLetter = { "elem": oSpan, "parent": this.target };
1464      this.letters.push(oLetter);
1465      oLetter.index = this.numletters;
1466      oLetter.elem.style.position = "relative";
1467      oLetter.val = oLetter.elem.textContent;
1468      this.numletters++;
1469      this.target.appendChild(oSpan);
1470    }
1471  },
1472  "perform": function (nIndex, nLength, bBackw) {
1473    for (var oLetter, nLetter = 0; nLetter &lt; this.letters.leng
>th; nLetter++) { 
1474      oLetter = this.letters[nLetter];
1475      if (nLength &lt; nIndex &amp;&amp; this.clock + this.delta 
>&lt; this.interval) { 
1476        clock += this.delta;
1477        return;
1478      }
1479      this.clock = 0;
1480      oLetter.elem.textContent = nIndex / nLength - oLetter.index
> / this.numletters &gt;= 0 ? 
1481        oLetter.val
1482        : this.pool[parseInt(Math.random() * this.pool.length)];
1483    }
1484  }
1485}, 30, 33);
1486 
1487onload = function () {
1488  oUnhide.owner.target.id = "animate-me";
1489  document.body.appendChild(oUnhide.owner.target);
1490  oUnhide.play();
1491};
1492 
1493&lt;/script&gt;
1494 
1495&lt;style type="text/css"&gt;
1496body {
1497  font-family: monospace, sans-serif;
1498  background: #DDDDDD;
1499  overflow: hidden;
1500}
1501 
1502#animate-me {
1503  margin: 50px;
1504  font-size: 20px;
1505  line-height: 20px;
1506}
1507&lt;/style&gt;
1508&lt;/head&gt;
1509 
1510&lt;body&gt;
1511 
1512&lt;h1&gt;Daemon.buildAround()&lt;/h1&gt;
1513 
1514&lt;p&gt;&lt;button onclick="oUnhide.skipTo(11);"&gt;skipTo(11)&l
>t;/button&gt; 
1515&lt;button onclick="oUnhide.makeSteps(29);"&gt;makeSteps(29)&lt;/
>button&gt; 
1516&lt;button onclick="oUnhide.fixPosition(-13);"&gt;fixPosition(-13
>)&lt;/button&gt; 
1517&lt;button onclick="oUnhide.play();"&gt;play&lt;/button&gt;
1518&lt;button onclick="oUnhide.turn();"&gt;turn&lt;/button&gt;
1519&lt;button onclick="oUnhide.pause();"&gt;pause&lt;/button&gt;
1520&lt;button onclick="oUnhide.reversePlay();"&gt;reversePlay&lt;/bu
>tton&gt; 
1521&lt;button onclick="oUnhide.reversals = 2;alert('changed');"&gt;t
>wo reversals&lt;/button&gt; 
1522&lt;button onclick="oUnhide.makeLoop();alert('changed');"&gt;make
>Loop&lt;/button&gt; 
1523&lt;button onclick="oUnhide.unmakeLoop();alert('changed');"&gt;un
>makeLoop&lt;/button&gt; 
1524&lt;button onclick="oUnhide.close();"&gt;close&lt;/button&gt;
1525&lt;button onclick="oUnhide.reclose();"&gt;reclose&lt;/button&gt;
>&lt;br /&gt; 
1526frame rate: &lt;input type="text" id="vello" value="33" style="wi
>dth: 40px;" onkeypress="return event.charCode===0||/\d/.test(Stri 
>ng.fromCharCode(event.charCode));" onkeyup="if(isFinite(this.valu 
>e)&amp;&amp;Number(this.value)&gt;0){oUnhide.setRate(this.value); 
>}" /&gt;&lt;/p&gt; 
1527 
1528&lt;/body&gt;
1529&lt;/html&gt;
1530</pre>
1531    </div>
1532    <h4 id="Example_.233.3A_A_safe_(without_setInterval)_instanti
>ation_.E2.80.93_new_Daemon.safe()"> 
1533      Example #3: A <em>safe</em> (without <code>setInterval</cod
>e>) instantiation – <code>new Daemon.safe()</code> 
1534    </h4>
1535    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
1536      <pre class="brush: html">
1537&lt;!doctype html&gt;
1538&lt;html&gt;
1539&lt;head&gt;
1540&lt;meta http-equiv="Content-Type" content="text/html; charset=UT
>F-8" /&gt; 
1541&lt;title&gt;new Daemon.safe(&amp;hellip;)&lt;/title&gt;
1542&lt;script type="text/javascript" src="fork.js"&gt;&lt;/script&gt
>; 
1543&lt;script type="text/javascript" src="daemon-safe.js"&gt;&lt;/sc
>ript&gt; 
1544&lt;script type="text/javascript" src="daemon-methods.js"&gt;&lt;
>/script&gt; 
1545&lt;script type="text/javascript"&gt;
1546 
1547function perform (nIndex, nLength, bBackw) {
1548  // http://tyleregeto.com/text-animation-in-javascript
1549  for (var oLetter, nLetter = 0; nLetter &lt; aLetters.length; nL
>etter++) { 
1550    oLetter = aLetters[nLetter];
1551    var nDist = nMaxDist - nMaxDist * nIndex / nLength;
1552    oLetter.pos += 0.08;
1553    oLetter.elem.style.top = Math.sin(oLetter.pos) * nDist + "px"
>; 
1554    oLetter.elem.style.left = Math.cos(oLetter.pos) * nDist * 5 +
> "px"; 
1555  }
1556}
1557 
1558function prepare () {
1559  // build letters list
1560  // http://tyleregeto.com/text-animation-in-javascript
1561  this.textContent = "";
1562  aLetters.length = 0;  
1563  for (var oSpan, oLetter, nLetter = 0, nLen = sText.length; nLet
>ter &lt; nLen; nLetter++) { 
1564    oSpan = document.createElement("span");
1565    oSpan.textContent = sText[nLetter];
1566    oLetter = { "elem": oSpan, "parent": this };
1567    aLetters.push(oLetter);
1568    oLetter.pos = Math.random() * 50;
1569    oLetter.elem.style.position = "relative";
1570    this.appendChild(oSpan);
1571  }
1572}
1573 
1574var
1575  nMaxDist = 25, aLetters = [], sText = "Do you feel lucky, punk?
>", 
1576  oRecompose = new Daemon.safe(document.createElement("p"), perfo
>rm, 30, 33, prepare); 
1577 
1578onload = function () {
1579  oRecompose.owner.id = "perform-me";
1580  document.body.appendChild(oRecompose.owner);
1581  oRecompose.play();
1582};
1583 
1584&lt;/script&gt;
1585 
1586&lt;style type="text/css"&gt;
1587body {
1588  font-family: monospace, sans-serif;
1589  background: #DDDDDD;
1590  overflow: hidden;
1591}
1592 
1593#perform-me {
1594  margin: 50px;
1595  font-size: 20px;
1596  line-height: 20px;
1597}
1598&lt;/style&gt;
1599&lt;/head&gt;
1600 
1601&lt;body&gt;
1602 
1603&lt;h1&gt;new Daemon.safe(&lt;em&gt;@thisObject&lt;/em&gt;, &lt;e
>m&gt;@callback&lt;/em&gt;[, &lt;em&gt;@length&lt;/em&gt;, &lt;em& 
>gt;@rate&lt;/em&gt;, &lt;em&gt;@init&lt;/em&gt;, &lt;em&gt;@onsta 
>rt&lt;/em&gt;])&lt;/h1&gt; 
1604 
1605&lt;p&gt;&lt;button onclick="oRecompose.skipTo(11);"&gt;skipTo(11
>)&lt;/button&gt; 
1606&lt;button onclick="oRecompose.makeSteps(29);"&gt;makeSteps(29)&l
>t;/button&gt; 
1607&lt;button onclick="oRecompose.fixPosition(-13);"&gt;fixPosition(
>-13)&lt;/button&gt; 
1608&lt;button onclick="oRecompose.play();"&gt;play&lt;/button&gt;
1609&lt;button onclick="oRecompose.turn();"&gt;turn&lt;/button&gt;
1610&lt;button onclick="oRecompose.pause();"&gt;pause&lt;/button&gt;
1611&lt;button onclick="oRecompose.reversePlay();"&gt;reversePlay&lt;
>/button&gt; 
1612&lt;button onclick="oRecompose.reversals = 2;alert('changed');"&g
>t;two reversals&lt;/button&gt; 
1613&lt;button onclick="oRecompose.makeLoop();alert('changed');"&gt;m
>akeLoop&lt;/button&gt; 
1614&lt;button onclick="oRecompose.unmakeLoop();alert('changed');"&gt
>;unmakeLoop&lt;/button&gt; 
1615&lt;button onclick="oRecompose.close();"&gt;close&lt;/button&gt;
1616&lt;button onclick="oRecompose.reclose();"&gt;reclose&lt;/button&
>gt;&lt;br /&gt; 
1617frame rate: &lt;input type="text" id="vello" value="33" style="wi
>dth: 40px;" onkeypress="return event.charCode===0||/\d/.test(Stri 
>ng.fromCharCode(event.charCode));" onkeyup="if(isFinite(this.valu 
>e)&amp;&amp;Number(this.value)&gt;0){oRecompose.setRate(this.valu 
>e);}" /&gt;&lt;/p&gt; 
1618 
1619&lt;/body&gt;
1620&lt;/html&gt;
1621</pre>
1622    </div>
1623    <h4 id="Example_.234.3A_A_practical_and_safe_(without_setInte
>rval)_instantiation_.E2.80.93_Daemon.safe.buildAround()"> 
1624      Example #4: A practical and <em>safe</em> (without <code>se
>tInterval</code>) instantiation – <code>Daemon.safe.buildAround() 
></code> 
1625    </h4>
1626    <div style="height: 400px; margin-bottom: 12px; overflow: aut
>o;"> 
1627      <pre class="brush: html">
1628&lt;!doctype html&gt;
1629&lt;html&gt;
1630&lt;head&gt;
1631&lt;meta http-equiv="Content-Type" content="text/html; charset=UT
>F-8" /&gt; 
1632&lt;title&gt;Daemon.safe.buildAround(&amp;hellip;)&lt;/title&gt;
1633&lt;script type="text/javascript" src="fork.js"&gt;&lt;/script&gt
>; 
1634&lt;script type="text/javascript" src="daemon-safe.js"&gt;&lt;/sc
>ript&gt; 
1635&lt;script type="text/javascript" src="daemon-methods.js"&gt;&lt;
>/script&gt; 
1636&lt;script type="text/javascript"&gt;
1637 
1638 /*\
1639 |*|
1640 |*|  :: Daemon.safe.buildAround(@context[, @length, @rate]) ::
1641 |*|
1642 |*|  Returns a new daemon built around a @context object. The @c
>ontext object must cointain *at least* 
1643 |*|  a "perform" property pointing to what you want to be the @c
>allback function of the daemon. 
1644 |*|  It can also optionally contain a "create" and a "prepare" p
>roperties pointing respectively to the 
1645 |*|  two functions you want to be the @init and @onstart functio
>ns of Daemon constructor's arguments. 
1646 |*|  The @context object will be also the *this* object of your 
>callback function. So you can populate 
1647 |*|  it with any custom properties and methods. The only require
>d one property is "perform". 
1648 |*|     
1649 |*|    Sample usage:
1650 |*|
1651 |*|      var myDaemon = Daemon.safe.buildAround({
1652 |*|        "customProperty": [custom value],
1653 |*|        "myCustomMethod": function () { [custom code] },
1654 |*|        "anotherCustomProperty": [custom value],
1655 |*|        "etc.": "etc."
1656 |*|        "create": function () { [custom code] },  // optional
1657 |*|        "prepare": function () { [custom code] },  // optiona
>l 
1658 |*|        "perform": function () { [custom code] },  // require
>d 
1659 |*|      }, 30, 200);
1660 |*|
1661 \*/
1662 
1663var sText = "Do you feel lucky, punk?", oUnhide = Daemon.safe.bui
>ldAround({ 
1664  // http://tyleregeto.com/text-animation-in-javascript
1665  "letters": [],
1666  "numletters": 0,
1667  "clock": 0,
1668  "interval": 0.0,
1669  "delta": 33,
1670  "letters": [],
1671  "pool": ["0","1","2","3","4","5","6","7","8","9"],
1672  "target": document.createElement("p"),
1673  "create": function () {
1674    // build letters list
1675    this.target.textContent = "";
1676    this.letters.length = 0;
1677    for (var oSpan, oLetter, nLetter = 0, nLen = sText.length; nL
>etter &lt; nLen; nLetter++) { 
1678      oSpan = document.createElement("span");
1679      oSpan.textContent = sText[nLetter];
1680      oLetter = { "elem": oSpan, "parent": this.target };
1681      this.letters.push(oLetter);
1682      oLetter.index = this.numletters;
1683      oLetter.elem.style.position = "relative";
1684      oLetter.val = oLetter.elem.textContent;
1685      this.numletters++;
1686      this.target.appendChild(oSpan);
1687    }
1688  },
1689  "perform": function (nIndex, nLength, bBackw) {
1690    for (var oLetter, nLetter = 0; nLetter &lt; this.letters.leng
>th; nLetter++) { 
1691      oLetter = this.letters[nLetter];
1692      if (nLength &lt; nIndex &amp;&amp; this.clock + this.delta 
>&lt; this.interval) { 
1693        clock += this.delta;
1694        return;
1695      }
1696      this.clock = 0;
1697      oLetter.elem.textContent = nIndex / nLength - oLetter.index
> / this.numletters &gt;= 0 ? 
1698        oLetter.val
1699        : this.pool[parseInt(Math.random() * this.pool.length)];
1700    }
1701  }
1702}, 30, 33);
1703 
1704onload = function () {
1705  oUnhide.owner.target.id = "animate-me";
1706  document.body.appendChild(oUnhide.owner.target);
1707  oUnhide.play();
1708};
1709 
1710&lt;/script&gt;
1711 
1712&lt;style type="text/css"&gt;
1713body {
1714  font-family: monospace, sans-serif;
1715  background: #DDDDDD;
1716  overflow: hidden;
1717}
1718 
1719#animate-me {
1720  margin: 50px;
1721  font-size: 20px;
1722  line-height: 20px;
1723}
1724&lt;/style&gt;
1725&lt;/head&gt;
1726 
1727&lt;body&gt;
1728 
1729&lt;h1&gt;Daemon.safe.buildAround()&lt;/h1&gt;
1730 
1731&lt;p&gt;&lt;button onclick="oUnhide.skipTo(11);"&gt;skipTo(11)&l
>t;/button&gt; 
1732&lt;button onclick="oUnhide.makeSteps(29);"&gt;makeSteps(29)&lt;/
>button&gt; 
1733&lt;button onclick="oUnhide.fixPosition(-13);"&gt;fixPosition(-13
>)&lt;/button&gt; 
1734&lt;button onclick="oUnhide.play();"&gt;play&lt;/button&gt;
1735&lt;button onclick="oUnhide.turn();"&gt;turn&lt;/button&gt;
1736&lt;button onclick="oUnhide.pause();"&gt;pause&lt;/button&gt;
1737&lt;button onclick="oUnhide.reversePlay();"&gt;reversePlay&lt;/bu
>tton&gt; 
1738&lt;button onclick="oUnhide.reversals = 2;alert('changed');"&gt;t
>wo reversals&lt;/button&gt; 
1739&lt;button onclick="oUnhide.makeLoop();alert('changed');"&gt;make
>Loop&lt;/button&gt; 
1740&lt;button onclick="oUnhide.unmakeLoop();alert('changed');"&gt;un
>makeLoop&lt;/button&gt; 
1741&lt;button onclick="oUnhide.close();"&gt;close&lt;/button&gt;
1742&lt;button onclick="oUnhide.reclose();"&gt;reclose&lt;/button&gt;
>&lt;br /&gt; 
1743frame rate: &lt;input type="text" id="vello" value="33" style="wi
>dth: 40px;" onkeypress="return event.charCode===0||/\d/.test(Stri 
>ng.fromCharCode(event.charCode));" onkeyup="if(isFinite(this.valu 
>e)&amp;&amp;Number(this.value)&gt;0){oUnhide.setRate(this.value); 
>}" /&gt;&lt;/p&gt; 
1744 
1745&lt;/body&gt;
1746&lt;/html&gt;
1747</pre>
1748    </div>
n1754        <a href="/en-US/docs/JavaScript/Timers" title="/en-US/docn15        <a href="/User:fusionchess" title="User:fusionchess">My p
>s/JavaScript/Timers">JavaScript timers</a>,>age</a>
n1757        <a href="https://developer.mozilla.org/en-US/docs/DOM/winn18        <a href="/profiles/fusionchess" title="profiles/fusionche
>dow.setTimeout" title="/en-US/docs/DOM/window.setTimeout"><code>s>ss">My profile</a>
>etTimeout()</code></a>, 
n1760        <a href="https://developer.mozilla.org/en-US/docs/DOM/winn21        <a href="/User:fusionchess/ToDo" title="User:fusionchess/
>dow.setInterval" title="/en-US/docs/DOM/window.setInterval"><code>ToDo">My TODO List</a>
>>setInterval()</code></a>, 
t1763        <a href="https://developer.mozilla.org/en-US/docs/DOM/wint24        <a href="/User:fusionchess/Sandbox" title="User:fusionche
>dow.clearTimeout" title="/en-US/docs/DOM/window.clearTimeout"><co>ss/Sandbox">My Sandbox</a>
>de>clearTimeout()</code></a>, 
1764      </li>
1765      <li>
1766        <a href="https://developer.mozilla.org/en-US/docs/DOM/win
>dow.clearInterval" title="/en-US/docs/DOM/window.clearTimeout"><c 
>ode>clearInterval()</code></a>, 
1767      </li>
1768      <li>
1769        <a href="https://developer.mozilla.org/en-US/docs/DOM/win
>dow.requestAnimationFrame" title="en-US/docs/DOM/window.requestAn 
>imationFrame">requestAnimationFrame()</a>. 

Back to History