jqtools-rails 0.1.1

data/vendor/assets/javascripts/tabs/tabs.slideshow.js

@@ -0,0 +1,191 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION Slideshow - Extend it.
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/tabs/slideshow.html
+ *
+ * Since: September 2009
+ * Date: @DATE 
+ */
+(function($) {
+	
+	var tool;
+	
+	tool = $.tools.tabs.slideshow = { 
+
+		conf: {
+			next: '.forward',
+			prev: '.backward',
+			disabledClass: 'disabled',
+			autoplay: false,
+			autopause: true,
+			interval: 3000, 
+			clickable: true,
+			api: false
+		}
+	};  
+	
+	function Slideshow(root, conf) {
+	
+		var self = this,
+			 fire = root.add(this),
+			 tabs = root.data("tabs"),
+			 timer, 
+			 stopped = true;
+		
+		// next / prev buttons
+		function find(query) {
+			var el = $(query);
+			return el.length < 2 ? el : root.parent().find(query);	
+		}	
+		
+		var nextButton = find(conf.next).click(function() {
+			tabs.next();		
+		});
+		
+		var prevButton = find(conf.prev).click(function() {
+			tabs.prev();		
+		}); 
+
+    /**
+    *
+    *   Similar fix for autoscroll animation queue problem
+    */
+    function next(){
+      timer = setTimeout(function(){
+        tabs.next();
+      }, conf.interval);
+    }
+
+		// extend the Tabs API with slideshow methods			
+		$.extend(self, {
+				
+			// return tabs API
+			getTabs: function() {
+				return tabs;	
+			},
+			
+			getConf: function() {
+				return conf;	
+			},
+				
+			play: function() {
+	
+				// do not start additional timer if already exists
+				if (timer) { return self; }	
+				
+				// onBeforePlay
+				var e = $.Event("onBeforePlay");
+				fire.trigger(e);				
+				if (e.isDefaultPrevented()) { return self; }				
+				
+				stopped = false;				
+				
+				// onPlay
+				fire.trigger("onPlay");				
+				
+				fire.bind('onClick', next);
+				next();
+				
+				return self;
+			},
+		
+			pause: function() {
+				
+				if (!timer) { return self; }
+
+				// onBeforePause
+				var e = $.Event("onBeforePause");
+				fire.trigger(e);					
+				if (e.isDefaultPrevented()) { return self; }		
+				
+				timer = clearTimeout(timer);
+				
+				// onPause
+				fire.trigger("onPause");	
+				
+				fire.unbind('onClick', next);
+				
+				return self;
+			},
+			
+			// resume playing if not stopped
+			resume: function() {
+				stopped || self.play();
+			},
+			
+			// when stopped - mouseover won't restart 
+			stop: function() {					
+				self.pause();
+				stopped = true;	
+			}
+			
+		});
+
+		// callbacks	
+		$.each("onBeforePlay,onPlay,onBeforePause,onPause".split(","), function(i, name) {
+				
+			// configuration
+			if ($.isFunction(conf[name]))  {
+				$(self).bind(name, conf[name]);	
+			}
+			
+			// API methods				
+			self[name] = function(fn) {
+				return $(self).bind(name, fn);
+			};
+		});	
+		
+	
+		/* when mouse enters, slideshow stops */
+		if (conf.autopause) {
+			tabs.getTabs().add(nextButton).add(prevButton).add(tabs.getPanes()).hover(self.pause, self.resume);
+		} 
+		
+		if (conf.autoplay) {
+			self.play();	
+		}
+		
+		if (conf.clickable) {
+			tabs.getPanes().click(function()  {
+				tabs.next();
+			});
+		} 
+		
+		// manage disabling of next/prev buttons
+		if (!tabs.getConf().rotate) {
+			
+			var disabled = conf.disabledClass;
+			
+			if (!tabs.getIndex()) {
+				prevButton.addClass(disabled);
+			}
+			
+			tabs.onBeforeClick(function(e, i)  { 
+				prevButton.toggleClass(disabled, !i);
+				nextButton.toggleClass(disabled, i == tabs.getTabs().length -1); 
+			});
+		}  
+	}
+	
+	// jQuery plugin implementation
+	$.fn.slideshow = function(conf) {
+	
+		// return existing instance
+		var el = this.data("slideshow");
+		if (el) { return el; }
+ 
+		conf = $.extend({}, tool.conf, conf);
+		
+		this.each(function() {
+			el = new Slideshow($(this), conf);
+			$(this).data("slideshow", el); 			
+		});	
+		
+		return conf.api ? el : this;
+	};
+	
+})(jQuery); 
+

data/vendor/assets/javascripts/toolbox/toolbox.expose.js

