Added: jquery/jquery.alternation.js
===================================================================
--- jquery/jquery.alternation.js	                        (rev 0)
+++ jquery/jquery.alternation.js	2007-02-14 16:33:03 UTC (rev 2)
@@ -0,0 +1,107 @@
+/*
+**  jquery.alternation.js -- jQuery plugin for DOM element alternation
+**  Copyright (c) 2007 Ralf S. Engelschall <rse@engelschall.com> 
+**  Copyright (c) 2006 Torsten Baldes
+**  Copyright (c) 2006 Matt Oakes
+**
+**  $LastChangedDate$
+**  $Rev$
+*/
+
+/*
+ *  <div class="alternation"> 
+ *      <div>content 1</div>
+ *      <div>content 2</div>
+ *      <div>content 3</div>
+ *  </div>
+ *
+ *  $('.alternation').alternation({
+ *      alternation: alternation type: "sequence" or "random"            (default: 'sequence')
+ *      timeout:     alternation time (in ms)                            (default: 2000)
+ *      animation:   animation type: "fade" or "slide"                   (default: "fade")
+ *      speed:       animation speed (in ms or "slow", "normal", "fast") (default: "normal")
+ *      class:       container element CSS class                         (default: "alternation") 
+ *      height:      container element CSS height                        (default: "auto")
+ *  });
+ */
+
+(function($) {
+
+    /* jQuery dynamic object method */
+    $.fn.alternation = function(options) {
+        return this.each(function() {   
+            $.alternation(this, options);
+        });
+    };
+
+    /* jQuery static function */
+    $.alternation = function(container, options) {
+        var settings = {
+            'alternation': 'sequence',
+            'timeout':     2000,
+            'animation':   'fade',
+            'speed':       'normal',
+            'class':       'alternation',
+            'height':      'auto'
+        };
+        if (options)
+            $.extend(settings, options);
+        var elements = $(container).children();
+        if (elements.length > 1) {
+            $(container).css('position', 'relative');
+            $(container).css('height', settings["height"]);
+            $(container).addClass(settings["class"]);
+            for (var i = 0; i < elements.length; i++) {
+                $(elements[i]).css('z-index', String(elements.length-i));
+                $(elements[i]).css('position', 'absolute');
+                $(elements[i]).hide();
+            };
+            if (settings["alternation"] == "sequence") {
+                setTimeout(function() {
+                    $.alternation._next(elements, settings, 1, 0);
+                }, settings.timeout);
+                $(elements[0]).show();
+            } else if (settings["alternation"] == "random") {
+                setTimeout(function() {
+                    do {
+                        current = Math.floor(Math.random() * elements.length);
+                    } while (current == 0)
+                    $.alternation._next(elements, settings, current, 0);
+                }, settings.timeout);
+                $(elements[0]).show();
+            } else
+                alert('jQuery: alternation: parameter "alternation" must either be "sequence" or "random"');
+        }
+    }
+
+    /* jQuery static function */
+    $.alternation._next = function(elements, settings, current, last) {
+        if (settings["animation"] == 'slide') {
+            $(elements[last]).slideUp(settings.speed,
+                $(elements[current]).slideDown(settings.speed));
+        } else if (settings["animation"] == 'fade') {
+            $(elements[last]).fadeOut(settings.speed);
+            $(elements[current]).fadeIn(settings.speed);
+        } else
+            alert('jQuery: alternation: parameter "animation" must either be "slide" or "fade"');
+        if (settings["alternation"] == "sequence") {
+            if ((current + 1) < elements.length) {
+                current = current + 1;
+                last = current - 1;
+            } else {
+                current = 0;
+                last = elements.length - 1;
+            }
+        } else if (settings["alternation"] == "random") {
+            last = current;
+            while (current == last)
+                current = Math.floor(Math.random() * elements.length);
+        } else
+            alert('jQuery: alternation: parameter "alternation" must either be "sequence" or "random"');
+        setTimeout((function() {
+            $.alternation._next(elements, settings, current, last);
+        }), settings.timeout);
+    };
+
+})(jQuery);
+

