1	/*!
2	 * jQuery UI Touch Punch 0.2.2
3	 *
4	 * Copyright 2011, Dave Furfero
5	 * Dual licensed under the MIT or GPL Version 2 licenses.
6	 *
7	 * Depends:
8	 *  jquery.ui.widget.js
9	 *  jquery.ui.mouse.js
10	 */
11	(function ($) {
12	
13	  // Detect touch support
14	  $.support.touch = 'ontouchend' in document;
15	
16	  // Ignore browsers without touch support
17	  if (!$.support.touch) {
18	    return;
19	  }
20	
21	  var mouseProto = $.ui.mouse.prototype,
22	      _mouseInit = mouseProto._mouseInit,
23	      touchHandled;
24	
25	  /**
26	   * Simulate a mouse event based on a corresponding touch event
27	   * @param {Object} event A touch event
28	   * @param {String} simulatedType The corresponding mouse event
29	   */
30	  function simulateMouseEvent (event, simulatedType) {
31	
32	    // Ignore multi-touch events
33	    if (event.originalEvent.touches.length > 1) {
34	      return;
35	    }
36	
37	    event.preventDefault();
38	
39	    var touch = event.originalEvent.changedTouches[0],
40	        simulatedEvent = document.createEvent('MouseEvents');
41	   
42	    // Initialize the simulated mouse event using the touch event's coordinates
43	    simulatedEvent.initMouseEvent(
44	      simulatedType,    // type
45	      true,             // bubbles                   
46	      true,             // cancelable                 
47	      window,           // view                       
48	      1,                // detail                     
49	      touch.screenX,    // screenX                   
50	      touch.screenY,    // screenY                   
51	      touch.clientX,    // clientX                   
52	      touch.clientY,    // clientY                   
53	      false,            // ctrlKey                   
54	      false,            // altKey                     
55	      false,            // shiftKey                   
56	      false,            // metaKey                   
57	      0,                // button                     
58	      null              // relatedTarget             
59	    );
60	
61	    // Dispatch the simulated event to the target element
62	    event.target.dispatchEvent(simulatedEvent);
63	  }
64	
65	  /**
66	   * Handle the jQuery UI widget's touchstart events
67	   * @param {Object} event The widget element's touchstart event
68	   */
69	  mouseProto._touchStart = function (event) {
70	
71	    var self = this;
72	
73	    // Ignore the event if another widget is already being handled
74	    if (touchHandled || !self._mouseCapture(event.originalEvent.changedTouches[0])) {
75	      return;
76	    }
77	
78	    // Set the flag to prevent other widgets from inheriting the touch event
79	    touchHandled = true;
80	
81	    // Track movement to determine if interaction was a click
82	    self._touchMoved = false;
83	
84	    // Simulate the mouseover event
85	    simulateMouseEvent(event, 'mouseover');
86	
87	    // Simulate the mousemove event
88	    simulateMouseEvent(event, 'mousemove');
89	
90	    // Simulate the mousedown event
91	    simulateMouseEvent(event, 'mousedown');
92	  };
93	
94	  /**
95	   * Handle the jQuery UI widget's touchmove events
96	   * @param {Object} event The document's touchmove event
97	   */
98	  mouseProto._touchMove = function (event) {
99	
100	    // Ignore event if not handled
101	    if (!touchHandled) {
102	      return;
103	    }
104	
105	    // Interaction was not a click
106	    this._touchMoved = true;
107	
108	    // Simulate the mousemove event
109	    simulateMouseEvent(event, 'mousemove');
110	  };
111	
112	  /**
113	   * Handle the jQuery UI widget's touchend events
114	   * @param {Object} event The document's touchend event
115	   */
116	  mouseProto._touchEnd = function (event) {
117	
118	    // Ignore event if not handled
119	    if (!touchHandled) {
120	      return;
121	    }
122	
123	    // Simulate the mouseup event
124	    simulateMouseEvent(event, 'mouseup');
125	
126	    // Simulate the mouseout event
127	    simulateMouseEvent(event, 'mouseout');
128	
129	    // If the touch interaction did not move, it should trigger a click
130	    if (!this._touchMoved) {
131	
132	      // Simulate the click event
133	      simulateMouseEvent(event, 'click');
134	    }
135	
136	    // Unset the flag to allow other widgets to inherit the touch event
137	    touchHandled = false;
138	  };
139	
140	  /**
141	   * A duck punch of the $.ui.mouse _mouseInit method to support touch events.
142	   * This method extends the widget with bound touch event handlers that
143	   * translate touch events to mouse events and pass them to the widget's
144	   * original mouse event handling methods.
145	   */
146	  mouseProto._mouseInit = function () {
147	   
148	    var self = this;
149	
150	    // Delegate the touch handlers to the widget's element
151	    self.element
152	      .bind('touchstart', $.proxy(self, '_touchStart'))
153	      .bind('touchmove', $.proxy(self, '_touchMove'))
154	      .bind('touchend', $.proxy(self, '_touchEnd'));
155	
156	    // Call the original $.ui.mouse init method
157	    _mouseInit.call(self);
158	  };
159	
160	})(jQuery);

