jquery-tools 0.0.2

data/vendor/assets/javascripts/overlay/overlay.apple.js

@@ -0,0 +1,155 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION / Overlay Apple effect. 
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/overlay/apple.html
+ *
+ * Since: July 2009
+ * Date: @DATE 
+ */
+(function($) { 
+
+	// version number
+	var t = $.tools.overlay,
+		 w = $(window); 
+		
+	// extend global configuragion with effect specific defaults
+	$.extend(t.conf, { 
+		start: { 
+			top: null,
+			left: null
+		},
+		
+		fadeInSpeed: 'fast',
+		zIndex: 9999
+	});			
+	
+	// utility function
+	function getPosition(el) {
+		var p = el.offset();
+		return {
+			top: p.top + el.height() / 2, 
+			left: p.left + el.width() / 2
+		}; 
+	}
+	
+//{{{ load 
+
+	var loadEffect = function(pos, onLoad) {
+		
+		var overlay = this.getOverlay(),
+			 conf = this.getConf(),
+			 trigger = this.getTrigger(),
+			 self = this,
+			 oWidth = overlay.outerWidth({margin:true}),
+			 img = overlay.data("img"),
+			 position = conf.fixed ? 'fixed' : 'absolute';  
+		
+		
+		// growing image is required.
+		if (!img) { 
+			var bg = overlay.css("backgroundImage");
+			
+			if (!bg) { 
+				throw "background-image CSS property not set for overlay"; 
+			}
+			
+			// url("bg.jpg") --> bg.jpg
+			bg = bg.slice(bg.indexOf("(") + 1, bg.indexOf(")")).replace(/\"/g, "");
+			overlay.css("backgroundImage", "none");
+			
+			img = $('<img src="' + bg + '"/>');
+			img.css({border:0, display:'none'}).width(oWidth);			
+			$('body').append(img); 
+			overlay.data("img", img);
+		}
+		
+		// initial top & left
+		var itop = conf.start.top || Math.round(w.height() / 2), 
+			 ileft = conf.start.left || Math.round(w.width() / 2);
+		
+		if (trigger) {
+			var p = getPosition(trigger);
+			itop = p.top;
+			ileft = p.left;
+		} 
+		
+		// put overlay into final position
+		if (conf.fixed) {
+			itop -= w.scrollTop();
+			ileft -= w.scrollLeft();
+		} else {
+			pos.top += w.scrollTop();
+			pos.left += w.scrollLeft();				
+		}
+			
+		// initialize background image and make it visible
+		img.css({
+			position: 'absolute',
+			top: itop, 
+			left: ileft,
+			width: 0,
+			zIndex: conf.zIndex
+		}).show();
+		
+		pos.position = position;
+		overlay.css(pos);
+		
+		// begin growing
+		img.animate({			
+			top: overlay.css("top"), 
+			left: overlay.css("left"), 
+			width: oWidth}, conf.speed, function() {
+			
+			// set close button and content over the image
+			overlay.css("zIndex", conf.zIndex + 1).fadeIn(conf.fadeInSpeed, function()  { 
+					
+				if (self.isOpened() && !$(this).index(overlay)) {	
+					onLoad.call(); 
+				} else {
+					overlay.hide();	
+				} 
+			});
+			
+		}).css("position", position);
+		
+	};
+//}}}
+	
+	
+	var closeEffect = function(onClose) {
+
+		// variables
+		var overlay = this.getOverlay().hide(), 
+			 conf = this.getConf(),
+			 trigger = this.getTrigger(),
+			 img = overlay.data("img"),
+			 
+			 css = { 
+			 	top: conf.start.top, 
+			 	left: conf.start.left, 
+			 	width: 0 
+			 };
+		
+		// trigger position
+		if (trigger) { $.extend(css, getPosition(trigger)); }
+		
+		
+		// change from fixed to absolute position
+		if (conf.fixed) {
+			img.css({position: 'absolute'})
+				.animate({ top: "+=" + w.scrollTop(), left: "+=" + w.scrollLeft()}, 0);
+		}
+		 
+		// shrink image		
+		img.animate(css, conf.closeSpeed, onClose);	
+	};
+	
+	
+	// add overlay effect	
+	t.addEffect("apple", loadEffect, closeEffect); 
+	
+})(jQuery);	
+		

data/vendor/assets/javascripts/overlay/overlay.js

@@ -0,0 +1,293 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION Overlay - Overlay base. Extend it.
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/overlay/
+ *
+ * Since: March 2008
+ * Date: @DATE 
+ */
+(function($) { 
+
+	// static constructs
+	$.tools = $.tools || {version: '@VERSION'};
+	
+	$.tools.overlay = {
+		
+		addEffect: function(name, loadFn, closeFn) {
+			effects[name] = [loadFn, closeFn];	
+		},
+	
+		conf: {  
+			close: null,	
+			closeOnClick: true,
+			closeOnEsc: true,			
+			closeSpeed: 'fast',
+			effect: 'default',
+			
+			// since 1.2. fixed positioning not supported by IE6
+			fixed: !$.browser.msie || $.browser.version > 6, 
+			
+			left: 'center',		
+			load: false, // 1.2
+			mask: null,  
+			oneInstance: true,
+			speed: 'normal',
+			target: null, // target element to be overlayed. by default taken from [rel]
+			top: '10%'
+		}
+	};
+
+	
+	var instances = [], effects = {};
+		
+	// the default effect. nice and easy!
+	$.tools.overlay.addEffect('default', 
+		
+		/* 
+			onLoad/onClose functions must be called otherwise none of the 
+			user supplied callback methods won't be called
+		*/
+		function(pos, onLoad) {
+			
+			var conf = this.getConf(),
+				 w = $(window);				 
+				
+			if (!conf.fixed)  {
+				pos.top += w.scrollTop();
+				pos.left += w.scrollLeft();
+			} 
+				
+			pos.position = conf.fixed ? 'fixed' : 'absolute';
+			this.getOverlay().css(pos).fadeIn(conf.speed, onLoad); 
+			
+		}, function(onClose) {
+			this.getOverlay().fadeOut(this.getConf().closeSpeed, onClose); 			
+		}		
+	);		
+
+	
+	function Overlay(trigger, conf) {		
+		
+		// private variables
+		var self = this,
+			 fire = trigger.add(self),
+			 w = $(window), 
+			 closers,            
+			 overlay,
+			 opened,
+			 maskConf = $.tools.expose && (conf.mask || conf.expose),
+			 uid = Math.random().toString().slice(10);		
+		
+			 
+		// mask configuration
+		if (maskConf) {			
+			if (typeof maskConf == 'string') { maskConf = {color: maskConf}; }
+			maskConf.closeOnClick = maskConf.closeOnEsc = false;
+		}			 
+		 
+		// get overlay and trigger
+		var jq = conf.target || trigger.attr("rel");
+		overlay = jq ? $(jq) : null || trigger;	
+		
+		// overlay not found. cannot continue
+		if (!overlay.length) { throw "Could not find Overlay: " + jq; }
+		
+		// trigger's click event
+		if (trigger && trigger.index(overlay) == -1) {
+			trigger.click(function(e) {				
+				self.load(e);
+				return e.preventDefault();
+			});
+		}   			
+		
+		// API methods  
+		$.extend(self, {
+
+			load: function(e) {
+				
+				// can be opened only once
+				if (self.isOpened()) { return self; }
+				
+				// find the effect
+		 		var eff = effects[conf.effect];
+		 		if (!eff) { throw "Overlay: cannot find effect : \"" + conf.effect + "\""; }
+				
+				// close other instances?
+				if (conf.oneInstance) {
+					$.each(instances, function() {
+						this.close(e);
+					});
+				}
+				
+				// onBeforeLoad
+				e = e || $.Event();
+				e.type = "onBeforeLoad";
+				fire.trigger(e);				
+				if (e.isDefaultPrevented()) { return self; }				
+
+				// opened
+				opened = true;
+				
+				// possible mask effect
+				if (maskConf) { $(overlay).expose(maskConf); }				
+				
+				// position & dimensions 
+				var top = conf.top,					
+					 left = conf.left,
+					 oWidth = overlay.outerWidth({margin:true}),
+					 oHeight = overlay.outerHeight({margin:true}); 
+				
+				if (typeof top == 'string')  {
+					top = top == 'center' ? Math.max((w.height() - oHeight) / 2, 0) : 
+						parseInt(top, 10) / 100 * w.height();			
+				}				
+				
+				if (left == 'center') { left = Math.max((w.width() - oWidth) / 2, 0); }
+
+				
+		 		// load effect  		 		
+				eff[0].call(self, {top: top, left: left}, function() {					
+					if (opened) {
+						e.type = "onLoad";
+						fire.trigger(e);
+					}
+				}); 				
+
+				// mask.click closes overlay
+				if (maskConf && conf.closeOnClick) {
+					$.mask.getMask().one("click", self.close); 
+				}
+				
+				// when window is clicked outside overlay, we close
+				if (conf.closeOnClick) {
+					$(document).bind("click." + uid, function(e) { 
+						if (!$(e.target).parents(overlay).length) { 
+							self.close(e); 
+						}
+					});						
+				}						
+			
+				// keyboard::escape
+				if (conf.closeOnEsc) { 
+
+					// one callback is enough if multiple instances are loaded simultaneously
+					$(document).bind("keydown." + uid, function(e) {
+						if (e.keyCode == 27) { 
+							self.close(e);	 
+						}
+					});			
+				}
+
+				
+				return self; 
+			}, 
+			
+			close: function(e) {
+
+				if (!self.isOpened()) { return self; }
+				
+				e = e || $.Event();
+				e.type = "onBeforeClose";
+				fire.trigger(e);				
+				if (e.isDefaultPrevented()) { return; }				
+				
+				opened = false;
+				
+				// close effect
+				effects[conf.effect][1].call(self, function() {
+					e.type = "onClose";
+					fire.trigger(e); 
+				});
+				
+				// unbind the keyboard / clicking actions
+				$(document).unbind("click." + uid).unbind("keydown." + uid);		  
+				
+				if (maskConf) {
+					$.mask.close();		
+				}
+				 
+				return self;
+			}, 
+			
+			getOverlay: function() {
+				return overlay;	
+			},
+			
+			getTrigger: function() {
+				return trigger;	
+			},
+			
+			getClosers: function() {
+				return closers;	
+			},			
+
+			isOpened: function()  {
+				return opened;
+			},
+			
+			// manipulate start, finish and speeds
+			getConf: function() {
+				return conf;	
+			}			
+			
+		});
+		
+		// callbacks	
+		$.each("onBeforeLoad,onStart,onLoad,onBeforeClose,onClose".split(","), function(i, name) {
+				
+			// configuration
+			if ($.isFunction(conf[name])) { 
+				$(self).bind(name, conf[name]); 
+			}
+
+			// API
+			self[name] = function(fn) {
+				if (fn) { $(self).bind(name, fn); }
+				return self;
+			};
+		});
+		
+		// close button
+		closers = overlay.find(conf.close || ".close");		
+		
+		if (!closers.length && !conf.close) {
+			closers = $('<a class="close"></a>');
+			overlay.prepend(closers);	
+		}		
+		
+		closers.click(function(e) { 
+			self.close(e);  
+		});	
+		
+		// autoload
+		if (conf.load) { self.load(); }
+		
+	}
+	
+	// jQuery plugin initialization
+	$.fn.overlay = function(conf) {   
+		
+		// already constructed --> return API
+		var el = this.data("overlay");
+		if (el) { return el; }	  		 
+		
+		if ($.isFunction(conf)) {
+			conf = {onBeforeLoad: conf};	
+		}
+
+		conf = $.extend(true, {}, $.tools.overlay.conf, conf);
+		
+		this.each(function() {		
+			el = new Overlay($(this), conf);
+			instances.push(el);
+			$(this).data("overlay", el);	
+		});
+		
+		return conf.api ? el: this;		
+	}; 
+	
+})(jQuery);
+

data/vendor/assets/javascripts/rangeinput/rangeinput.js

@@ -0,0 +1,471 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION Rangeinput - HTML5 <input type="range" /> for humans
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/rangeinput/
+ *
+ * Since: Mar 2010
+ * Date: @DATE 
+ */
+(function($) {
+	 
+	$.tools = $.tools || {version: '@VERSION'};
+	 
+	var tool;
+	
+	tool = $.tools.rangeinput = {
+		                            
+		conf: {
+			min: 0,
+			max: 100,		// as defined in the standard
+			step: 'any', 	// granularity of the value. a non-zero float or int (or "any")
+			steps: 0,
+			value: 0,			
+			precision: undefined,
+			vertical: 0,
+			keyboard: true,
+			progress: false,
+			speed: 100,
+			
+			// set to null if not needed
+			css: {
+				input:		'range',
+				slider: 		'slider',
+				progress: 	'progress',
+				handle: 		'handle'					
+			}
+
+		} 
+	};
+	
+//{{{ fn.drag
+		
+	/* 
+		FULL featured drag and drop. 0.7 kb minified, 0.3 gzipped. done.
+		Who told d'n'd is rocket science? Usage:
+		
+		$(".myelement").drag({y: false}).bind("drag", function(event, x, y) {
+			// do your custom thing
+		});
+		 
+		Configuration: 
+			x: true, 		// enable horizontal drag
+			y: true, 		// enable vertical drag 
+			drag: true 		// true = perform drag, false = only fire events 
+			
+		Events: dragStart, drag, dragEnd. 
+	*/
+	var doc, draggable;
+	
+	$.fn.drag = function(conf) {
+		
+		// disable IE specialities
+		document.ondragstart = function () { return false; };
+		
+		conf = $.extend({x: true, y: true, drag: true}, conf);
+	
+		doc = doc || $(document).bind("mousedown mouseup", function(e) {
+				
+			var el = $(e.target);  
+			
+			// start 
+			if (e.type == "mousedown" && el.data("drag")) {
+				
+				var offset = el.position(),
+					 x0 = e.pageX - offset.left, 
+					 y0 = e.pageY - offset.top,
+					 start = true;    
+				
+				doc.bind("mousemove.drag", function(e) {  
+					var x = e.pageX -x0, 
+						 y = e.pageY -y0,
+						 props = {};
+					
+					if (conf.x) { props.left = x; }
+					if (conf.y) { props.top = y; } 
+					
+					if (start) {
+						el.trigger("dragStart");
+						start = false;
+					}
+					if (conf.drag) { el.css(props); }
+					el.trigger("drag", [y, x]);
+					draggable = el;
+				}); 
+				
+				e.preventDefault();
+				
+			} else {
+				
+				try {
+					if (draggable) {  
+						draggable.trigger("dragEnd");  
+					}
+				} finally { 
+					doc.unbind("mousemove.drag");
+					draggable = null; 
+				}
+			} 
+							
+		});
+		
+		return this.data("drag", true); 
+	};	
+
+//}}}
+	
+
+	
+	function round(value, precision) {
+		var n = Math.pow(10, precision);
+		return Math.round(value * n) / n;
+	}
+	
+	// get hidden element's width or height even though it's hidden
+	function dim(el, key) {
+		var v = parseInt(el.css(key), 10);
+		if (v) { return v; }
+		var s = el[0].currentStyle; 
+		return s && s.width && parseInt(s.width, 10);	
+	}
+	
+	function hasEvent(el) {
+		var e = el.data("events");
+		return e && e.onSlide;
+	}
+	
+	function RangeInput(input, conf) {
+		
+		// private variables
+		var self = this,  
+			 css = conf.css, 
+			 root = $("<div><div/><a href='#'/></div>").data("rangeinput", self),	
+			 vertical,		
+			 value,			// current value
+			 origo,			// handle's start point
+			 len,				// length of the range
+			 pos;				// current position of the handle		
+		 
+		// create range	 
+		input.before(root);	
+		
+		var handle = root.addClass(css.slider).find("a").addClass(css.handle), 	
+			 progress = root.find("div").addClass(css.progress);
+		
+		// get (HTML5) attributes into configuration
+		$.each("min,max,step,value".split(","), function(i, key) {
+			var val = input.attr(key);
+			if (parseFloat(val)) {
+				conf[key] = parseFloat(val, 10);
+			}
+		});			   
+		
+		var range = conf.max - conf.min, 
+			 step = conf.step == 'any' ? 0 : conf.step,
+			 precision = conf.precision;
+			 
+		if (precision === undefined) {
+			try {
+				precision = step.toString().split(".")[1].length;
+			} catch (err) {
+				precision = 0;	
+			}
+		}  
+		
+		// Replace built-in range input (type attribute cannot be changed)
+		if (input.attr("type") == 'range') {			
+			var def = input.clone().wrap("<div/>").parent().html(),
+				 clone = $(def.replace(/type/i, "type=text data-orig-type"));
+				 
+			clone.val(conf.value);
+			input.replaceWith(clone);
+			input = clone;
+		}
+		
+		input.addClass(css.input);
+			 
+		var fire = $(self).add(input), fireOnSlide = true;
+
+		
+		/**
+		 	The flesh and bone of this tool. All sliding is routed trough this.
+			
+			@param evt types include: click, keydown, blur and api (setValue call)
+			@param isSetValue when called trough setValue() call (keydown, blur, api)
+			
+			vertical configuration gives additional complexity. 
+		 */
+		function slide(evt, x, val, isSetValue) { 
+
+			// calculate value based on slide position
+			if (val === undefined) {
+				val = x / len * range;  
+				
+			// x is calculated based on val. we need to strip off min during calculation	
+			} else if (isSetValue) {
+				val -= conf.min;	
+			}
+			
+			// increment in steps
+			if (step) {
+				val = Math.round(val / step) * step;
+			}
+
+			// count x based on value or tweak x if stepping is done
+			if (x === undefined || step) {
+				x = val * len / range;	
+			}  
+			
+			// crazy value?
+			if (isNaN(val)) { return self; }       
+			
+			// stay within range
+			x = Math.max(0, Math.min(x, len));  
+			val = x / len * range;   
+
+			if (isSetValue || !vertical) {
+				val += conf.min;
+			}
+			
+			// in vertical ranges value rises upwards
+			if (vertical) {
+				if (isSetValue) {
+					x = len -x;
+				} else {
+					val = conf.max - val;	
+				}
+			}	
+			
+			// precision
+			val = round(val, precision); 
+			
+			// onSlide
+			var isClick = evt.type == "click";
+			if (fireOnSlide && value !== undefined && !isClick) {
+				evt.type = "onSlide";           
+				fire.trigger(evt, [val, x]); 
+				if (evt.isDefaultPrevented()) { return self; }  
+			}				
+			
+			// speed & callback
+			var speed = isClick ? conf.speed : 0,
+				 callback = isClick ? function()  {
+					evt.type = "change";
+					fire.trigger(evt, [val]);
+				 } : null;
+			
+			if (vertical) {
+				handle.animate({top: x}, speed, callback);
+				if (conf.progress) { 
+					progress.animate({height: len - x + handle.height() / 2}, speed);	
+				}				
+				
+			} else {
+				handle.animate({left: x}, speed, callback);
+				if (conf.progress) { 
+					progress.animate({width: x + handle.width() / 2}, speed); 
+				}
+			}
+			
+			// store current value
+			value = val; 
+			pos = x;			 
+			
+			// se input field's value
+			input.val(val);
+
+			return self;
+		} 
+		
+		
+		$.extend(self, {  
+			
+			getValue: function() {
+				return value;	
+			},
+			
+			setValue: function(val, e) {
+				init();
+				return slide(e || $.Event("api"), undefined, val, true); 
+			}, 			  
+			
+			getConf: function() {
+				return conf;	
+			},
+			
+			getProgress: function() {
+				return progress;	
+			},
+
+			getHandle: function() {
+				return handle;	
+			},			
+			
+			getInput: function() {
+				return input;	
+			}, 
+				
+			step: function(am, e) {
+				e = e || $.Event();
+				var step = conf.step == 'any' ? 1 : conf.step;
+				self.setValue(value + step * (am || 1), e);	
+			},
+			
+			// HTML5 compatible name
+			stepUp: function(am) { 
+				return self.step(am || 1);
+			},
+			
+			// HTML5 compatible name
+			stepDown: function(am) { 
+				return self.step(-am || -1);
+			}
+			
+		});
+		
+		// callbacks
+		$.each("onSlide,change".split(","), function(i, name) {
+				
+			// from configuration
+			if ($.isFunction(conf[name]))  {
+				$(self).bind(name, conf[name]);	
+			}
+			
+			// API methods
+			self[name] = function(fn) {
+				if (fn) { $(self).bind(name, fn); }
+				return self;	
+			};
+		}); 
+			
+
+		// dragging		                                  
+		handle.drag({drag: false}).bind("dragStart", function() {
+		
+			/* do some pre- calculations for seek() function. improves performance */			
+			init();
+			
+			// avoid redundant event triggering (= heavy stuff)
+			fireOnSlide = hasEvent($(self)) || hasEvent(input);
+			
+				
+		}).bind("drag", function(e, y, x) {        
+			
+			if (input.is(":disabled")) { return false; } 
+			slide(e, vertical ? y : x); 
+			
+		}).bind("dragEnd", function(e) {
+			if (!e.isDefaultPrevented()) {
+				e.type = "change";
+				fire.trigger(e, [value]);	 
+			}
+			
+		}).click(function(e) {
+			return e.preventDefault();	 
+		});		
+		
+		// clicking
+		root.click(function(e) { 
+			if (input.is(":disabled") || e.target == handle[0]) { 
+				return e.preventDefault(); 
+			}				  
+			init(); 
+			var fix = vertical ? handle.height() / 2 : handle.width() / 2;
+			slide(e, vertical ? len-origo-fix + e.pageY  : e.pageX -origo -fix);  
+		});
+
+		if (conf.keyboard) {
+			
+			input.keydown(function(e) {
+		
+				if (input.attr("readonly")) { return; }
+				
+				var key = e.keyCode,
+					 up = $([75, 76, 38, 33, 39]).index(key) != -1,
+					 down = $([74, 72, 40, 34, 37]).index(key) != -1;					 
+					 
+				if ((up || down) && !(e.shiftKey || e.altKey || e.ctrlKey)) {
+				
+					// UP: 	k=75, l=76, up=38, pageup=33, right=39			
+					if (up) {
+						self.step(key == 33 ? 10 : 1, e);
+						
+					// DOWN:	j=74, h=72, down=40, pagedown=34, left=37
+					} else if (down) {
+						self.step(key == 34 ? -10 : -1, e); 
+					} 
+					return e.preventDefault();
+				} 
+			});
+		}
+		
+		
+		input.blur(function(e) {	
+			var val = $(this).val();
+			if (val !== value) {
+				self.setValue(val, e);
+			}
+		});    
+		
+		
+		// HTML5 DOM methods
+		$.extend(input[0], { stepUp: self.stepUp, stepDown: self.stepDown});
+		
+		
+		// calculate all dimension related stuff
+		function init() { 
+		 	vertical = conf.vertical || dim(root, "height") > dim(root, "width");
+		 
+			if (vertical) {
+				len = dim(root, "height") - dim(handle, "height");
+				origo = root.offset().top + len; 
+				
+			} else {
+				len = dim(root, "width") - dim(handle, "width");
+				origo = root.offset().left;	  
+			} 	  
+		}
+		
+		function begin() {
+			init();	
+			self.setValue(conf.value !== undefined ? conf.value : conf.min);
+		} 
+		begin();
+		
+		// some browsers cannot get dimensions upon initialization
+		if (!len) {  
+			$(window).load(begin);
+		}
+	}
+	
+	$.expr[':'].range = function(el) {
+		var type = el.getAttribute("type");
+		return type && type == 'range' || !!$(el).filter("input").data("rangeinput");
+	};
+	
+	
+	// jQuery plugin implementation
+	$.fn.rangeinput = function(conf) {
+
+		// already installed
+		if (this.data("rangeinput")) { return this; } 
+		
+		// extend configuration with globals
+		conf = $.extend(true, {}, tool.conf, conf);		
+		
+		var els;
+		
+		this.each(function() {				
+			var el = new RangeInput($(this), $.extend(true, {}, conf));		 
+			var input = el.getInput().data("rangeinput", el);
+			els = els ? els.add(input) : input;	
+		});		
+		
+		return els ? els : this; 
+	};	
+	
+	
+}) (jQuery);
+