ui_alchemy-rails 1.0.4

data/vendor/assets/javascripts/alchemy/jquery/plugins/jquery.timepickr.js

@@ -0,0 +1,214 @@
+/*
+  jQuery Ui timepickr
+  (c) Maxime Haineault <haineault@gmail.com>
+  http://haineault.com
+
+  MIT License (http://www.opensource.org/licenses/mit-license.php
+  Modified under license by Daniel Wachsstock & Haso Keric
+
+	Updated 10/25/2010 for jQuery UI 1.8.5
+*/
+
+(function($) {
+	var menuTemplate = '<div class="ui-helper-reset ui-timepickr ui-widget" />';
+	var rowTemplate = '<ol />';
+	var buttonTemplate = '<li class="{className}">{label}</li>';
+	function format(s, o){ // simple parameterizing strings
+		for (key in o) s = s.replace('{'+key+'}', o[key]);
+		return s;
+	}
+
+$.widget('ui.timepickr', {
+	_init: function() {
+		var ui = this, element = this.element;
+		element.data('timepickr.initialValue', element.val());
+		var menu = this.menu = ui._buildMenu().insertAfter(element);
+		menu.children().hide();
+
+		element.bind(this.options.trigger + '.timepickr', function(){
+			ui.show();
+		});
+
+		var hover = this.options.hoverIntent && $.fn.hoverIntent ? 'hoverIntent' : 'hover';
+		menu
+			.data('timepickr', this)
+			.css({width:this.options.width})
+			.find('li')
+				.addClass('ui-state-default ui-corner-all')
+				[hover](function(){
+					ui.inside = true;
+					$(this).siblings().removeClass('ui-state-hover');
+					$(this).addClass('ui-state-hover');
+					ui._redraw();
+					ui.showNextLevel(this);
+					ui.update();
+				}, function(){
+					ui.inside = false;
+				}).end()
+			.find('ol')
+				.addClass('ui-widget ui-helper-clearfix ui-helper-reset')
+				.hide();
+
+		this._redraw();
+
+		element.blur(function(e) {
+			ui.hide();
+			if (ui.inside){
+				// clicking outside the element blurs it before the click on the new element in called
+				ui._trigger ('select', [e, ui]);
+			}
+			if (ui.options.resetOnBlur) {
+				element.val(element.data('timepickr.initialValue'));
+			}
+		});
+
+		if (this.options.val) {
+			element.val(this.options.val);
+		}
+
+		if (this.options.handle) {
+			$(this.options.handle).click(function() {
+				ui.show();
+				ui.element.focus();
+			});
+		}
+
+		if (this.options.resetOnBlur) {
+			menu.find('li').bind('mousedown.timepickr', function(){
+				element.data('timepickr.initialValue', element.val());
+			});
+		}
+
+		this._redraw();
+	},
+
+	update: function() {
+		var val = {
+			h: this.getValue('hour'),
+			m: this.getValue('minute'),
+			prefix: this.getValue('prefix'),
+			suffix: this.getValue('suffix')
+		};
+		$(this.element).val(format(this.options.format, val));
+	},
+
+	getValue: function(type) {
+		// get the highlighted element; if none is highlighted, get the first one
+		var elem = $('.'+ type +'.ui-state-hover', this.menu)[0] || $('.'+type+':first', this.menu)[0];
+		return $(elem).text();
+	},
+
+	destroy: function() {
+		this.menu.remove();
+		$.Widget.prototype.destroy.apply(this);
+	},
+
+	show: function() {
+		this.menu.css({
+			top: this.element.position().top + this.element.height() + this.options.top,
+			zIndex: 1000
+		});
+		this.menu.find('ol:eq(0)').css('left', this.element.position().left).show();
+	},
+
+	showNextLevel: function(el) {
+		$(el).closest('ol').next().show(this.options.animSpeed);
+	},
+
+	// essentially reposition each ol
+	_redraw: function() {
+		this.menu.css({
+			top: this.element.position().top + this.element.height() + this.options.top,
+			left: this.element.position().left + this.options.left
+		});
+
+		if (this.options.convention === 24) {
+			var hrs        = this.menu.find('ol:eq(1)');
+			var dayHours   = hrs.find('li').slice(0, 12);
+			var nightHours = hrs.find('li').slice(12, 24);
+			if (this.menu.find('ol:eq(0) li:eq(0)').hasClass('ui-state-hover')){
+				// daytime
+				nightHours.hide();
+				dayHours.show();
+			}else{
+				//nighttime
+				dayHours.hide();
+				nightHours.show();
+			}
+		}
+
+		// reposition each ol
+		var ols = this.menu.find('ol');
+		ols.each(function(i) {
+			var prevOL = $(this).prev('ol');
+			// find the span that's being hovered; if nothing, use the first one
+			var pos = prevOL.find('.ui-state-hover:visible').position() || prevOL.find('li:visible:first').position();
+			if (pos) $(this).css('margin-left', pos.left);
+		});
+	},
+
+	// hide all levels
+	hide: function() {
+		this.menu.find('ol').hide();
+	},
+
+	activate: function(e) {
+		this.element.focus();
+		this.show(this.options.animSpeed);
+	},
+
+	_createRow: function(range, className) {
+		var row = $(rowTemplate);
+		$.each(range, function(){
+			row.append($(format(buttonTemplate, {className: className, label: this.toString()})));
+		});
+		return row;
+	},
+
+	_getRanges12: function() {
+		var o = [];
+		o.push(this._createRow(['01','02','03','04','05','06','07','08','09','10','11','12'], 'hour'));
+		o.push(this._createRow(this.options.rangeMin, 'minute'));
+		o.push(this._createRow(this.options.suffix, 'suffix'));
+		return o;
+	},
+
+	_getRanges24: function() {
+		var o = [], opt = this.options;
+		o.push(this._createRow(this.options.prefix, false, 'prefix')); // prefix is required in 24h mode
+		o.push(this._createRow(
+			['00','01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','17','18','19','20','21','22','23'],
+			'hour'
+		));
+		o.push(this._createRow(this.options.rangeMin, 'minute'));
+		return o;
+	},
+
+	_buildMenu: function() {
+		var menu   = $(menuTemplate);
+		var ranges = this.options.convention === 24
+								 && this._getRanges24() || this._getRanges12();
+		$.each(ranges, function(i, val){
+				menu.append(val);
+		});
+		return menu;
+	}
+});
+
+$.ui.timepickr.prototype.options = {
+	top:       6,
+	left:      0,
+	animSpeed: 0,
+	trigger:   'click',
+	convention:  12, // 24, 12
+	format:    '{h}:{m} {suffix}',
+	handle:      false,
+	prefix:      ['00-11', '12-23'],
+	suffix:      ['am', 'pm'],
+	rangeMin:    ['00', '15', '30', '45'],
+	resetOnBlur: true,
+	val:         false,
+	hoverIntent: false
+};
+
+})(jQuery);