1	/*
2	**  jquery.schedule.js -- jQuery plugin for scheduled/deferred actions
3	**  Copyright (c) 2007 Ralf S. Engelschall <rse@engelschall.com>
4	**  Licensed under GPL <http://www.gnu.org/licenses/gpl.txt>
5	**
6	**  $LastChangedDate$
7	**  $LastChangedRevision$
8	*/
9	
10	/*
11	 *  <div id="button">TEST BUTTON</div>
12	 *  <div id="test"></div>
13	 *
14	 *  <script type="text/javascript">
15	 *     $(document).ready(
16	 *     function(){
17	 *         $('#button').click(function () {
18	 *             $(this).css("color", "blue").schedule(2000, function (x) {
19	 *                 $(this).css("color", "red");
20	 *                 $("#test").html("test: x = " + x);
21	 *             }, 42);
22	 *         });
23	 *     });
24	 *  </script>
25	 */
26	
27	(function($) {
28	
29	    /*  object constructor  */
30	    $.scheduler = function () {
31	        this.bucket = {};
32	        return;
33	    };
34	
35	    /*  object methods  */
36	    $.scheduler.prototype = {
37	        /*  schedule a task  */
38	        schedule: function () {
39	            /*  schedule context with default parameters */
40	            var ctx = {
41	                "id":         null,         /* unique identifier of high-level schedule */
42	                "time":       1000,         /* time in milliseconds after which the task is run */
43	                "repeat":     false,        /* whether schedule should be automatically repeated */
44	                "protect":    false,        /* whether schedule should be protected from double scheduling */
45	                "obj":        null,         /* function context object ("this") */
46	                "func":       function(){}, /* function to call */
47	                "args":       []            /* function arguments to pass */
48	            };
49	
50	            /*  helper function: portable checking whether something is a function  */
51	            function _isfn (fn) {
52	                return (
53	                       !!fn
54	                    && typeof fn != "string"
55	                    && typeof fn[0] == "undefined"
56	                    && RegExp("function", "i").test(fn + "")
57	                );
58	            };
59	           
60	            /*  parse arguments into context parameters (part 1/4):
61	                detect an override object (special case to support jQuery method) */
62	            var i = 0;
63	            var override = false;
64	            if (typeof arguments[i] == "object" && arguments.length > 1) {
65	                override = true;
66	                i++;
67	            }
68	
69	            /*  parse arguments into context parameters (part 2/4):
70	                support the flexible way of an associated array */
71	            if (typeof arguments[i] == "object") {
72	                for (var option in arguments[i])
73	                    if (typeof ctx[option] != "undefined")
74	                        ctx[option] = arguments[i][option];
75	                i++;
76	            }
77	
78	            /*  parse arguments into context parameters (part 3/4):
79	                support: schedule([time [, repeat], ]{{obj, methodname} | func}[, arg, ...]); */
80	            if (   typeof arguments[i] == "number"
81	                || (   typeof arguments[i] == "string" 
82	                    && arguments[i].match(RegExp("^[0-9]+[smhdw]$"))))
83	                ctx["time"] = arguments[i++];
84	            if (typeof arguments[i] == "boolean")
85	                ctx["repeat"] = arguments[i++];
86	            if (typeof arguments[i] == "boolean")
87	                ctx["protect"] = arguments[i++];
88	            if (   typeof arguments[i] == "object"
89	                && typeof arguments[i+1] == "string"
90	                && _isfn(arguments[i][arguments[i+1]])) {
91	                ctx["obj"] = arguments[i++];
92	                ctx["func"] = arguments[i++];
93	            }
94	            else if (   typeof arguments[i] != "undefined"
95	                     && (   _isfn(arguments[i]) 
96	                         || typeof arguments[i] == "string"))
97	                ctx["func"] = arguments[i++];
98	            while (typeof arguments[i] != "undefined")
99	                ctx["args"].push(arguments[i++]);
100	
101	            /*  parse arguments into context parameters (part 4/4):
102	                apply parameters from override object */
103	            if (override) {
104	                if (typeof arguments[1] == "object") {
105	                    for (var option in arguments[0])
106	                        if (   typeof ctx[option] != "undefined"
107	                            && typeof arguments[1][option] == "undefined")
108	                            ctx[option] = arguments[0][option];
109	                }
110	                else {
111	                    for (var option in arguments[0])
112	                        if (typeof ctx[option] != "undefined")
113	                            ctx[option] = arguments[0][option];
114	                }
115	                i++;
116	            }
117	
118	            /*  annotate context with internals */
119	            ctx["_scheduler"] = this; /* internal: back-reference to scheduler object */
120	            ctx["_handle"]    = null; /* internal: unique handle of low-level task */
121	
122	            /*  determine time value in milliseconds */
123	            var match = String(ctx["time"]).match(RegExp("^([0-9]+)([smhdw])$"));
124	            if (match && match[0] != "undefined" && match[1] != "undefined")
125	                ctx["time"] = String(parseInt(match[1]) *
126	                    { s: 1000, m: 1000*60, h: 1000*60*60,
127	                      d: 1000*60*60*24, w: 1000*60*60*24*7 }[match[2]]);
128	
129	            /*  determine unique identifier of task  */
130	            if (ctx["id"] == null)
131	                ctx["id"] = (  String(ctx["repeat"])  + ":"
132	                             + String(ctx["protect"]) + ":"
133	                             + String(ctx["time"])    + ":"
134	                             + String(ctx["obj"])     + ":"
135	                             + String(ctx["func"])    + ":"
136	                             + String(ctx["args"])         );
137	
138	            /*  optionally protect from duplicate calls  */
139	            if (ctx["protect"])
140	                if (typeof this.bucket[ctx["id"]] != "undefined")
141	                    return this.bucket[ctx["id"]];
142	
143	            /*  support execution of methods by name and arbitrary scripts  */
144	            if (!_isfn(ctx["func"])) {
145	                if (   ctx["obj"] != null
146	                    && typeof ctx["obj"] == "object"
147	                    && typeof ctx["func"] == "string"
148	                    && _isfn(ctx["obj"][ctx["func"]]))
149	                    /*  method by name  */
150	                    ctx["func"] = ctx["obj"][ctx["func"]];
151	                else
152	                    /*  arbitrary script  */
153	                    ctx["func"] = eval("function () { " + ctx["func"] + " }");
154	            }
155	
156	            /*  pass-through to internal scheduling operation  */
157	            ctx["_handle"] = this._schedule(ctx);
158	
159	            /*  store context into bucket of scheduler object  */
160	            this.bucket[ctx["id"]] = ctx;
161	
162	            /*  return context  */
163	            return ctx;
164	        },
165	
166	        /*  re-schedule a task  */
167	        reschedule: function (ctx) {
168	            if (typeof ctx == "string")
169	                ctx = this.bucket[ctx];
170	
171	            /*  pass-through to internal scheduling operation  */
172	            ctx["_handle"] = this._schedule(ctx);
173	
174	            /*  return context  */
175	            return ctx;
176	        },
177	
178	        /*  internal scheduling operation  */
179	        _schedule: function (ctx) {
180	            /*  closure to act as the call trampoline function  */
181	            var trampoline = function () {
182	                /*  jump into function  */
183	                var obj = (ctx["obj"] != null ? ctx["obj"] : ctx);
184	                (ctx["func"]).apply(obj, ctx["args"]);
185	
186	                /*  either repeat scheduling and keep in bucket or
187	                    just stop scheduling and delete from scheduler bucket  */
188	                if (   /* not cancelled from inside... */
189	                       typeof (ctx["_scheduler"]).bucket[ctx["id"]] != "undefined"
190	                    && /* ...and repeating requested */
191	                       ctx["repeat"])
192	                    (ctx["_scheduler"])._schedule(ctx);
193	                else
194	                    delete (ctx["_scheduler"]).bucket[ctx["id"]];
195	            };
196	
197	            /*  schedule task and return handle  */
198	            return setTimeout(trampoline, ctx["time"]);
199	        },
200	
201	        /*  cancel a scheduled task  */
202	        cancel: function (ctx) {
203	            if (typeof ctx == "string")
204	                ctx = this.bucket[ctx];
205	
206	            /*  cancel scheduled task  */
207	            if (typeof ctx == "object") {
208	                clearTimeout(ctx["_handle"]);
209	                delete this.bucket[ctx["id"]];
210	            }
211	        }
212	    };
213	
214	    /* integrate a global instance of the scheduler into the global jQuery object */
215	    $.extend({
216	        scheduler$: new $.scheduler(),
217	        schedule:   function () { return $.scheduler$.schedule.apply  ($.scheduler$, arguments) },
218	        reschedule: function () { return $.scheduler$.reschedule.apply($.scheduler$, arguments) },
219	        cancel:     function () { return $.scheduler$.cancel.apply    ($.scheduler$, arguments) }
220	    });
221	
222	    /* integrate scheduling convinience method into all jQuery objects */
223	    $.fn.extend({
224	        schedule: function () {
225	            var a = [ {} ];
226	            for (var i = 0; i < arguments.length; i++)
227	                a.push(arguments[i]);
228	            return this.each(function () {
229	                a[0] = { "id": this, "obj": this };
230	                return $.schedule.apply($, a);
231	            });
232	        }
233	    });
234	
235	})(jQuery);
236	
237	/*
238	**  jquery.schedule.js -- jQuery plugin for scheduled/deferred actions
239	**  Copyright (c) 2007 Ralf S. Engelschall <rse@engelschall.com>
240	**  Licensed under GPL <http://www.gnu.org/licenses/gpl.txt>
241	**
242	**  $LastChangedDate$
243	**  $LastChangedRevision$
244	*/
245	
246	/*
247	 *  <div id="button">TEST BUTTON</div>
248	 *  <div id="test"></div>
249	 *
250	 *  <script type="text/javascript">
251	 *     $(document).ready(
252	 *     function(){
253	 *         $('#button').click(function () {
254	 *             $(this).css("color", "blue").schedule(2000, function (x) {
255	 *                 $(this).css("color", "red");
256	 *                 $("#test").html("test: x = " + x);
257	 *             }, 42);
258	 *         });
259	 *     });
260	 *  </script>
261	 */
262	
263	(function($) {
264	
265	    /*  object constructor  */
266	    $.scheduler = function () {
267	        this.bucket = {};
268	        return;
269	    };
270	
271	    /*  object methods  */
272	    $.scheduler.prototype = {
273	        /*  schedule a task  */
274	        schedule: function () {
275	            /*  schedule context with default parameters */
276	            var ctx = {
277	                "id":         null,         /* unique identifier of high-level schedule */
278	                "time":       1000,         /* time in milliseconds after which the task is run */
279	                "repeat":     false,        /* whether schedule should be automatically repeated */
280	                "protect":    false,        /* whether schedule should be protected from double scheduling */
281	                "obj":        null,         /* function context object ("this") */
282	                "func":       function(){}, /* function to call */
283	                "args":       []            /* function arguments to pass */
284	            };
285	
286	            /*  helper function: portable checking whether something is a function  */
287	            function _isfn (fn) {
288	                return (
289	                       !!fn
290	                    && typeof fn != "string"
291	                    && typeof fn[0] == "undefined"
292	                    && RegExp("function", "i").test(fn + "")
293	                );
294	            };
295	           
296	            /*  parse arguments into context parameters (part 1/4):
297	                detect an override object (special case to support jQuery method) */
298	            var i = 0;
299	            var override = false;
300	            if (typeof arguments[i] == "object" && arguments.length > 1) {
301	                override = true;
302	                i++;
303	            }
304	
305	            /*  parse arguments into context parameters (part 2/4):
306	                support the flexible way of an associated array */
307	            if (typeof arguments[i] == "object") {
308	                for (var option in arguments[i])
309	                    if (typeof ctx[option] != "undefined")
310	                        ctx[option] = arguments[i][option];
311	                i++;
312	            }
313	
314	            /*  parse arguments into context parameters (part 3/4):
315	                support: schedule([time [, repeat], ]{{obj, methodname} | func}[, arg, ...]); */
316	            if (   typeof arguments[i] == "number"
317	                || (   typeof arguments[i] == "string" 
318	                    && arguments[i].match(RegExp("^[0-9]+[smhdw]$"))))
319	                ctx["time"] = arguments[i++];
320	            if (typeof arguments[i] == "boolean")
321	                ctx["repeat"] = arguments[i++];
322	            if (typeof arguments[i] == "boolean")
323	                ctx["protect"] = arguments[i++];
324	            if (   typeof arguments[i] == "object"
325	                && typeof arguments[i+1] == "string"
326	                && _isfn(arguments[i][arguments[i+1]])) {
327	                ctx["obj"] = arguments[i++];
328	                ctx["func"] = arguments[i++];
329	            }
330	            else if (   typeof arguments[i] != "undefined"
331	                     && (   _isfn(arguments[i]) 
332	                         || typeof arguments[i] == "string"))
333	                ctx["func"] = arguments[i++];
334	            while (typeof arguments[i] != "undefined")
335	                ctx["args"].push(arguments[i++]);
336	
337	            /*  parse arguments into context parameters (part 4/4):
338	                apply parameters from override object */
339	            if (override) {
340	                if (typeof arguments[1] == "object") {
341	                    for (var option in arguments[0])
342	                        if (   typeof ctx[option] != "undefined"
343	                            && typeof arguments[1][option] == "undefined")
344	                            ctx[option] = arguments[0][option];
345	                }
346	                else {
347	                    for (var option in arguments[0])
348	                        if (typeof ctx[option] != "undefined")
349	                            ctx[option] = arguments[0][option];
350	                }
351	                i++;
352	            }
353	
354	            /*  annotate context with internals */
355	            ctx["_scheduler"] = this; /* internal: back-reference to scheduler object */
356	            ctx["_handle"]    = null; /* internal: unique handle of low-level task */
357	
358	            /*  determine time value in milliseconds */
359	            var match = String(ctx["time"]).match(RegExp("^([0-9]+)([smhdw])$"));
360	            if (match && match[0] != "undefined" && match[1] != "undefined")
361	                ctx["time"] = String(parseInt(match[1]) *
362	                    { s: 1000, m: 1000*60, h: 1000*60*60,
363	                      d: 1000*60*60*24, w: 1000*60*60*24*7 }[match[2]]);
364	
365	            /*  determine unique identifier of task  */
366	            if (ctx["id"] == null)
367	                ctx["id"] = (  String(ctx["repeat"])  + ":"
368	                             + String(ctx["protect"]) + ":"
369	                             + String(ctx["time"])    + ":"
370	                             + String(ctx["obj"])     + ":"
371	                             + String(ctx["func"])    + ":"
372	                             + String(ctx["args"])         );
373	
374	            /*  optionally protect from duplicate calls  */
375	            if (ctx["protect"])
376	                if (typeof this.bucket[ctx["id"]] != "undefined")
377	                    return this.bucket[ctx["id"]];
378	
379	            /*  support execution of methods by name and arbitrary scripts  */
380	            if (!_isfn(ctx["func"])) {
381	                if (   ctx["obj"] != null
382	                    && typeof ctx["obj"] == "object"
383	                    && typeof ctx["func"] == "string"
384	                    && _isfn(ctx["obj"][ctx["func"]]))
385	                    /*  method by name  */
386	                    ctx["func"] = ctx["obj"][ctx["func"]];
387	                else
388	                    /*  arbitrary script  */
389	                    ctx["func"] = eval("function () { " + ctx["func"] + " }");
390	            }
391	
392	            /*  pass-through to internal scheduling operation  */
393	            ctx["_handle"] = this._schedule(ctx);
394	
395	            /*  store context into bucket of scheduler object  */
396	            this.bucket[ctx["id"]] = ctx;
397	
398	            /*  return context  */
399	            return ctx;
400	        },
401	
402	        /*  re-schedule a task  */
403	        reschedule: function (ctx) {
404	            if (typeof ctx == "string")
405	                ctx = this.bucket[ctx];
406	
407	            /*  pass-through to internal scheduling operation  */
408	            ctx["_handle"] = this._schedule(ctx);
409	
410	            /*  return context  */
411	            return ctx;
412	        },
413	
414	        /*  internal scheduling operation  */
415	        _schedule: function (ctx) {
416	            /*  closure to act as the call trampoline function  */
417	            var trampoline = function () {
418	                /*  jump into function  */
419	                var obj = (ctx["obj"] != null ? ctx["obj"] : ctx);
420	                (ctx["func"]).apply(obj, ctx["args"]);
421	
422	                /*  either repeat scheduling and keep in bucket or
423	                    just stop scheduling and delete from scheduler bucket  */
424	                if (   /* not cancelled from inside... */
425	                       typeof (ctx["_scheduler"]).bucket[ctx["id"]] != "undefined"
426	                    && /* ...and repeating requested */
427	                       ctx["repeat"])
428	                    (ctx["_scheduler"])._schedule(ctx);
429	                else
430	                    delete (ctx["_scheduler"]).bucket[ctx["id"]];
431	            };
432	
433	            /*  schedule task and return handle  */
434	            return setTimeout(trampoline, ctx["time"]);
435	        },
436	
437	        /*  cancel a scheduled task  */
438	        cancel: function (ctx) {
439	            if (typeof ctx == "string")
440	                ctx = this.bucket[ctx];
441	
442	            /*  cancel scheduled task  */
443	            if (typeof ctx == "object") {
444	                clearTimeout(ctx["_handle"]);
445	                delete this.bucket[ctx["id"]];
446	            }
447	        }
448	    };
449	
450	    /* integrate a global instance of the scheduler into the global jQuery object */
451	    $.extend({
452	        scheduler$: new $.scheduler(),
453	        schedule:   function () { return $.scheduler$.schedule.apply  ($.scheduler$, arguments) },
454	        reschedule: function () { return $.scheduler$.reschedule.apply($.scheduler$, arguments) },
455	        cancel:     function () { return $.scheduler$.cancel.apply    ($.scheduler$, arguments) }
456	    });
457	
458	    /* integrate scheduling convinience method into all jQuery objects */
459	    $.fn.extend({
460	        schedule: function () {
461	            var a = [ {} ];
462	            for (var i = 0; i < arguments.length; i++)
463	                a.push(arguments[i]);
464	            return this.each(function () {
465	                a[0] = { "id": this, "obj": this };
466	                return $.schedule.apply($, a);
467	            });
468	        }
469	    });
470	
471	})(jQuery);
472	
473	/*
474	**  jquery.schedule.js -- jQuery plugin for scheduled/deferred actions
475	**  Copyright (c) 2007 Ralf S. Engelschall <rse@engelschall.com>
476	**  Licensed under GPL <http://www.gnu.org/licenses/gpl.txt>
477	**
478	**  $LastChangedDate$
479	**  $LastChangedRevision$
480	*/
481	
482	/*
483	 *  <div id="button">TEST BUTTON</div>
484	 *  <div id="test"></div>
485	 *
486	 *  <script type="text/javascript">
487	 *     $(document).ready(
488	 *     function(){
489	 *         $('#button').click(function () {
490	 *             $(this).css("color", "blue").schedule(2000, function (x) {
491	 *                 $(this).css("color", "red");
492	 *                 $("#test").html("test: x = " + x);
493	 *             }, 42);
494	 *         });
495	 *     });
496	 *  </script>
497	 */
498	
499	(function($) {
500	
501	    /*  object constructor  */
502	    $.scheduler = function () {
503	        this.bucket = {};
504	        return;
505	    };
506	
507	    /*  object methods  */
508	    $.scheduler.prototype = {
509	        /*  schedule a task  */
510	        schedule: function () {
511	            /*  schedule context with default parameters */
512	            var ctx = {
513	                "id":         null,         /* unique identifier of high-level schedule */
514	                "time":       1000,         /* time in milliseconds after which the task is run */
515	                "repeat":     false,        /* whether schedule should be automatically repeated */
516	                "protect":    false,        /* whether schedule should be protected from double scheduling */
517	                "obj":        null,         /* function context object ("this") */
518	                "func":       function(){}, /* function to call */
519	                "args":       []            /* function arguments to pass */
520	            };
521	
522	            /*  helper function: portable checking whether something is a function  */
523	            function _isfn (fn) {
524	                return (
525	                       !!fn
526	                    && typeof fn != "string"
527	                    && typeof fn[0] == "undefined"
528	                    && RegExp("function", "i").test(fn + "")
529	                );
530	            };
531	           
532	            /*  parse arguments into context parameters (part 1/4):
533	                detect an override object (special case to support jQuery method) */
534	            var i = 0;
535	            var override = false;
536	            if (typeof arguments[i] == "object" && arguments.length > 1) {
537	                override = true;
538	                i++;
539	            }
540	
541	            /*  parse arguments into context parameters (part 2/4):
542	                support the flexible way of an associated array */
543	            if (typeof arguments[i] == "object") {
544	                for (var option in arguments[i])
545	                    if (typeof ctx[option] != "undefined")
546	                        ctx[option] = arguments[i][option];
547	                i++;
548	            }
549	
550	            /*  parse arguments into context parameters (part 3/4):
551	                support: schedule([time [, repeat], ]{{obj, methodname} | func}[, arg, ...]); */
552	            if (   typeof arguments[i] == "number"
553	                || (   typeof arguments[i] == "string" 
554	                    && arguments[i].match(RegExp("^[0-9]+[smhdw]$"))))
555	                ctx["time"] = arguments[i++];
556	            if (typeof arguments[i] == "boolean")
557	                ctx["repeat"] = arguments[i++];
558	            if (typeof arguments[i] == "boolean")
559	                ctx["protect"] = arguments[i++];
560	            if (   typeof arguments[i] == "object"
561	                && typeof arguments[i+1] == "string"
562	                && _isfn(arguments[i][arguments[i+1]])) {
563	                ctx["obj"] = arguments[i++];
564	                ctx["func"] = arguments[i++];
565	            }
566	            else if (   typeof arguments[i] != "undefined"
567	                     && (   _isfn(arguments[i]) 
568	                         || typeof arguments[i] == "string"))
569	                ctx["func"] = arguments[i++];
570	            while (typeof arguments[i] != "undefined")
571	                ctx["args"].push(arguments[i++]);
572	
573	            /*  parse arguments into context parameters (part 4/4):
574	                apply parameters from override object */
575	            if (override) {
576	                if (typeof arguments[1] == "object") {
577	                    for (var option in arguments[0])
578	                        if (   typeof ctx[option] != "undefined"
579	                            && typeof arguments[1][option] == "undefined")
580	                            ctx[option] = arguments[0][option];
581	                }
582	                else {
583	                    for (var option in arguments[0])
584	                        if (typeof ctx[option] != "undefined")
585	                            ctx[option] = arguments[0][option];
586	                }
587	                i++;
588	            }
589	
590	            /*  annotate context with internals */
591	            ctx["_scheduler"] = this; /* internal: back-reference to scheduler object */
592	            ctx["_handle"]    = null; /* internal: unique handle of low-level task */
593	
594	            /*  determine time value in milliseconds */
595	            var match = String(ctx["time"]).match(RegExp("^([0-9]+)([smhdw])$"));
596	            if (match && match[0] != "undefined" && match[1] != "undefined")
597	                ctx["time"] = String(parseInt(match[1]) *
598	                    { s: 1000, m: 1000*60, h: 1000*60*60,
599	                      d: 1000*60*60*24, w: 1000*60*60*24*7 }[match[2]]);
600	
601	            /*  determine unique identifier of task  */
602	            if (ctx["id"] == null)
603	                ctx["id"] = (  String(ctx["repeat"])  + ":"
604	                             + String(ctx["protect"]) + ":"
605	                             + String(ctx["time"])    + ":"
606	                             + String(ctx["obj"])     + ":"
607	                             + String(ctx["func"])    + ":"
608	                             + String(ctx["args"])         );
609	
610	            /*  optionally protect from duplicate calls  */
611	            if (ctx["protect"])
612	                if (typeof this.bucket[ctx["id"]] != "undefined")
613	                    return this.bucket[ctx["id"]];
614	
615	            /*  support execution of methods by name and arbitrary scripts  */
616	            if (!_isfn(ctx["func"])) {
617	                if (   ctx["obj"] != null
618	                    && typeof ctx["obj"] == "object"
619	                    && typeof ctx["func"] == "string"
620	                    && _isfn(ctx["obj"][ctx["func"]]))
621	                    /*  method by name  */
622	                    ctx["func"] = ctx["obj"][ctx["func"]];
623	                else
624	                    /*  arbitrary script  */
625	                    ctx["func"] = eval("function () { " + ctx["func"] + " }");
626	            }
627	
628	            /*  pass-through to internal scheduling operation  */
629	            ctx["_handle"] = this._schedule(ctx);
630	
631	            /*  store context into bucket of scheduler object  */
632	            this.bucket[ctx["id"]] = ctx;
633	
634	            /*  return context  */
635	            return ctx;
636	        },
637	
638	        /*  re-schedule a task  */
639	        reschedule: function (ctx) {
640	            if (typeof ctx == "string")
641	                ctx = this.bucket[ctx];
642	
643	            /*  pass-through to internal scheduling operation  */
644	            ctx["_handle"] = this._schedule(ctx);
645	
646	            /*  return context  */
647	            return ctx;
648	        },
649	
650	        /*  internal scheduling operation  */
651	        _schedule: function (ctx) {
652	            /*  closure to act as the call trampoline function  */
653	            var trampoline = function () {
654	                /*  jump into function  */
655	                var obj = (ctx["obj"] != null ? ctx["obj"] : ctx);
656	                (ctx["func"]).apply(obj, ctx["args"]);
657	
658	                /*  either repeat scheduling and keep in bucket or
659	                    just stop scheduling and delete from scheduler bucket  */
660	                if (   /* not cancelled from inside... */
661	                       typeof (ctx["_scheduler"]).bucket[ctx["id"]] != "undefined"
662	                    && /* ...and repeating requested */
663	                       ctx["repeat"])
664	                    (ctx["_scheduler"])._schedule(ctx);
665	                else
666	                    delete (ctx["_scheduler"]).bucket[ctx["id"]];
667	            };
668	
669	            /*  schedule task and return handle  */
670	            return setTimeout(trampoline, ctx["time"]);
671	        },
672	
673	        /*  cancel a scheduled task  */
674	        cancel: function (ctx) {
675	            if (typeof ctx == "string")
676	                ctx = this.bucket[ctx];
677	
678	            /*  cancel scheduled task  */
679	            if (typeof ctx == "object") {
680	                clearTimeout(ctx["_handle"]);
681	                delete this.bucket[ctx["id"]];
682	            }
683	        }
684	    };
685	
686	    /* integrate a global instance of the scheduler into the global jQuery object */
687	    $.extend({
688	        scheduler$: new $.scheduler(),
689	        schedule:   function () { return $.scheduler$.schedule.apply  ($.scheduler$, arguments) },
690	        reschedule: function () { return $.scheduler$.reschedule.apply($.scheduler$, arguments) },
691	        cancel:     function () { return $.scheduler$.cancel.apply    ($.scheduler$, arguments) }
692	    });
693	
694	    /* integrate scheduling convinience method into all jQuery objects */
695	    $.fn.extend({
696	        schedule: function () {
697	            var a = [ {} ];
698	            for (var i = 0; i < arguments.length; i++)
699	                a.push(arguments[i]);
700	            return this.each(function () {
701	                a[0] = { "id": this, "obj": this };
702	                return $.schedule.apply($, a);
703	            });
704	        }
705	    });
706	
707	})(jQuery);
708	

