html5forms-rails 0.1.3

data/vendor/assets/javascripts/html5forms/dev/timer.js

@@ -0,0 +1,137 @@
+/*
+   *  Timer.js - object oriented friendly timeout object
+   *  From code originally found on:
+   *
+   *  http://www.codingforums.com/archive/index.php/index.php?t-10531.html
+   * 
+   *  The problems with the setTimeout and setInterval functions 
+   *  provided in Javascript are twofold. First, you can't call a local 
+   *  object method without losing your scope, and second, you can't pass 
+   *  objects to the function, since the function call is implemented as a string.
+   *  
+   *  The Timer class solves these difficulties by employing a static array 
+   *  to store the parent object and function arguments until the function is 
+   *  called.
+   *  
+   *  This class is provided as-is and pro bono, so go ahead and muck with 
+   *  it if you see things that could be done better.
+   *  
+   *  Thanks to WA for giving me the idea for this (albeit indirectly)!
+   *  
+   *  Updated 4/18/2003: Footprint decreased, minor code improvements.
+   *  Updated 5/3/2003: Minor comment clarification; no code changes.
+   *  Updated 5/10/2003: Minor code improvements.
+ */
+
+
+// The constructor should be called with
+// the parent object (optional, defaults to window).
+
+function 
+Timer ()
+{
+  this.obj = (arguments.length) ? arguments[0] : window;
+  return this;
+}
+
+// The set functions should be called with:
+// - The name of the object method (as a string) (required)
+// - The millisecond delay (required)
+// - Any number of extra arguments, which will all be
+// passed to the method when it is evaluated.
+
+Timer.prototype.setInterval = function (func, msec)
+{
+  var i = Timer.getNew ();
+  var t = Timer.buildCall (this.obj, i, arguments);
+  Timer.set[i].timer = window.setInterval (t, msec);
+  return i;
+}
+Timer.prototype.setTimeout = function (func, msec)
+{
+  var i = Timer.getNew ();
+  Timer.buildCall (this.obj, i, arguments);
+  Timer.set[i].timer = window.setTimeout ("Timer.callOnce(" + i + ");", msec);
+  return i;
+}
+
+// The clear functions should be called with
+// the return value from the equivalent set function.
+
+Timer.prototype.clearInterval = function (i)
+{
+  if (!Timer.set[i])
+    return;
+  window.clearInterval (Timer.set[i].timer);
+  Timer.set[i] = null;
+}
+Timer.prototype.clearTimeout = function (i)
+{
+  if (!Timer.set[i])
+    return;
+  window.clearTimeout (Timer.set[i].timer);
+  Timer.set[i] = null;
+}
+
+// Private data
+
+Timer.set = new Array ();
+Timer.buildCall = function (obj, i, args)
+{
+  var t = "";
+  Timer.set[i] = new Array ();
+  if (obj != window)
+    {
+      Timer.set[i].obj = obj;
+      t = "Timer.set[" + i + "].obj.";
+    }
+  t += args[0] + "(";
+  if (args.length > 2)
+    {
+      Timer.set[i][0] = args[2];
+      t += "Timer.set[" + i + "][0]";
+      for (var j = 1; (j + 2) < args.length; j++)
+	{
+	  Timer.set[i][j] = args[j + 2];
+	  t += ", Timer.set[" + i + "][" + j + "]";
+	}
+    }
+  t += ");";
+  Timer.set[i].call = t;
+  return t;
+}
+Timer.callOnce = function (i)
+{
+  if (!Timer.set[i])
+    return;
+  eval (Timer.set[i].call);
+  Timer.set[i] = null;
+}
+Timer.getNew = function ()
+{
+  var i = 0;
+  while (Timer.set[i])
+    i++;
+  return i;
+}
+/* 
+Here 's an example of the code in action:
+function Ticker ()
+{
+  this.count = 0;
+  this.timer = new Timer (this);
+}
+Ticker.prototype.tick = function (d)
+{
+  this.count += d;
+  window.status = "" + this.count;
+  this.timer.setTimeout ("tick", 1000, d);
+}
+
+window.onload = function ()
+{
+  var ticker = new Ticker ();
+  ticker.tick (1);
+}
+
+*/