data/vendor/assets/javascripts/alchemy/jquery/plugins/jquery.timers.js

@@ -0,0 +1,142 @@
+jQuery.fn.extend({
+	everyTime: function(interval, label, fn, times, belay) {
+		return this.each(function() {
+			jQuery.timer.add(this, interval, label, fn, times, belay);
+		});
+	},
+	oneTime: function(interval, label, fn) {
+		return this.each(function() {
+			jQuery.timer.add(this, interval, label, fn, 1);
+		});
+	},
+	stopTime: function(label, fn) {
+		return this.each(function() {
+			jQuery.timer.remove(this, label, fn);
+		});
+	}
+});
+
+jQuery.extend({
+	timer: {
+		guid: 1,
+		global: {},
+		regex: /^([0-9]+)\s*(.*s)?$/,
+		powers: {
+			// Yeah this is major overkill...
+			'ms': 1,
+			'cs': 10,
+			'ds': 100,
+			's': 1000,
+			'das': 10000,
+			'hs': 100000,
+			'ks': 1000000
+		},
+		timeParse: function(value) {
+			if (value == undefined || value == null)
+				return null;
+			var result = this.regex.exec(jQuery.trim(value.toString()));
+			if (result[2]) {
+				var num = parseInt(result[1], 10);
+				var mult = this.powers[result[2]] || 1;
+				return num * mult;
+			} else {
+				return value;
+			}
+		},
+		add: function(element, interval, label, fn, times, belay) {
+			var counter = 0;
+			
+			if (jQuery.isFunction(label)) {
+				if (!times) 
+					times = fn;
+				fn = label;
+				label = interval;
+			}
+			
+			interval = jQuery.timer.timeParse(interval);
+
+			if (typeof interval != 'number' || isNaN(interval) || interval <= 0)
+				return;
+
+			if (times && times.constructor != Number) {
+				belay = !!times;
+				times = 0;
+			}
+			
+			times = times || 0;
+			belay = belay || false;
+			
+			if (!element.$timers) 
+				element.$timers = {};
+			
+			if (!element.$timers[label])
+				element.$timers[label] = {};
+			
+			fn.$timerID = fn.$timerID || this.guid++;
+			
+			var handler = function() {
+				if (belay && this.inProgress) 
+					return;
+				this.inProgress = true;
+				if ((++counter > times && times !== 0) || fn.call(element, counter) === false)
+					jQuery.timer.remove(element, label, fn);
+				this.inProgress = false;
+			};
+			
+			handler.$timerID = fn.$timerID;
+			
+			if (!element.$timers[label][fn.$timerID]) 
+				element.$timers[label][fn.$timerID] = window.setInterval(handler,interval);
+			
+			if ( !this.global[label] )
+				this.global[label] = [];
+			this.global[label].push( element );
+			
+		},
+		remove: function(element, label, fn) {
+			var timers = element.$timers, ret;
+			
+			if ( timers ) {
+				
+				if (!label) {
+					for ( label in timers )
+						this.remove(element, label, fn);
+				} else if ( timers[label] ) {
+					if ( fn ) {
+						if ( fn.$timerID ) {
+							window.clearInterval(timers[label][fn.$timerID]);
+							delete timers[label][fn.$timerID];
+						}
+					} else {
+						for ( var fn in timers[label] ) {
+							window.clearInterval(timers[label][fn]);
+							delete timers[label][fn];
+						}
+					}
+					
+					for ( ret in timers[label] ) break;
+					if ( !ret ) {
+						ret = null;
+						delete timers[label];
+					}
+				}
+				
+				for ( ret in timers ) break;
+				if ( !ret ) 
+					element.$timers = null;
+			}
+		}
+	}
+});
+
+if (jQuery.browser.msie)
+	jQuery(window).one("unload", function() {
+		var global = jQuery.timer.global;
+		for ( var label in global ) {
+			var els = global[label], i = els.length;
+			while ( --i )
+				jQuery.timer.remove(els[i], label);
+		}
+	});
+
+

