transit 0.0.1 → 0.0.2

data/app/assets/javascripts/jqtools/overlay.js

@@ -0,0 +1,294 @@
+//= require './expose'
+
+/**
+ * @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 triggerr
+		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/app/assets/javascripts/jqtools/scrollable.js

@@ -0,0 +1,3 @@
+//= require './scrollable/base'
+//= require './scrollable/navigator'
+//= require './scrollable/autoscroll'

data/app/assets/javascripts/jqtools/scrollable/autoscroll.js

@@ -0,0 +1,81 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION / Scrollable Autoscroll
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/scrollable/autoscroll.html
+ *
+ * Since: September 2009
+ * Date: @DATE 
+ */
+(function($) {		
+
+	var t = $.tools.scrollable; 
+	
+	t.autoscroll = {
+		
+		conf: {
+			autoplay: true,
+			interval: 3000,
+			autopause: true
+		}
+	};	
+	
+	// jQuery plugin implementation
+	$.fn.autoscroll = function(conf) { 
+
+		if (typeof conf == 'number') {
+			conf = {interval: conf};	
+		}
+		
+		var opts = $.extend({}, t.autoscroll.conf, conf), ret;
+		
+		this.each(function() {		
+				
+			var api = $(this).data("scrollable");			
+			if (api) { ret = api; }
+			
+			// interval stuff
+			var timer, stopped = true;
+	
+			api.play = function() { 
+				
+				// do not start additional timer if already exists
+				if (timer) { return; }
+				
+				stopped = false;
+				
+				// construct new timer
+				timer = setInterval(function() { 
+					api.next();				
+				}, opts.interval);
+				
+			};	
+
+			api.pause = function() {
+				timer = clearInterval(timer);
+			};
+			
+			// when stopped - mouseover won't restart 
+			api.stop = function() {
+				api.pause();
+				stopped = true;	
+			};
+		
+			/* when mouse enters, autoscroll stops */
+			if (opts.autopause) {
+				api.getRoot().add(api.getNaviButtons()).hover(api.pause, api.play);
+			}
+			
+			if (opts.autoplay) {
+				api.play();				
+			}
+
+		});
+		
+		return opts.api ? ret : this;
+		
+	}; 
+	
+})(jQuery);

data/app/assets/javascripts/jqtools/scrollable/base.js