1	/*!
2	 * jQuery Color Animations v2.1.0
3	 * http://jquery.com/
4	 *
5	 * Copyright 2012 jQuery Foundation and other contributors
6	 * Released under the MIT license.
7	 * http://jquery.org/license
8	 *
9	 * Date: Fri Aug 24 12:02:24 2012 -0500
10	 */
11	(function( jQuery, undefined ) {
12	
13	        var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
14	
15	        // plusequals test for += 100 -= 100
16	        rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
17	        // a set of RE's that can match strings and generate color tuples.
18	        stringParsers = [{
19	                        re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
20	                        parse: function( execResult ) {
21	                                return [
22	                                        execResult[ 1 ],
23	                                        execResult[ 2 ],
24	                                        execResult[ 3 ],
25	                                        execResult[ 4 ]
26	                                ];
27	                        }
28	                }, {
29	                        re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
30	                        parse: function( execResult ) {
31	                                return [
32	                                        execResult[ 1 ] * 2.55,
33	                                        execResult[ 2 ] * 2.55,
34	                                        execResult[ 3 ] * 2.55,
35	                                        execResult[ 4 ]
36	                                ];
37	                        }
38	                }, {
39	                        // this regex ignores A-F because it's compared against an already lowercased string
40	                        re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
41	                        parse: function( execResult ) {
42	                                return [
43	                                        parseInt( execResult[ 1 ], 16 ),
44	                                        parseInt( execResult[ 2 ], 16 ),
45	                                        parseInt( execResult[ 3 ], 16 )
46	                                ];
47	                        }
48	                }, {
49	                        // this regex ignores A-F because it's compared against an already lowercased string
50	                        re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
51	                        parse: function( execResult ) {
52	                                return [
53	                                        parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
54	                                        parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
55	                                        parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
56	                                ];
57	                        }
58	                }, {
59	                        re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
60	                        space: "hsla",
61	                        parse: function( execResult ) {
62	                                return [
63	                                        execResult[ 1 ],
64	                                        execResult[ 2 ] / 100,
65	                                        execResult[ 3 ] / 100,
66	                                        execResult[ 4 ]
67	                                ];
68	                        }
69	                }],
70	
71	        // jQuery.Color( )
72	        color = jQuery.Color = function( color, green, blue, alpha ) {
73	                return new jQuery.Color.fn.parse( color, green, blue, alpha );
74	        },
75	        spaces = {
76	                rgba: {
77	                        props: {
78	                                red: {
79	                                        idx: 0,
80	                                        type: "byte"
81	                                },
82	                                green: {
83	                                        idx: 1,
84	                                        type: "byte"
85	                                },
86	                                blue: {
87	                                        idx: 2,
88	                                        type: "byte"
89	                                }
90	                        }
91	                },
92	
93	                hsla: {
94	                        props: {
95	                                hue: {
96	                                        idx: 0,
97	                                        type: "degrees"
98	                                },
99	                                saturation: {
100	                                        idx: 1,
101	                                        type: "percent"
102	                                },
103	                                lightness: {
104	                                        idx: 2,
105	                                        type: "percent"
106	                                }
107	                        }
108	                }
109	        },
110	        propTypes = {
111	                "byte": {
112	                        floor: true,
113	                        max: 255
114	                },
115	                "percent": {
116	                        max: 1
117	                },
118	                "degrees": {
119	                        mod: 360,
120	                        floor: true
121	                }
122	        },
123	        support = color.support = {},
124	
125	        // element for support tests
126	        supportElem = jQuery( "<p>" )[ 0 ],
127	
128	        // colors = jQuery.Color.names
129	        colors,
130	
131	        // local aliases of functions called often
132	        each = jQuery.each;
133	
134	// determine rgba support immediately
135	supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
136	support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
137	
138	// define cache name and alpha properties
139	// for rgba and hsla spaces
140	each( spaces, function( spaceName, space ) {
141	        space.cache = "_" + spaceName;
142	        space.props.alpha = {
143	                idx: 3,
144	                type: "percent",
145	                def: 1
146	        };
147	});
148	
149	function clamp( value, prop, allowEmpty ) {
150	        var type = propTypes[ prop.type ] || {};
151	
152	        if ( value == null ) {
153	                return (allowEmpty || !prop.def) ? null : prop.def;
154	        }
155	
156	        // ~~ is an short way of doing floor for positive numbers
157	        value = type.floor ? ~~value : parseFloat( value );
158	
159	        // IE will pass in empty strings as value for alpha,
160	        // which will hit this case
161	        if ( isNaN( value ) ) {
162	                return prop.def;
163	        }
164	
165	        if ( type.mod ) {
166	                // we add mod before modding to make sure that negatives values
167	                // get converted properly: -10 -> 350
168	                return (value + type.mod) % type.mod;
169	        }
170	
171	        // for now all property types without mod have min and max
172	        return 0 > value ? 0 : type.max < value ? type.max : value;
173	}
174	
175	function stringParse( string ) {
176	        var inst = color(),
177	                rgba = inst._rgba = [];
178	
179	        string = string.toLowerCase();
180	
181	        each( stringParsers, function( i, parser ) {
182	                var parsed,
183	                        match = parser.re.exec( string ),
184	                        values = match && parser.parse( match ),
185	                        spaceName = parser.space || "rgba";
186	
187	                if ( values ) {
188	                        parsed = inst[ spaceName ]( values );
189	
190	                        // if this was an rgba parse the assignment might happen twice
191	                        // oh well....
192	                        inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
193	                        rgba = inst._rgba = parsed._rgba;
194	
195	                        // exit each( stringParsers ) here because we matched
196	                        return false;
197	                }
198	        });
199	
200	        // Found a stringParser that handled it
201	        if ( rgba.length ) {
202	
203	                // if this came from a parsed string, force "transparent" when alpha is 0
204	                // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
205	                if ( rgba.join() === "0,0,0,0" ) {
206	                        jQuery.extend( rgba, colors.transparent );
207	                }
208	                return inst;
209	        }
210	
211	        // named colors
212	        return colors[ string ];
213	}
214	
215	color.fn = jQuery.extend( color.prototype, {
216	        parse: function( red, green, blue, alpha ) {
217	                if ( red === undefined ) {
218	                        this._rgba = [ null, null, null, null ];
219	                        return this;
220	                }
221	                if ( red.jquery || red.nodeType ) {
222	                        red = jQuery( red ).css( green );
223	                        green = undefined;
224	                }
225	
226	                var inst = this,
227	                        type = jQuery.type( red ),
228	                        rgba = this._rgba = [],
229	                        source;
230	
231	                // more than 1 argument specified - assume ( red, green, blue, alpha )
232	                if ( green !== undefined ) {
233	                        red = [ red, green, blue, alpha ];
234	                        type = "array";
235	                }
236	
237	                if ( type === "string" ) {
238	                        return this.parse( stringParse( red ) || colors._default );
239	                }
240	
241	                if ( type === "array" ) {
242	                        each( spaces.rgba.props, function( key, prop ) {
243	                                rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
244	                        });
245	                        return this;
246	                }
247	
248	                if ( type === "object" ) {
249	                        if ( red instanceof color ) {
250	                                each( spaces, function( spaceName, space ) {
251	                                        if ( red[ space.cache ] ) {
252	                                                inst[ space.cache ] = red[ space.cache ].slice();
253	                                        }
254	                                });
255	                        } else {
256	                                each( spaces, function( spaceName, space ) {
257	                                        var cache = space.cache;
258	                                        each( space.props, function( key, prop ) {
259	
260	                                                // if the cache doesn't exist, and we know how to convert
261	                                                if ( !inst[ cache ] && space.to ) {
262	
263	                                                        // if the value was null, we don't need to copy it
264	                                                        // if the key was alpha, we don't need to copy it either
265	                                                        if ( key === "alpha" || red[ key ] == null ) {
266	                                                                return;
267	                                                        }
268	                                                        inst[ cache ] = space.to( inst._rgba );
269	                                                }
270	
271	                                                // this is the only case where we allow nulls for ALL properties.
272	                                                // call clamp with alwaysAllowEmpty
273	                                                inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
274	                                        });
275	
276	                                        // everything defined but alpha?
277	                                        if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
278	                                                // use the default of 1
279	                                                inst[ cache ][ 3 ] = 1;
280	                                                if ( space.from ) {
281	                                                        inst._rgba = space.from( inst[ cache ] );
282	                                                }
283	                                        }
284	                                });
285	                        }
286	                        return this;
287	                }
288	        },
289	        is: function( compare ) {
290	                var is = color( compare ),
291	                        same = true,
292	                        inst = this;
293	
294	                each( spaces, function( _, space ) {
295	                        var localCache,
296	                                isCache = is[ space.cache ];
297	                        if (isCache) {
298	                                localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
299	                                each( space.props, function( _, prop ) {
300	                                        if ( isCache[ prop.idx ] != null ) {
301	                                                same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
302	                                                return same;
303	                                        }
304	                                });
305	                        }
306	                        return same;
307	                });
308	                return same;
309	        },
310	        _space: function() {
311	                var used = [],
312	                        inst = this;
313	                each( spaces, function( spaceName, space ) {
314	                        if ( inst[ space.cache ] ) {
315	                                used.push( spaceName );
316	                        }
317	                });
318	                return used.pop();
319	        },
320	        transition: function( other, distance ) {
321	                var end = color( other ),
322	                        spaceName = end._space(),
323	                        space = spaces[ spaceName ],
324	                        startColor = this.alpha() === 0 ? color( "transparent" ) : this,
325	                        start = startColor[ space.cache ] || space.to( startColor._rgba ),
326	                        result = start.slice();
327	
328	                end = end[ space.cache ];
329	                each( space.props, function( key, prop ) {
330	                        var index = prop.idx,
331	                                startValue = start[ index ],
332	                                endValue = end[ index ],
333	                                type = propTypes[ prop.type ] || {};
334	
335	                        // if null, don't override start value
336	                        if ( endValue === null ) {
337	                                return;
338	                        }
339	                        // if null - use end
340	                        if ( startValue === null ) {
341	                                result[ index ] = endValue;
342	                        } else {
343	                                if ( type.mod ) {
344	                                        if ( endValue - startValue > type.mod / 2 ) {
345	                                                startValue += type.mod;
346	                                        } else if ( startValue - endValue > type.mod / 2 ) {
347	                                                startValue -= type.mod;
348	                                        }
349	                                }
350	                                result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
351	                        }
352	                });
353	                return this[ spaceName ]( result );
354	        },
355	        blend: function( opaque ) {
356	                // if we are already opaque - return ourself
357	                if ( this._rgba[ 3 ] === 1 ) {
358	                        return this;
359	                }
360	
361	                var rgb = this._rgba.slice(),
362	                        a = rgb.pop(),
363	                        blend = color( opaque )._rgba;
364	
365	                return color( jQuery.map( rgb, function( v, i ) {
366	                        return ( 1 - a ) * blend[ i ] + a * v;
367	                }));
368	        },
369	        toRgbaString: function() {
370	                var prefix = "rgba(",
371	                        rgba = jQuery.map( this._rgba, function( v, i ) {
372	                                return v == null ? ( i > 2 ? 1 : 0 ) : v;
373	                        });
374	
375	                if ( rgba[ 3 ] === 1 ) {
376	                        rgba.pop();
377	                        prefix = "rgb(";
378	                }
379	
380	                return prefix + rgba.join() + ")";
381	        },
382	        toHslaString: function() {
383	                var prefix = "hsla(",
384	                        hsla = jQuery.map( this.hsla(), function( v, i ) {
385	                                if ( v == null ) {
386	                                        v = i > 2 ? 1 : 0;
387	                                }
388	
389	                                // catch 1 and 2
390	                                if ( i && i < 3 ) {
391	                                        v = Math.round( v * 100 ) + "%";
392	                                }
393	                                return v;
394	                        });
395	
396	                if ( hsla[ 3 ] === 1 ) {
397	                        hsla.pop();
398	                        prefix = "hsl(";
399	                }
400	                return prefix + hsla.join() + ")";
401	        },
402	        toHexString: function( includeAlpha ) {
403	                var rgba = this._rgba.slice(),
404	                        alpha = rgba.pop();
405	
406	                if ( includeAlpha ) {
407	                        rgba.push( ~~( alpha * 255 ) );
408	                }
409	
410	                return "#" + jQuery.map( rgba, function( v, i ) {
411	
412	                        // default to 0 when nulls exist
413	                        v = ( v || 0 ).toString( 16 );
414	                        return v.length === 1 ? "0" + v : v;
415	                }).join("");
416	        },
417	        toString: function() {
418	                return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
419	        }
420	});
421	color.fn.parse.prototype = color.fn;
422	
423	// hsla conversions adapted from:
424	// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
425	
426	function hue2rgb( p, q, h ) {
427	        h = ( h + 1 ) % 1;
428	        if ( h * 6 < 1 ) {
429	                return p + (q - p) * h * 6;
430	        }
431	        if ( h * 2 < 1) {
432	                return q;
433	        }
434	        if ( h * 3 < 2 ) {
435	                return p + (q - p) * ((2/3) - h) * 6;
436	        }
437	        return p;
438	}
439	
440	spaces.hsla.to = function ( rgba ) {
441	        if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
442	                return [ null, null, null, rgba[ 3 ] ];
443	        }
444	        var r = rgba[ 0 ] / 255,
445	                g = rgba[ 1 ] / 255,
446	                b = rgba[ 2 ] / 255,
447	                a = rgba[ 3 ],
448	                max = Math.max( r, g, b ),
449	                min = Math.min( r, g, b ),
450	                diff = max - min,
451	                add = max + min,
452	                l = add * 0.5,
453	                h, s;
454	
455	        if ( min === max ) {
456	                h = 0;
457	        } else if ( r === max ) {
458	                h = ( 60 * ( g - b ) / diff ) + 360;
459	        } else if ( g === max ) {
460	                h = ( 60 * ( b - r ) / diff ) + 120;
461	        } else {
462	                h = ( 60 * ( r - g ) / diff ) + 240;
463	        }
464	
465	        if ( l === 0 || l === 1 ) {
466	                s = l;
467	        } else if ( l <= 0.5 ) {
468	                s = diff / add;
469	        } else {
470	                s = diff / ( 2 - add );
471	        }
472	        return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
473	};
474	
475	spaces.hsla.from = function ( hsla ) {
476	        if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
477	                return [ null, null, null, hsla[ 3 ] ];
478	        }
479	        var h = hsla[ 0 ] / 360,
480	                s = hsla[ 1 ],
481	                l = hsla[ 2 ],
482	                a = hsla[ 3 ],
483	                q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
484	                p = 2 * l - q,
485	                r, g, b;
486	
487	        return [
488	                Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
489	                Math.round( hue2rgb( p, q, h ) * 255 ),
490	                Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
491	                a
492	        ];
493	};
494	
495	
496	each( spaces, function( spaceName, space ) {
497	        var props = space.props,
498	                cache = space.cache,
499	                to = space.to,
500	                from = space.from;
501	
502	        // makes rgba() and hsla()
503	        color.fn[ spaceName ] = function( value ) {
504	
505	                // generate a cache for this space if it doesn't exist
506	                if ( to && !this[ cache ] ) {
507	                        this[ cache ] = to( this._rgba );
508	                }
509	                if ( value === undefined ) {
510	                        return this[ cache ].slice();
511	                }
512	
513	                var ret,
514	                        type = jQuery.type( value ),
515	                        arr = ( type === "array" || type === "object" ) ? value : arguments,
516	                        local = this[ cache ].slice();
517	
518	                each( props, function( key, prop ) {
519	                        var val = arr[ type === "object" ? key : prop.idx ];
520	                        if ( val == null ) {
521	                                val = local[ prop.idx ];
522	                        }
523	                        local[ prop.idx ] = clamp( val, prop );
524	                });
525	
526	                if ( from ) {
527	                        ret = color( from( local ) );
528	                        ret[ cache ] = local;
529	                        return ret;
530	                } else {
531	                        return color( local );
532	                }
533	        };
534	
535	        // makes red() green() blue() alpha() hue() saturation() lightness()
536	        each( props, function( key, prop ) {
537	                // alpha is included in more than one space
538	                if ( color.fn[ key ] ) {
539	                        return;
540	                }
541	                color.fn[ key ] = function( value ) {
542	                        var vtype = jQuery.type( value ),
543	                                fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
544	                                local = this[ fn ](),
545	                                cur = local[ prop.idx ],
546	                                match;
547	
548	                        if ( vtype === "undefined" ) {
549	                                return cur;
550	                        }
551	
552	                        if ( vtype === "function" ) {
553	                                value = value.call( this, cur );
554	                                vtype = jQuery.type( value );
555	                        }
556	                        if ( value == null && prop.empty ) {
557	                                return this;
558	                        }
559	                        if ( vtype === "string" ) {
560	                                match = rplusequals.exec( value );
561	                                if ( match ) {
562	                                        value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
563	                                }
564	                        }
565	                        local[ prop.idx ] = value;
566	                        return this[ fn ]( local );
567	                };
568	        });
569	});
570	
571	// add cssHook and .fx.step function for each named hook.
572	// accept a space separated string of properties
573	color.hook = function( hook ) {
574	        var hooks = hook.split( " " );
575	        each( hooks, function( i, hook ) {
576	                jQuery.cssHooks[ hook ] = {
577	                        set: function( elem, value ) {
578	                                var parsed, curElem,
579	                                        backgroundColor = "";
580	
581	                                if ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) {
582	                                        value = color( parsed || value );
583	                                        if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
584	                                                curElem = hook === "backgroundColor" ? elem.parentNode : elem;
585	                                                while (
586	                                                        (backgroundColor === "" || backgroundColor === "transparent") &&
587	                                                        curElem && curElem.style
588	                                                ) {
589	                                                        try {
590	                                                                backgroundColor = jQuery.css( curElem, "backgroundColor" );
591	                                                                curElem = curElem.parentNode;
592	                                                        } catch ( e ) {
593	                                                        }
594	                                                }
595	
596	                                                value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
597	                                                        backgroundColor :
598	                                                        "_default" );
599	                                        }
600	
601	                                        value = value.toRgbaString();
602	                                }
603	                                try {
604	                                        elem.style[ hook ] = value;
605	                                } catch( value ) {
606	                                        // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
607	                                }
608	                        }
609	                };
610	                jQuery.fx.step[ hook ] = function( fx ) {
611	                        if ( !fx.colorInit ) {
612	                                fx.start = color( fx.elem, hook );
613	                                fx.end = color( fx.end );
614	                                fx.colorInit = true;
615	                        }
616	                        jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
617	                };
618	        });
619	
620	};
621	
622	color.hook( stepHooks );
623	
624	jQuery.cssHooks.borderColor = {
625	        expand: function( value ) {
626	                var expanded = {};
627	
628	                each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
629	                        expanded[ "border" + part + "Color" ] = value;
630	                });
631	                return expanded;
632	        }
633	};
634	
635	// Basic color names only.
636	// Usage of any of the other color names requires adding yourself or including
637	// jquery.color.svg-names.js.
638	colors = jQuery.Color.names = {
639	        // 4.1. Basic color keywords
640	        aqua: "#00ffff",
641	        black: "#000000",
642	        blue: "#0000ff",
643	        fuchsia: "#ff00ff",
644	        gray: "#808080",
645	        green: "#008000",
646	        lime: "#00ff00",
647	        maroon: "#800000",
648	        navy: "#000080",
649	        olive: "#808000",
650	        purple: "#800080",
651	        red: "#ff0000",
652	        silver: "#c0c0c0",
653	        teal: "#008080",
654	        white: "#ffffff",
655	        yellow: "#ffff00",
656	
657	        // 4.2.3. ‘transparent’ color keyword
658	        transparent: [ null, null, null, 0 ],
659	
660	        _default: "#ffffff"
661	};
662	
663	})( jQuery );
664	
665	/*!
666	 * jQuery Color Animations v2.1.0 - SVG Color Names
667	 * http://jquery.org/
668	 *
669	 * Remaining HTML/CSS color names per W3C's CSS Color Module Level 3.
670	 * http://www.w3.org/TR/css3-color/#svg-color
671	 *
672	 * Copyright 2012 jQuery Foundation and other contributors
673	 * Released under the MIT license.
674	 * http://jquery.org/license
675	 *
676	 * Date: Fri Aug 24 12:02:24 2012 -0500
677	 */
678	jQuery.extend( jQuery.Color.names, {
679	        // 4.3. Extended color keywords (minus the basic ones in core color plugin)
680	        aliceblue: "#f0f8ff",
681	        antiquewhite: "#faebd7",
682	        aquamarine: "#7fffd4",
683	        azure: "#f0ffff",
684	        beige: "#f5f5dc",
685	        bisque: "#ffe4c4",
686	        blanchedalmond: "#ffebcd",
687	        blueviolet: "#8a2be2",
688	        brown: "#a52a2a",
689	        burlywood: "#deb887",
690	        cadetblue: "#5f9ea0",
691	        chartreuse: "#7fff00",
692	        chocolate: "#d2691e",
693	        coral: "#ff7f50",
694	        cornflowerblue: "#6495ed",
695	        cornsilk: "#fff8dc",
696	        crimson: "#dc143c",
697	        cyan: "#00ffff",
698	        darkblue: "#00008b",
699	        darkcyan: "#008b8b",
700	        darkgoldenrod: "#b8860b",
701	        darkgray: "#a9a9a9",
702	        darkgreen: "#006400",
703	        darkgrey: "#a9a9a9",
704	        darkkhaki: "#bdb76b",
705	        darkmagenta: "#8b008b",
706	        darkolivegreen: "#556b2f",
707	        darkorange: "#ff8c00",
708	        darkorchid: "#9932cc",
709	        darkred: "#8b0000",
710	        darksalmon: "#e9967a",
711	        darkseagreen: "#8fbc8f",
712	        darkslateblue: "#483d8b",
713	        darkslategray: "#2f4f4f",
714	        darkslategrey: "#2f4f4f",
715	        darkturquoise: "#00ced1",
716	        darkviolet: "#9400d3",
717	        deeppink: "#ff1493",
718	        deepskyblue: "#00bfff",
719	        dimgray: "#696969",
720	        dimgrey: "#696969",
721	        dodgerblue: "#1e90ff",
722	        firebrick: "#b22222",
723	        floralwhite: "#fffaf0",
724	        forestgreen: "#228b22",
725	        gainsboro: "#dcdcdc",
726	        ghostwhite: "#f8f8ff",
727	        gold: "#ffd700",
728	        goldenrod: "#daa520",
729	        greenyellow: "#adff2f",
730	        grey: "#808080",
731	        honeydew: "#f0fff0",
732	        hotpink: "#ff69b4",
733	        indianred: "#cd5c5c",
734	        indigo: "#4b0082",
735	        ivory: "#fffff0",
736	        khaki: "#f0e68c",
737	        lavender: "#e6e6fa",
738	        lavenderblush: "#fff0f5",
739	        lawngreen: "#7cfc00",
740	        lemonchiffon: "#fffacd",
741	        lightblue: "#add8e6",
742	        lightcoral: "#f08080",
743	        lightcyan: "#e0ffff",
744	        lightgoldenrodyellow: "#fafad2",
745	        lightgray: "#d3d3d3",
746	        lightgreen: "#90ee90",
747	        lightgrey: "#d3d3d3",
748	        lightpink: "#ffb6c1",
749	        lightsalmon: "#ffa07a",
750	        lightseagreen: "#20b2aa",
751	        lightskyblue: "#87cefa",
752	        lightslategray: "#778899",
753	        lightslategrey: "#778899",
754	        lightsteelblue: "#b0c4de",
755	        lightyellow: "#ffffe0",
756	        limegreen: "#32cd32",
757	        linen: "#faf0e6",
758	        mediumaquamarine: "#66cdaa",
759	        mediumblue: "#0000cd",
760	        mediumorchid: "#ba55d3",
761	        mediumpurple: "#9370db",
762	        mediumseagreen: "#3cb371",
763	        mediumslateblue: "#7b68ee",
764	        mediumspringgreen: "#00fa9a",
765	        mediumturquoise: "#48d1cc",
766	        mediumvioletred: "#c71585",
767	        midnightblue: "#191970",
768	        mintcream: "#f5fffa",
769	        mistyrose: "#ffe4e1",
770	        moccasin: "#ffe4b5",
771	        navajowhite: "#ffdead",
772	        oldlace: "#fdf5e6",
773	        olivedrab: "#6b8e23",
774	        orange: "#ffa500",
775	        orangered: "#ff4500",
776	        orchid: "#da70d6",
777	        palegoldenrod: "#eee8aa",
778	        palegreen: "#98fb98",
779	        paleturquoise: "#afeeee",
780	        palevioletred: "#db7093",
781	        papayawhip: "#ffefd5",
782	        peachpuff: "#ffdab9",
783	        peru: "#cd853f",
784	        pink: "#ffc0cb",
785	        plum: "#dda0dd",
786	        powderblue: "#b0e0e6",
787	        rosybrown: "#bc8f8f",
788	        royalblue: "#4169e1",
789	        saddlebrown: "#8b4513",
790	        salmon: "#fa8072",
791	        sandybrown: "#f4a460",
792	        seagreen: "#2e8b57",
793	        seashell: "#fff5ee",
794	        sienna: "#a0522d",
795	        skyblue: "#87ceeb",
796	        slateblue: "#6a5acd",
797	        slategray: "#708090",
798	        slategrey: "#708090",
799	        snow: "#fffafa",
800	        springgreen: "#00ff7f",
801	        steelblue: "#4682b4",
802	        tan: "#d2b48c",
803	        thistle: "#d8bfd8",
804	        tomato: "#ff6347",
805	        turquoise: "#40e0d0",
806	        violet: "#ee82ee",
807	        wheat: "#f5deb3",
808	        whitesmoke: "#f5f5f5",
809	        yellowgreen: "#9acd32",
810	});