data/vendor/assets/javascripts/alchemy/jquery/plugins/jquery.tipsy.js

@@ -0,0 +1,358 @@
+// tipsy, facebook style tooltips for jquery
+// version 1.0.0a
+// (c) 2008-2010 jason frame [jason@onehackoranother.com]
+// released under the MIT license
+
+(function($) {
+    
+    function maybeCall(thing, ctx) {
+        return (typeof thing == 'function') ? (thing.call(ctx)) : thing;
+    };
+    
+    function Tipsy(element, options) {
+        this.$element = $(element);
+        this.options = options;
+        this.enabled = true;
+        this.fixTitle();
+    };
+    
+    Tipsy.prototype = {
+        show: function() {
+            var title = this.getTitle(),
+                to_render = title;
+            if (title && this.enabled) {
+                var $tip = this.tip();
+
+                if(this.cached_title){
+                    title = this.cached_title;
+                }
+                else {
+                    this.fetchData();
+                }
+
+                $tip.find('.tipsy-inner')[this.options.html ? 'html' : 'text'](title); 
+                $tip[0].className = 'tipsy'; // reset classname in case of dynamic gravity
+                $tip.remove().css({top: 0, left: 0, visibility: 'hidden', display: 'block'}).prependTo(document.body);
+               
+
+                if (this.options.className) {
+                    $tip.addClass(maybeCall(this.options.className, this.$element[0]));
+                }
+
+                var that = this;
+                function tipOver() {
+                    that.hoverTooltip = true;
+                }
+                function tipOut() {
+                    if (that.hoverState == 'in') return;  // If field is still focused.
+                    that.hoverTooltip = false;
+                    if (that.options.trigger != 'manual') {
+                        var eventOut = that.options.trigger == 'hover' ? 'mouseleave.tipsy' : 'blur.tipsy';
+                        that.$element.trigger(eventOut);
+                    }
+                }
+
+                if (this.options.hoverable) {
+                    $tip.hover(tipOver, tipOut);
+                }
+                
+                var pos = $.extend({}, this.$element.offset(), {
+                    width: this.$element[0].offsetWidth,
+                    height: this.$element[0].offsetHeight
+                });
+                
+                var actualWidth = $tip[0].offsetWidth,
+                    actualHeight = $tip[0].offsetHeight,
+                    gravity = maybeCall(this.options.gravity, this.$element[0]);
+                
+                var tp;
+                switch (gravity.charAt(0)) {
+                    case 'n':
+                        tp = {top: pos.top + pos.height + this.options.offset, left: pos.left + pos.width / 2 - actualWidth / 2};
+                        break;
+                    case 's':
+                        tp = {top: pos.top - actualHeight - this.options.offset, left: pos.left + pos.width / 2 - actualWidth / 2};
+                        break;
+                    case 'e':
+                        tp = {top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth - this.options.offset};
+                        break;
+                    case 'w':
+                        tp = {top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width + this.options.offset};
+                        break;
+                }
+                
+                if (gravity.length == 2) {
+                    if (gravity.charAt(1) == 'w') {
+                        tp.left = pos.left + pos.width / 2 - 15;
+                    } else {
+                        tp.left = pos.left + pos.width / 2 - actualWidth + 15;
+                    }
+                }
+                
+                $tip.css(tp).addClass('tipsy-' + gravity);
+                $tip.find('.tipsy-arrow')[0].className = 'tipsy-arrow tipsy-arrow-' + gravity.charAt(0);
+                
+                if (this.options.fade) {
+                    $tip.stop().css({opacity: 0, display: 'block', visibility: 'visible'}).animate({opacity: this.options.opacity});
+                } else {
+                    $tip.css({visibility: 'visible', opacity: this.options.opacity});
+                }
+                // if there's a callback, run it
+                if( $.isFunction(this.options.afterShow) ) this.options.afterShow.apply(self);
+            }
+        },
+        hide: function() {
+            if (this.options.fade) {
+                this.tip().stop().fadeOut(function() { $(this).remove(); });
+            } else {
+                this.tip().remove();
+            }
+        },
+        
+        fixTitle: function() {
+            var $e = this.$element;
+            if ($e.attr('title') || typeof($e.attr('original-title')) != 'string') {
+                $e.attr('original-title', $e.attr('title') || '').removeAttr('title');
+            }
+        },
+        fetchData: function(){
+            var o = this.options, 
+                tipsy = this,
+                url = o.url;
+
+            if(o.url && !this.fetching){
+                if (typeof o.url === 'function') {
+                    url = url(this.$element);
+                }
+                $.get(url, {}, function(data){
+                    tipsy.cached_title = data;
+                    tipsy.fetching = true;
+                    if(tipsy.$tip.is(':visible')){
+                        tipsy.show();
+                    }
+                });
+            }
+        },
+        getTitle: function() {
+            var title, $e = this.$element, o = this.options;
+            this.fixTitle();
+            var title, o = this.options;
+            if (typeof o.title === 'string') {
+                title = $e.attr(o.title == 'title' ? 'original-title' : o.title);
+            } else if (typeof o.title == 'function') {
+                title = o.title.call($e[0]);
+            }
+            title = ('' + title).replace(/(^\s*|\s*$)/, "");
+            return title || o.fallback;
+        },
+        
+        tip: function() {
+            if (!this.$tip) {
+                this.$tip = $('<div class="tipsy"></div>').html('<div class="tipsy-arrow"></div><div class="tipsy-inner"></div>');
+            }
+            return this.$tip;
+        },
+        
+        validate: function() {
+            if (!this.$element[0].parentNode) {
+                this.hide();
+                this.$element = null;
+                this.options = null;
+            }
+        },
+        
+        enable: function() { this.enabled = true; },
+        disable: function() { this.enabled = false; },
+        toggleEnabled: function() { this.enabled = !this.enabled; }
+    };
+    
+    $.fn.tipsy = function(options) {
+        
+        if (options === true) {
+            return this.data('tipsy');
+        } else if (typeof options == 'string') {
+            var tipsy = this.data('tipsy');
+            if (tipsy) tipsy[options]();
+            return this;
+        }
+        
+        options = $.extend({}, $.fn.tipsy.defaults, options);
+        if (options.hoverable) {
+            options.delayOut = options.delayOut || 200;
+        }
+        
+        function get(ele) {
+            var tipsy = $.data(ele, 'tipsy');
+            if (!tipsy) {
+                tipsy = new Tipsy(ele, $.fn.tipsy.elementOptions(ele, options));
+                $.data(ele, 'tipsy', tipsy);
+            }
+            return tipsy;
+        }
+        
+        function enter() {
+            var tipsy = get(this);
+            if( options.activeTip === undefined ){
+                tipsy.hoverState = 'in';
+                if (options.delayIn == 0) {
+                    tipsy.show();
+                } else {
+                    tipsy.fixTitle();
+                    setTimeout(function() { if (tipsy.hoverState == 'in') tipsy.show(); }, options.delayIn);
+                }
+            }
+        };
+        
+        function leave() {
+            var tipsy = get(this);
+            if( tipsy.clickState !== 'on' ){
+                tipsy.hoverState = 'out';
+                if (options.delayOut == 0) {
+                    tipsy.hide();
+                } else {
+                    setTimeout(function() { if (tipsy.hoverState == 'out' && !tipsy.hoverTooltip) tipsy.hide(); }, options.delayOut);
+                }
+            }
+        };
+        
+        function sticky() {
+            var tipsy = get(this),
+                activeTip,
+                show = (tipsy.clickState === 'on') ? false : true;
+            handleClose();
+
+            if( show ){
+                tipsy.show();
+                tipsy.clickState = 'on';
+                options.activeTip = this;
+                $(this).addClass('tipsy-sticky-click');
+                options.stickyClick(this, tipsy.clickState);
+            }
+        }
+
+        function handleScroll(event) {
+            var target = $(event.target);
+
+            if( !(target.parents().hasClass('tipsy-inner')) ){
+                if( options.activeTip ){
+                    if(options.closeOnScroll){
+                        handleClose();
+                    }
+                    else {
+                        get(options.activeTip).show();
+                    }
+
+                }
+            }
+        }
+
+        function closeAll(){
+            var elements = $('.tipsy');
+
+            elements.remove();
+        }
+
+        function handleClose(){
+            var elements = $('.tipsy-sticky-click'),
+                i, length, tipsy, node;
+
+            for(i=0, length = elements.length; i < length; i += 1){
+                node = elements[i];
+                $(node).removeClass('tipsy-sticky-click');
+                tipsy = get(node);
+                tipsy.clickState = 'off';
+                tipsy.hide();
+                options.stickyClick(node, tipsy.clickState);
+            }
+            options.activeTip = undefined;
+        }
+
+        if (!options.live) this.each(function() { get(this); });
+        
+        if (options.trigger != 'manual') {
+            var binder   = options.live ? 'live' : 'bind',
+                eventIn  = options.trigger == 'hover' ? 'mouseenter.tipsy' : 'focus.tipsy',
+                eventOut = options.trigger == 'hover' ? 'mouseleave.tipsy' : 'blur.tipsy';
+            this[binder](eventIn, enter)[binder](eventOut, leave);
+        }
+        
+        if (options.stickyClick) {
+            this['live']('click', sticky);
+            $(document).bind('scroll', handleScroll);
+            $(document).bind('close.tipsy', handleClose);
+        }
+
+        $(document).bind('close.tipsy', function(){
+            closeAll();  
+        });
+
+        return this;
+        
+    };
+    
+    $.fn.tipsy.defaults = {
+        className: null,
+        delayIn: 0,
+        delayOut: 0,
+        fade: false,
+        fallback: '',
+        gravity: 'n',
+        html: false,
+        live: false,
+        hoverable: false,
+        stickyClick: false,
+        offset: 0,
+        opacity: 0.8,
+        title: 'title',
+        trigger: 'hover',
+        afterShow: null //call back after the tip is shown
+    };
+    
+    // Overwrite this method to provide options on a per-element basis.
+    // For example, you could store the gravity in a 'tipsy-gravity' attribute:
+    // return $.extend({}, options, {gravity: $(ele).attr('tipsy-gravity') || 'n' });
+    // (remember - do not modify 'options' in place!)
+    $.fn.tipsy.elementOptions = function(ele, options) {
+        return $.metadata ? $.extend({}, options, $(ele).metadata()) : options;
+    };
+    
+    $.fn.tipsy.autoNS = function() {
+        return $(this).offset().top > ($(document).scrollTop() + $(window).height() / 2) ? 's' : 'n';
+    };
+    
+    $.fn.tipsy.autoWE = function() {
+        return $(this).offset().left > ($(document).scrollLeft() + $(window).width() / 2) ? 'e' : 'w';
+    };
+    
+    /**
+     * yields a closure of the supplied parameters, producing a function that takes
+     * no arguments and is suitable for use as an autogravity function like so:
+     *
+     * @param margin (int) - distance from the viewable region edge that an
+     *        element should be before setting its tooltip's gravity to be away
+     *        from that edge.
+     * @param prefer (string, e.g. 'n', 'sw', 'w') - the direction to prefer
+     *        if there are no viewable region edges effecting the tooltip's
+     *        gravity. It will try to vary from this minimally, for example,
+     *        if 'sw' is preferred and an element is near the right viewable 
+     *        region edge, but not the top edge, it will set the gravity for
+     *        that element's tooltip to be 'se', preserving the southern
+     *        component.
+     */
+     $.fn.tipsy.autoBounds = function(margin, prefer) {
+		return function() {
+			var dir = {ns: prefer[0], ew: (prefer.length > 1 ? prefer[1] : false)},
+			    boundTop = $(document).scrollTop() + margin,
+			    boundLeft = $(document).scrollLeft() + margin,
+			    $this = $(this);
+
+			if ($this.offset().top < boundTop) dir.ns = 'n';
+			if ($this.offset().left < boundLeft) dir.ew = 'w';
+			if ($(window).width() + $(document).scrollLeft() - $this.offset().left < margin) dir.ew = 'e';
+			if ($(window).height() + $(document).scrollTop() - $this.offset().top < margin) dir.ns = 's';
+
+			return dir.ns + (dir.ew ? dir.ew : '');
+		}
+	};
+    
+})(jQuery);