@@ -0,0 +1,335 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION Scrollable - New wave UI design
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/scrollable.html
+ *
+ * Since: March 2008
+ * Date: @DATE 
+ */
+(function($) { 
+
+	// static constructs
+	$.tools = $.tools || {version: '@VERSION'};
+	
+	$.tools.scrollable = {
+		
+		conf: {	
+			activeClass: 'active',
+			circular: false,
+			clonedClass: 'cloned',
+			disabledClass: 'disabled',
+			easing: 'swing',
+			initialIndex: 0,
+			item: null,
+			items: '.items',
+			keyboard: true,
+			mousewheel: false,
+			next: '.next',   
+			prev: '.prev', 
+			speed: 400,
+			vertical: false,
+			touch: true,
+			wheelSpeed: 0
+		} 
+	};
+					
+	// 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 find(root, query) { 
+		var el = $(query);
+		return el.length < 2 ? el : root.parent().find(query);
+	}
+	
+	var current;		
+	
+	// constructor
+	function Scrollable(root, conf) {   
+		
+		// current instance
+		var self = this, 
+			 fire = root.add(self),
+			 itemWrap = root.children(),
+			 index = 0,
+			 vertical = conf.vertical;
+				
+		if (!current) { current = self; } 
+		if (itemWrap.length > 1) { itemWrap = $(conf.items, root); }
+		
+		// methods
+		$.extend(self, {
+				
+			getConf: function() {
+				return conf;	
+			},			
+			
+			getIndex: function() {
+				return index;	
+			}, 
+
+			getSize: function() {
+				return self.getItems().size();	
+			},
+
+			getNaviButtons: function() {
+				return prev.add(next);	
+			},
+			
+			getRoot: function() {
+				return root;	
+			},
+			
+			getItemWrap: function() {
+				return itemWrap;	
+			},
+			
+			getItems: function() {
+				return itemWrap.children(conf.item).not("." + conf.clonedClass);	
+			},
+							
+			move: function(offset, time) {
+				return self.seekTo(index + offset, time);
+			},
+			
+			next: function(time) {
+				return self.move(1, time);	
+			},
+			
+			prev: function(time) {
+				return self.move(-1, time);	
+			},
+			
+			begin: function(time) {
+				return self.seekTo(0, time);	
+			},
+			
+			end: function(time) {
+				return self.seekTo(self.getSize() -1, time);	
+			},	
+			
+			focus: function() {
+				current = self;
+				return self;
+			},
+			
+			addItem: function(item) {
+				item = $(item);
+				
+				if (!conf.circular)  {
+					itemWrap.append(item);
+				} else {
+					itemWrap.children("." + conf.clonedClass + ":last").before(item);
+					itemWrap.children("." + conf.clonedClass + ":first").replaceWith(item.clone().addClass(conf.clonedClass)); 						
+				}
+				
+				fire.trigger("onAddItem", [item]);
+				return self;
+			},
+			
+			
+			/* all seeking functions depend on this */		
+			seekTo: function(i, time, fn) {	
+				
+				// ensure numeric index
+				if (!i.jquery) { i *= 1; }
+				
+				// avoid seeking from end clone to the beginning
+				if (conf.circular && i === 0 && index == -1 && time !== 0) { return self; }
+				
+				// check that index is sane				
+				if (!conf.circular && i < 0 || i > self.getSize() || i < -1) { return self; }
+				
+				var item = i;
+			
+				if (i.jquery) {
+					i = self.getItems().index(i);	
+					
+				} else {
+					item = self.getItems().eq(i);
+				}  
+				
+				// onBeforeSeek
+				var e = $.Event("onBeforeSeek"); 
+				if (!fn) {
+					fire.trigger(e, [i, time]);				
+					if (e.isDefaultPrevented() || !item.length) { return self; }			
+				}  
+	
+				var props = vertical ? {top: -item.position().top} : {left: -item.position().left};  
+				
+				index = i;
+				current = self;  
+				if (time === undefined) { time = conf.speed; }   
+				
+				itemWrap.animate(props, time, conf.easing, fn || function() { 
+					fire.trigger("onSeek", [i]);		
+				});	 
+				
+				return self; 
+			}					
+			
+		});
+				
+		// callbacks	
+		$.each(['onBeforeSeek', 'onSeek', 'onAddItem'], function(i, name) {
+				
+			// configuration
+			if ($.isFunction(conf[name])) { 
+				$(self).bind(name, conf[name]); 
+			}
+			
+			self[name] = function(fn) {
+				if (fn) { $(self).bind(name, fn); }
+				return self;
+			};
+		});  
+		
+		// circular loop
+		if (conf.circular) {
+			
+			var cloned1 = self.getItems().slice(-1).clone().prependTo(itemWrap),
+				 cloned2 = self.getItems().eq(1).clone().appendTo(itemWrap);
+				
+			cloned1.add(cloned2).addClass(conf.clonedClass);
+			
+			self.onBeforeSeek(function(e, i, time) {
+
+				
+				if (e.isDefaultPrevented()) { return; }
+				
+				/*
+					1. animate to the clone without event triggering
+					2. seek to correct position with 0 speed
+				*/
+				if (i == -1) {
+					self.seekTo(cloned1, time, function()  {
+						self.end(0);		
+					});          
+					return e.preventDefault();
+					
+				} else if (i == self.getSize()) {
+					self.seekTo(cloned2, time, function()  {
+						self.begin(0);		
+					});	
+				}
+				
+			});
+			
+			// seek over the cloned item
+			self.seekTo(0, 0, function() {});
+		}
+		
+		// next/prev buttons
+		var prev = find(root, conf.prev).click(function() { self.prev(); }),
+			 next = find(root, conf.next).click(function() { self.next(); });	
+		
+		if (!conf.circular && self.getSize() > 1) {
+			
+			self.onBeforeSeek(function(e, i) {
+				setTimeout(function() {
+					if (!e.isDefaultPrevented()) {
+						prev.toggleClass(conf.disabledClass, i <= 0);
+						next.toggleClass(conf.disabledClass, i >= self.getSize() -1);
+					}
+				}, 1);
+			}); 
+			
+			if (!conf.initialIndex) {
+				prev.addClass(conf.disabledClass);	
+			}
+		}
+			
+		// mousewheel support
+		if (conf.mousewheel && $.fn.mousewheel) {
+			root.mousewheel(function(e, delta)  {
+				if (conf.mousewheel) {
+					self.move(delta < 0 ? 1 : -1, conf.wheelSpeed || 50);
+					return false;
+				}
+			});			
+		}
+		
+		// touch event
+		if (conf.touch) {
+			var touch = {};
+			
+			itemWrap[0].ontouchstart = function(e) {
+				var t = e.touches[0];
+				touch.x = t.clientX;
+				touch.y = t.clientY;
+			};
+			
+			itemWrap[0].ontouchmove = function(e) {
+				
+				// only deal with one finger
+				if (e.touches.length == 1 && !itemWrap.is(":animated")) {			
+					var t = e.touches[0],
+						 deltaX = touch.x - t.clientX,
+						 deltaY = touch.y - t.clientY;
+	
+					self[vertical && deltaY > 0 || !vertical && deltaX > 0 ? 'next' : 'prev']();				
+					e.preventDefault();
+				}
+			};
+		}
+		
+		if (conf.keyboard)  {
+			
+			$(document).bind("keydown.scrollable", function(evt) {
+
+				// skip certain conditions
+				if (!conf.keyboard || evt.altKey || evt.ctrlKey || $(evt.target).is(":input")) { return; }
+				
+				// does this instance have focus?
+				if (conf.keyboard != 'static' && current != self) { return; }
+					
+				var key = evt.keyCode;
+			
+				if (vertical && (key == 38 || key == 40)) {
+					self.move(key == 38 ? -1 : 1);
+					return evt.preventDefault();
+				}
+				
+				if (!vertical && (key == 37 || key == 39)) {					
+					self.move(key == 37 ? -1 : 1);
+					return evt.preventDefault();
+				}	  
+				
+			});  
+		}
+		
+		// initial index
+		if (conf.initialIndex) {
+			self.seekTo(conf.initialIndex, 0, function() {});
+		}
+	} 
+
+		
+	// jQuery plugin implementation
+	$.fn.scrollable = function(conf) { 
+			
+		// already constructed --> return API
+		var el = this.data("scrollable");
+		if (el) { return el; }		 
+
+		conf = $.extend({}, $.tools.scrollable.conf, conf); 
+		
+		this.each(function() {			
+			el = new Scrollable($(this), conf);
+			$(this).data("scrollable", el);	
+		});
+		
+		return conf.api ? el: this; 
+		
+	};
+			
+	
+})(jQuery);