Added: jquery/jquery.schedule.js
===================================================================
--- jquery/jquery.schedule.js	                        (rev 0)
+++ jquery/jquery.schedule.js	2007-02-14 16:33:03 UTC (rev 2)
@@ -0,0 +1,206 @@
+/*
+**  jquery.schedule.js -- jQuery plugin for scheduled/deferred actions
+**  Copyright (c) 2007 Ralf S. Engelschall <rse@engelschall.com> 
+**
+**  $LastChangedDate$
+**  $Rev$
+*/
+
+/*
+ *  <div id="button">TEST BUTTON</div>
+ *  <div id="test"></div>
+ *
+ *  <script type="text/javascript">
+ *     $(document).ready(
+ *     function(){
+ *         $('#button').click(function () {
+ *             $(this).css("color", "blue").schedule(2000, function (x) {
+ *                 $(this).css("color", "red");
+ *                 $("#test").html("test: x = " + x);
+ *             }, 42);
+ *         });
+ *     });
+ *  </script>
+ */
+
+/*  object constructor  */
+jQuery.scheduler = function () {
+    this.bucket = {};
+    return;
+};
+
+/*  object methods  */
+jQuery.scheduler.prototype = {
+    /*  schedule a task  */
+    schedule: function () {
+        /*  schedule context with default parameters */
+        var ctx = {
+            "_scheduler": this,         /* internal: back-reference to scheduler object */
+            "_handle":    null,         /* internal: unique handle of low-level task */
+            "id":         null,         /* unique identifier of high-level schedule */
+            "time":       1000,         /* time in milliseconds after which the task is run */
+            "repeat":     false,        /* whether schedule should be automatically repeated */
+            "protect":    false,        /* whether schedule should be protected from double scheduling */
+            "obj":        null,         /* function context object ("this") */
+            "func":       function(){}, /* function to call */
+            "args":       []            /* function arguments to pass */
+        };
+
+        /*  helper function for portable checking whether something is a function  */
+	    var isfn = function (fn) {
+            return (
+                   !!fn
+                && typeof fn != "string"
+                && typeof fn[0] == "undefined"
+                && RegExp("function", "i").test(fn + "")
+            );
+	    };
+
+        /*  parse arguments into context parameters (part 1/2):
+            support the flexible way of an associated array */
+        var i = 0;
+        if (typeof arguments[i] == "object") {
+            for (var option in arguments[i])
+                if (   typeof ctx[option] != "undefined"
+                    && option.substr(0, 1) != "_")
+                    ctx[option] = arguments[i][option];
+            i++;
+        }
+
+        /*  parse arguments into context parameters (part 2/2):
+            support: schedule([time [, repeat], ]{{obj, methodname} | func}[, arg, ...]); */
+        if (typeof arguments[i] == "number")
+            ctx["time"] = arguments[i++];
+        if (typeof arguments[i] == "boolean")
+            ctx["repeat"] = arguments[i++];
+        if (typeof arguments[i] == "boolean")
+            ctx["protect"] = arguments[i++];
+        if (   typeof arguments[i] == "object"
+            && typeof arguments[i+1] == "string"
+            && isfn(arguments[i][arguments[i+1]])) {
+            ctx["obj"] = arguments[i++];
+            ctx["func"] = arguments[i++];
+        }
+        else if (typeof arguments[i] != "undefined")
+            ctx["func"] = arguments[i++];
+        while (typeof arguments[i] != "undefined")
+            ctx["args"].push(arguments[i++]);
+
+        /*  determine unique identifier of task  */
+        if (ctx["id"] == null)
+            ctx["id"] = (  String(ctx["repeat"])  + ":"
+                         + String(ctx["protect"]) + ":"
+                         + String(ctx["time"])    + ":"
+                         + String(ctx["obj"])     + ":"
+                         + String(ctx["func"])    + ":"
+                         + String(ctx["args"])         );
+
+        /*  optionally protect from duplicate calls  */
+        if (ctx["protect"])
+            if (typeof this.bucket[ctx["id"]] != "undefined")
+                return this.bucket[ctx["id"]];
+
+        /*  support execution of methods by name and arbitrary scripts  */
+        if (!isfn(ctx["func"])) {
+            if (   ctx["obj"] != null
+                && typeof ctx["obj"] == "object"
+	            && typeof ctx["func"] == "string"
+                && isfn(ctx["obj"][ctx["func"]]))
+                /*  method by name  */
+                ctx["func"] = ctx["obj"][ctx["func"]];
+            else
+                /*  arbitrary script  */
+                ctx["func"] = eval("function () { " + ctx["func"] + " }");
+        }
+
+        /*  pass-through to internal scheduling operation  */
+        ctx["_handle"] = this._schedule(ctx);
+
+        /*  store context into bucket of scheduler object  */
+        this.bucket[ctx["id"]] = ctx;
+
+        /*  return context  */
+        return ctx;
+    },
+
+    /*  re-schedule a task  */
+    reschedule: function (ctx) {
+        if (typeof ctx == "string")
+            ctx = this.bucket[ctx];
+
+        /*  pass-through to internal scheduling operation  */
+        ctx["_handle"] = this._schedule(ctx);
+
+        /*  return context  */
+        return ctx;
+    },
+
+    /*  internal scheduling operation  */
+    _schedule: function (ctx) {
+        /*  closure to act as the call trampoline function  */
+        var trampoline = function () {
+            /*  jump into function  */
+            var obj = (ctx["obj"] != null ? ctx["obj"] : ctx);
+            (ctx["func"]).apply(obj, ctx["args"]);
+
+            /*  either repeat scheduling and keep in bucket or
+                just stop scheduling and delete from scheduler bucket  */
+            if (   /* not cancelled from inside... */
+                   typeof (ctx["_scheduler"]).bucket[ctx["id"]] != "undefined"
+                && /* ...and repeating requested */
+                   ctx["repeat"])
+                (ctx["_scheduler"])._schedule(ctx);
+            else
+                delete (ctx["_scheduler"]).bucket[ctx["id"]];
+        }
+
+        /*  schedule task and return handle  */
+        return setTimeout(trampoline, ctx["time"]);
+    },
+
+    /*  cancel a scheduled task  */
+    cancel: function (ctx) {
+        if (typeof ctx == "string")
+            ctx = this.bucket[ctx];
+
+        /*  cancel scheduled task  */
+        if (typeof ctx == "object") {
+            clearTimeout(ctx["_handle"]);
+            delete this.bucket[ctx["id"]];
+        }
+    }
+};
+
+/* ============================== */
+
+/* integrate a global instance of the scheduler into the global jQuery object */
+jQuery.extend({
+    scheduler$: new jQuery.scheduler(),
+	schedule:   function () { return jQuery.scheduler$.schedule.apply  (jQuery.scheduler$, arguments) },
+	reschedule: function () { return jQuery.scheduler$.reschedule.apply(jQuery.scheduler$, arguments) },
+	cancel:     function () { return jQuery.scheduler$.cancel.apply    (jQuery.scheduler$, arguments) }
+});
+
+/* integrate scheduling convinience method into all jQuery objects */
+jQuery.fn.extend({
+	schedule: function () {
+        var a = arguments;
+		return this.each(function () {
+            var time = a[0];
+            var func = a[1];
+            var args = [];
+            for (var i = 2; i < a.length; i++)
+                args.push(a[i]);
+            return jQuery.schedule({
+                id:      this,
+                repeat:  false,
+                protect: false,
+                time:    time,
+                obj:     this,
+                func:    func,
+                args:    args
+            });
+		});
+	}
+});
+