@@ -0,0 +1,224 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION / Expose - Dim the lights
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/toolbox/expose.html
+ *
+ * Since: Mar 2010
+ * Date: @DATE 
+ */
+(function($) { 	
+
+	// static constructs
+	$.tools = $.tools || {version: '@VERSION'};
+	
+	var tool;
+	
+	tool = $.tools.expose = {
+		
+		conf: {	
+			maskId: 'exposeMask',
+			loadSpeed: 'slow',
+			closeSpeed: 'fast',
+			closeOnClick: true,
+			closeOnEsc: true,
+			
+			// css settings
+			zIndex: 9998,
+			opacity: 0.8,
+			startOpacity: 0,
+			color: '#fff',
+			
+			// callbacks
+			onLoad: null,
+			onClose: null
+		}
+	};
+
+	/* one of the greatest headaches in the tool. finally made it */
+	function viewport() {
+				
+		// the horror case
+		if ($.browser.msie) {
+			
+			// if there are no scrollbars then use window.height
+			var d = $(document).height(), w = $(window).height();
+			
+			return [
+				window.innerWidth || 							// ie7+
+				document.documentElement.clientWidth || 	// ie6  
+				document.body.clientWidth, 					// ie6 quirks mode
+				d - w < 20 ? w : d
+			];
+		} 
+		
+		// other well behaving browsers
+		return [$(document).width(), $(document).height()]; 
+	} 
+	
+	function call(fn) {
+		if (fn) { return fn.call($.mask); }
+	}
+	
+	var mask, exposed, loaded, config, overlayIndex;		
+	
+	
+	$.mask = {
+		
+		load: function(conf, els) {
+			
+			// already loaded ?
+			if (loaded) { return this; }			
+			
+			// configuration
+			if (typeof conf == 'string') {
+				conf = {color: conf};	
+			}
+			
+			// use latest config
+			conf = conf || config;
+			
+			config = conf = $.extend($.extend({}, tool.conf), conf);
+
+			// get the mask
+			mask = $("#" + conf.maskId);
+				
+			// or create it
+			if (!mask.length) {
+				mask = $('<div/>').attr("id", conf.maskId);
+				$("body").append(mask);
+			}
+			
+			// set position and dimensions 			
+			var size = viewport();
+				
+			mask.css({				
+				position:'absolute', 
+				top: 0, 
+				left: 0,
+				width: size[0],
+				height: size[1],
+				display: 'none',
+				opacity: conf.startOpacity,					 		
+				zIndex: conf.zIndex 
+			});
+			
+			if (conf.color) {
+				mask.css("backgroundColor", conf.color);	
+			}			
+			
+			// onBeforeLoad
+			if (call(conf.onBeforeLoad) === false) {
+				return this;
+			}
+			
+			// esc button
+			if (conf.closeOnEsc) {						
+				$(document).bind("keydown.mask", function(e) {							
+					if (e.keyCode == 27) {
+						$.mask.close(e);	
+					}		
+				});			
+			}
+			
+			// mask click closes
+			if (conf.closeOnClick) {
+				mask.bind("click.mask", function(e)  {
+					$.mask.close(e);		
+				});					
+			}			
+			
+			// resize mask when window is resized
+			$(window).bind("resize.mask", function() {
+				$.mask.fit();
+			});
+			
+			// exposed elements
+			if (els && els.length) {
+				
+				overlayIndex = els.eq(0).css("zIndex");
+
+				// make sure element is positioned absolutely or relatively
+				$.each(els, function() {
+					var el = $(this);
+					if (!/relative|absolute|fixed/i.test(el.css("position"))) {
+						el.css("position", "relative");		
+					}					
+				});
+			 
+				// make elements sit on top of the mask
+				exposed = els.css({ zIndex: Math.max(conf.zIndex + 1, overlayIndex == 'auto' ? 0 : overlayIndex)});			
+			}	
+			
+			// reveal mask
+			mask.css({display: 'block'}).fadeTo(conf.loadSpeed, conf.opacity, function() {
+				$.mask.fit(); 
+				call(conf.onLoad);
+				loaded = "full";
+			});
+			
+			loaded = true;			
+			return this;				
+		},
+		
+		close: function() {
+			if (loaded) {
+				
+				// onBeforeClose
+				if (call(config.onBeforeClose) === false) { return this; }
+					
+				mask.fadeOut(config.closeSpeed, function()  {					
+					call(config.onClose);					
+					if (exposed) {
+						exposed.css({zIndex: overlayIndex});						
+					}				
+					loaded = false;
+				});				
+				
+				// unbind various event listeners
+				$(document).unbind("keydown.mask");
+				mask.unbind("click.mask");
+				$(window).unbind("resize.mask");  
+			}
+			
+			return this; 
+		},
+		
+		fit: function() {
+			if (loaded) {
+				var size = viewport();				
+				mask.css({width: size[0], height: size[1]});
+			}				
+		},
+		
+		getMask: function() {
+			return mask;	
+		},
+		
+		isLoaded: function(fully) {
+			return fully ? loaded == 'full' : loaded;	
+		}, 
+		
+		getConf: function() {
+			return config;	
+		},
+		
+		getExposed: function() {
+			return exposed;	
+		}		
+	};
+	
+	$.fn.mask = function(conf) {
+		$.mask.load(conf);
+		return this;		
+	};			
+	
+	$.fn.expose = function(conf) {
+		$.mask.load(conf, this);
+		return this;			
+	};
+
+
+})(jQuery);

data/vendor/assets/javascripts/toolbox/toolbox.flashembed.js

@@ -0,0 +1,301 @@
+/**
+ * @license
+ * jQuery Tools @VERSION / Flashembed - New wave Flash embedding
+ *
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ *
+ * http://flowplayer.org/tools/toolbox/flashembed.html
+ *
+ * Since : March 2008
+ * Date  : @DATE
+ */
+(function() {
+
+	var IE = document.all,
+		 URL = 'http://www.adobe.com/go/getflashplayer',
+		 JQUERY = typeof jQuery == 'function',
+		 RE = /(\d+)[^\d]+(\d+)[^\d]*(\d*)/,
+		 GLOBAL_OPTS = {
+			// very common opts
+			width: '100%',
+			height: '100%',
+			id: "_" + ("" + Math.random()).slice(9),
+
+			// flashembed defaults
+			allowfullscreen: true,
+			allowscriptaccess: 'always',
+			quality: 'high',
+
+			// flashembed specific options
+			version: [3, 0],
+			onFail: null,
+			expressInstall: null,
+			w3c: false,
+			cachebusting: false
+	};
+
+	// version 9 bugfix: (http://blog.deconcept.com/2006/07/28/swfobject-143-released/)
+	if (window.attachEvent) {
+		window.attachEvent("onbeforeunload", function() {
+			__flash_unloadHandler = function() {};
+			__flash_savedUnloadHandler = function() {};
+		});
+	}
+
+	// simple extend
+	function extend(to, from) {
+		if (from) {
+			for (var key in from) {
+				if (from.hasOwnProperty(key)) {
+					to[key] = from[key];
+				}
+			}
+		}
+		return to;
+	}
+
+	// used by asString method
+	function map(arr, func) {
+		var newArr = [];
+		for (var i in arr) {
+			if (arr.hasOwnProperty(i)) {
+				newArr[i] = func(arr[i]);
+			}
+		}
+		return newArr;
+	}
+
+	window.flashembed = function(root, opts, conf) {
+
+		// root must be found / loaded
+		if (typeof root == 'string') {
+			root = document.getElementById(root.replace("#", ""));
+		}
+
+		// not found
+		if (!root) { return; }
+
+		if (typeof opts == 'string') {
+			opts = {src: opts};
+		}
+
+		return new Flash(root, extend(extend({}, GLOBAL_OPTS), opts), conf);
+	};
+
+	// flashembed "static" API
+	var f = extend(window.flashembed, {
+
+		conf: GLOBAL_OPTS,
+
+		getVersion: function()  {
+			var fo, ver;
+
+			try {
+				ver = navigator.plugins["Shockwave Flash"].description.slice(16);
+			} catch(e) {
+
+				try  {
+					fo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
+					ver = fo && fo.GetVariable("$version");
+
+				} catch(err) {
+                try  {
+                    fo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
+                    ver = fo && fo.GetVariable("$version");
+                } catch(err2) { }
+				}
+			}
+
+			ver = RE.exec(ver);
+			return ver ? [ver[1], ver[3]] : [0, 0];
+		},
+
+		asString: function(obj) {
+
+			if (obj === null || obj === undefined) { return null; }
+			var type = typeof obj;
+			if (type == 'object' && obj.push) { type = 'array'; }
+
+			switch (type){
+
+				case 'string':
+					obj = obj.replace(new RegExp('(["\\\\])', 'g'), '\\$1');
+
+					// flash does not handle %- characters well. transforms "50%" to "50pct" (a dirty hack, I admit)
+					obj = obj.replace(/^\s?(\d+\.?\d*)%/, "$1pct");
+					return '"' +obj+ '"';
+
+				case 'array':
+					return '['+ map(obj, function(el) {
+						return f.asString(el);
+					}).join(',') +']';
+
+				case 'function':
+					return '"function()"';
+
+				case 'object':
+					var str = [];
+					for (var prop in obj) {
+						if (obj.hasOwnProperty(prop)) {
+							str.push('"'+prop+'":'+ f.asString(obj[prop]));
+						}
+					}
+					return '{'+str.join(',')+'}';
+			}
+
+			// replace ' --> "  and remove spaces
+			return String(obj).replace(/\s/g, " ").replace(/\'/g, "\"");
+		},
+
+		getHTML: function(opts, conf) {
+
+			opts = extend({}, opts);
+
+			/******* OBJECT tag and it's attributes *******/
+			var html = '<object width="' + opts.width +
+				'" height="' + opts.height +
+				'" id="' + opts.id +
+				'" name="' + opts.id + '"';
+
+			if (opts.cachebusting) {
+				opts.src += ((opts.src.indexOf("?") != -1 ? "&" : "?") + Math.random());
+			}
+
+			if (opts.w3c || !IE) {
+				html += ' data="' +opts.src+ '" type="application/x-shockwave-flash"';
+			} else {
+				html += ' classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"';
+			}
+
+			html += '>';
+
+			/******* nested PARAM tags *******/
+			if (opts.w3c || IE) {
+				html += '<param name="movie" value="' +opts.src+ '" />';
+			}
+
+			// not allowed params
+			opts.width = opts.height = opts.id = opts.w3c = opts.src = null;
+			opts.onFail = opts.version = opts.expressInstall = null;
+
+			for (var key in opts) {
+				if (opts[key]) {
+					html += '<param name="'+ key +'" value="'+ opts[key] +'" />';
+				}
+			}
+
+			/******* FLASHVARS *******/
+			var vars = "";
+
+			if (conf) {
+				for (var k in conf) {
+					if (conf[k]) {
+						var val = conf[k];
+						vars += k +'='+ encodeURIComponent(/function|object/.test(typeof val) ? f.asString(val) : val) + '&';
+					}
+				}
+				vars = vars.slice(0, -1);
+				html += '<param name="flashvars" value=\'' + vars + '\' />';
+			}
+
+			html += "</object>";
+
+			return html;
+		},
+
+		isSupported: function(ver) {
+			return VERSION[0] > ver[0] || VERSION[0] == ver[0] && VERSION[1] >= ver[1];
+		}
+
+	});
+
+	var VERSION = f.getVersion();
+
+	function Flash(root, opts, conf) {
+
+		// version is ok
+		if (f.isSupported(opts.version)) {
+			root.innerHTML = f.getHTML(opts, conf);
+
+		// express install
+		} else if (opts.expressInstall && f.isSupported([6, 65])) {
+			root.innerHTML = f.getHTML(extend(opts, {src: opts.expressInstall}), {
+				MMredirectURL: location.href,
+				MMplayerType: 'PlugIn',
+				MMdoctitle: document.title
+			});
+
+		} else {
+
+			// fail #2.1 custom content inside container
+			if (!root.innerHTML.replace(/\s/g, '')) {
+				root.innerHTML =
+					"<h2>Flash version " + opts.version + " or greater is required</h2>" +
+					"<h3>" +
+						(VERSION[0] > 0 ? "Your version is " + VERSION : "You have no flash plugin installed") +
+					"</h3>" +
+
+					(root.tagName == 'A' ? "<p>Click here to download latest version</p>" :
+						"<p>Download latest version from <a href='" + URL + "'>here</a></p>");
+
+				if (root.tagName == 'A') {
+					root.onclick = function() {
+						location.href = URL;
+					};
+				}
+			}
+
+			// onFail
+			if (opts.onFail) {
+				var ret = opts.onFail.call(this);
+				if (typeof ret == 'string') { root.innerHTML = ret; }
+			}
+		}
+
+		// http://flowplayer.org/forum/8/18186#post-18593
+		if (IE) {
+			window[opts.id] = document.getElementById(opts.id);
+		}
+
+		// API methods for callback
+		extend(this, {
+
+			getRoot: function() {
+				return root;
+			},
+
+			getOptions: function() {
+				return opts;
+			},
+
+
+			getConf: function() {
+				return conf;
+			},
+
+			getApi: function() {
+				return root.firstChild;
+			}
+
+		});
+	}
+
+	// setup jquery support
+	if (JQUERY) {
+
+		// tools version number
+		jQuery.tools = jQuery.tools || {version: '@VERSION'};
+
+		jQuery.tools.flashembed = {
+			conf: GLOBAL_OPTS
+		};
+
+		jQuery.fn.flashembed = function(opts, conf) {
+			return this.each(function() {
+				jQuery(this).data("flashembed", flashembed(this, opts, conf));
+			});
+		};
+	}
+
+})();
+