jquerypp-rails 1.0

data/vendor/assets/javascripts/lib/jquery.event.hover.js

@@ -0,0 +1,266 @@
+// Dependencies:
+//
+//    - jquery.event.hover.js
+//    - jquery.event.livehack.js
+
+(function($){
+/**
+ * @class jQuery.Hover
+ * @plugin jquery/event/hover
+ * @download  http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/hover/hover.js
+ * @parent jQuery.event.hover
+ *
+ * Creates a new hover. The constructor should not be called directly.
+ *
+ * An instance of `$.Hover` is passed as the second argument to each
+ * [jQuery.event.hover] event handler:
+ *
+ *      $('#menu').on("hoverinit", function(ev, hover) {
+ *          // Set the hover distance to 20px
+ *          hover.distance(20);
+ *      });
+ */
+$.Hover = function(){
+	this._delay =  $.Hover.delay;
+	this._distance = $.Hover.distance;
+	this._leave = $.Hover.leave
+};
+/**
+ * @Static
+ */
+$.extend($.Hover,{
+	/**
+	 * @attribute delay
+	 *
+	 * `$.Hover.delay` is the delay (in milliseconds) after which the hover is
+	 * activated by default.
+	 *
+	 * Set this value as a global default. The default is 100ms.
+	 *
+	 *      // Set the global hover delay to 1 second
+	 *      $.Hover.delay = 1000;
+	 */
+	delay: 100,
+	/**
+	 * @attribute distance
+	 *
+	 * `$.Hover.distance` is the maximum distance (in pixels) that the mouse is allowed to
+	 * travel within the time of [jQuery.Hover.delay] in order to activate a hover.
+	 *
+	 * Set this value as a global default. The default is 10px.
+	 *
+	 *      // Set the global hover distance to 1 pixel
+	 *      $.Hover.distance = 1;
+	 */
+	distance: 10,
+	leave : 0
+})
+
+/**
+ * @Prototype
+ */
+$.extend($.Hover.prototype,{
+	/**
+	 * `hover.delay(time)` sets the delay (in ms) for this hover.
+	 * This method should only be used in [jQuery.event.hover.hoverinit hoverinit]:
+	 *
+	 *      $('.hoverable').on('hoverinit', function(ev, hover) {
+	 *          // Set the delay to 500ms
+	 *          hover.delay(500);
+	 *      });
+	 *
+	 * @param {Number} delay the number of milliseconds used to determine a hover
+	 * @return {$.Hover} The hover object
+	 */
+	delay: function( delay ) {
+		this._delay = delay;
+		return this;
+	},
+	/**
+	 * `hover.distance(px) sets the maximum distance (in pixels) the mouse is allowed to travel in order to activate
+	 * the hover. This method should only be used in [jQuery.event.hover.hoverinit hoverinit]:
+	 *
+	 *      $('.hoverable').on('hoverinit', function(ev, hover) {
+	 *          // Set the distance to 1px
+	 *          hover.distance(1);
+	 *      });
+	 *
+	 * @param {Number} distance the max distance in pixels a mouse can move to be considered a hover
+	 * @return {$.Hover} The hover object
+	 */
+	distance: function( distance ) {
+		this._distance = distance;
+		return this;
+	},
+	/**
+	 * `hover.leave(delay)` sets a delay for how long the hover should stay active after the mouse left.
+	 * This method should only be used in [jQuery.event.hover.hoverinit hoverinit]:
+	 *
+	 *      $('.hoverable').on('hoverinit', function(ev, hover) {
+	 *          // Stay active for another second after the mouse left
+	 *          hover.leave(1000);
+	 *      });
+	 *
+	 * @param {Number} delay the number of milliseconds the hover should stay active after the mouse leaves
+	 * @return {$.Hover} The hover object
+	 */
+	leave : function(leave){
+		this._leave = leave;
+		return this;
+	}
+})
+var event = $.event, 
+	handle  = event.handle,
+	onmouseenter = function(ev){
+		// now start checking mousemoves to update location
+		var delegate = ev.delegateTarget || ev.currentTarget;
+		var selector = ev.handleObj.selector;
+		// prevents another mouseenter until current has run its course
+		if($.data(delegate,"_hover"+selector)) {
+			return;
+		}
+		$.data(delegate,"_hover"+selector, true)
+		var loc = {
+				pageX : ev.pageX,
+				pageY : ev.pageY
+			},
+			// The current distance
+			dist = 0,
+			// Timer that checks for the distance travelled
+			timer,
+			enteredEl = this,
+			// If we are hovered
+			hovered = false,
+			// The previous event
+			lastEv = ev,
+			// The $.Hover instance passed to events
+			hover = new $.Hover(),
+			// timer if hover.leave has been called
+			leaveTimer,
+			// Callback for triggering hoverleave
+			callHoverLeave = function(){
+				$.each(event.find(delegate, ["hoverleave"], selector), function(){
+					this.call(enteredEl, ev, hover)
+				})
+				cleanUp();
+			},
+			mousemove = function(ev){
+				clearTimeout(leaveTimer);
+				// Update the distance and location
+				dist += Math.pow( ev.pageX-loc.pageX, 2 ) + Math.pow( ev.pageY-loc.pageY, 2 ); 
+				loc = {
+					pageX : ev.pageX,
+					pageY : ev.pageY
+				}
+				lastEv = ev
+			},
+			mouseleave = function(ev){
+				clearTimeout(timer);
+				if(hovered) {
+					// go right away
+					if(hover._leave === 0){
+						callHoverLeave();
+					}else{
+						clearTimeout(leaveTimer);
+						// leave the hover after the time set in hover.leave(time)
+						leaveTimer = setTimeout(function(){
+							callHoverLeave();
+						}, hover._leave)
+					}
+				}else{
+					cleanUp();
+				}
+			},
+			cleanUp = function(){
+				// Unbind all events and data
+				$(enteredEl).unbind("mouseleave",mouseleave)
+				$(enteredEl).unbind("mousemove",mousemove);
+				$.removeData(delegate,"_hover"+selector)
+			};
+
+		// Bind the mousemove event
+		$(enteredEl).bind("mousemove",mousemove).bind("mouseleave", mouseleave);
+		// call hoverinit for each element with the hover instance
+		$.each(event.find(delegate, ["hoverinit"], selector), function(){
+			this.call(enteredEl, ev, hover)
+		})
+		
+		timer = setTimeout(function(){
+			// check that we aren't moving around
+			if(dist < hover._distance && $(enteredEl).queue().length == 0){
+				$.each(event.find(delegate, ["hoverenter"], selector), function(){
+					this.call(enteredEl, lastEv, hover)
+				})
+				hovered = true;
+				return;
+			}else{
+				// Reset distance and timer
+				dist = 0;
+				timer = setTimeout(arguments.callee, hover._delay)
+			}
+		}, hover._delay)
+		
+	};
+
+/**
+ * @add jQuery.event.special
+ */
+// Attach events
+event.setupHelper( [
+/**
+ * @attribute hoverinit
+ * @parent jQuery.event.hover
+ *
+ * `hoverinit` is called when a hover is about to start (on `mouseenter`). Listen for `hoverinit` events to configure
+ * [jQuery.Hover::delay delay] and [jQuery.Hover::distance distance]
+ * for this specific event:
+ *
+ *      $(".option").on("hoverinit", function(ev, hover){
+ *          //set the distance to 10px
+ *          hover.distance(10);
+ *          //set the delay to 200ms
+ *          hover.delay(10);
+ *          // End the hover one second after the mouse leaves
+ *          hover.leave(1000);
+ *      })
+ */
+"hoverinit", 
+/**
+ * @attribute hoverenter
+ * @parent jQuery.event.hover
+ *
+ * `hoverenter` events are called when the mouses less than [jQuery.Hover.prototype.distance] pixels in
+ * [jQuery.Hover.prototype.delay delay] milliseconds.
+ *
+ *      $(".option").on("hoverenter", function(ev, hover){
+ *          $(this).addClass("hovering");
+ *      })
+ */
+"hoverenter",
+/**
+ * @attribute hoverleave
+ * @parent jQuery.event.hover
+ *
+ * `hoverleave` is called when the mouse leaves an element that has been hovered.
+ *
+ *      $(".option").on("hoverleave", function(ev, hover){
+ *          $(this).removeClass("hovering");
+ *      })
+ */
+"hoverleave",
+/**
+ * @attribute hovermove
+ * @parent jQuery.event.hover
+ *
+ * `hovermove` is called when a `mousemove` occurs on an element that has been hovered.
+ *
+ *      $(".option").on("hovermove", function(ev, hover){
+ *          // not sure why you would want to listen for this
+ *          // but we provide it just in case
+ *      })
+ */
+"hovermove"], "mouseenter", onmouseenter )
+		
+
+	
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.event.key.js

@@ -0,0 +1,156 @@
+//    - jquery.event.key.js
+(function($){
+	var keymap = {},
+		reverseKeyMap = {},
+		currentBrowser = jQuery.uaMatch(navigator.userAgent).browser;
+		
+	/**
+	 * @hide
+	 * @parent jQuery.Event.prototype.key
+	 * 
+	 * Allows you to set alternate key maps or overwrite existing key codes.
+	 * For example::
+	 * 
+	 *     $.event.key({"~" : 177});
+	 * 
+	 * @param {Object} map A map of character - keycode pairs.
+	 */
+	$.event.key = function(browser, map){
+		if(browser === undefined) {
+			return keymap;
+		}
+
+		if(map === undefined) {
+			map = browser;
+			browser = currentBrowser;
+		}
+
+		// extend the keymap
+		if(!keymap[browser]) {
+			keymap[browser] = {};
+		}
+		$.extend(keymap[browser], map);
+		// and also update the reverse keymap
+		if(!reverseKeyMap[browser]) {
+			reverseKeyMap[browser] = {};
+		}
+		for(var name in map){
+			reverseKeyMap[browser][map[name]] = name;
+		}
+	};
+	
+	$.event.key({
+		// backspace
+		'\b':'8',
+		
+		// tab
+		'\t':'9',
+		
+		// enter
+		'\r':'13',
+		
+		// special
+		'shift':'16','ctrl':'17','alt':'18',
+		
+		// others
+		'pause-break':'19',
+		'caps':'20',
+		'escape':'27',
+		'num-lock':'144',
+		'scroll-lock':'145',
+		'print' : '44',
+		
+		// navigation
+		'page-up':'33','page-down':'34','end':'35','home':'36',
+		'left':'37','up':'38','right':'39','down':'40','insert':'45','delete':'46',
+		
+		// normal characters
+		' ':'32',
+		'0':'48','1':'49','2':'50','3':'51','4':'52','5':'53','6':'54','7':'55','8':'56','9':'57',
+		'a':'65','b':'66','c':'67','d':'68','e':'69','f':'70','g':'71','h':'72','i':'73','j':'74','k':'75','l':'76','m':'77',
+		'n':'78','o':'79','p':'80','q':'81','r':'82','s':'83','t':'84','u':'85','v':'86','w':'87','x':'88','y':'89','z':'90',
+		// normal-characters, numpad
+		'num0':'96','num1':'97','num2':'98','num3':'99','num4':'100','num5':'101','num6':'102','num7':'103','num8':'104','num9':'105',
+		'*':'106','+':'107','-':'109','.':'110',
+		// normal-characters, others
+		'/':'111',
+		';':'186',
+		'=':'187',
+		',':'188',
+		'-':'189',
+		'.':'190',
+		'/':'191',
+		'`':'192',
+		'[':'219',
+		'\\':'220',
+		']':'221',
+		"'":'222',
+		
+		// ignore these, you shouldn't use them
+		'left window key':'91','right window key':'92','select key':'93',
+		
+		
+		'f1':'112','f2':'113','f3':'114','f4':'115','f5':'116','f6':'117',
+		'f7':'118','f8':'119','f9':'120','f10':'121','f11':'122','f12':'123'
+	});
+	
+	/**
+	 * @parent jQuery.event.key
+	 * @plugin jquery/event/key
+	 * @function jQuery.Event.prototype.keyName
+	 *
+	 * Returns a string representation of the key pressed:
+	 *
+	 *      $("input").on('keypress', function(ev){
+	 *          if(ev.keyName() == 'ctrl') {
+	 *              $(this).addClass('highlight');
+	 *          }
+	 *      });
+	 *
+	 * The key names mapped by default can be found in the [jQuery.event.key jQuery.event.key overview].
+	 *
+	 * @return {String} The string representation of of the key pressed.
+	 */
+	jQuery.Event.prototype.keyName  = function(){
+		var event = this,
+			test = /\w/,
+			// It can be either keyCode or charCode.
+			// Look both cases up in the reverse key map and converted to a string
+			key_Key =  reverseKeyMap[currentBrowser][(event.keyCode || event.which)+""],
+			char_Key =  String.fromCharCode(event.keyCode || event.which),
+			key_Char =  event.charCode && reverseKeyMap[currentBrowser][event.charCode+""],
+			char_Char = event.charCode && String.fromCharCode(event.charCode);
+		
+		if( char_Char && test.test(char_Char) ) {
+			// string representation of event.charCode
+			return char_Char.toLowerCase()
+		}
+		if( key_Char && test.test(key_Char) ) {
+			// reverseKeyMap representation of event.charCode
+			return char_Char.toLowerCase()
+		}
+		if( char_Key && test.test(char_Key) ) {
+			// string representation of event.keyCode
+			return char_Key.toLowerCase()
+		}
+		if( key_Key && test.test(key_Key) ) {
+			// reverseKeyMap representation of event.keyCode
+			return key_Key.toLowerCase()
+		}
+
+		if (event.type == 'keypress'){
+			// keypress doesn't capture everything
+			return event.keyCode ? String.fromCharCode(event.keyCode) : String.fromCharCode(event.which)
+		}
+
+		if (!event.keyCode && event.which) {
+			// event.which
+			return String.fromCharCode(event.which)
+		}
+
+		// default
+		return reverseKeyMap[currentBrowser][event.keyCode+""]
+	}
+	
+	
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.event.livehack.js

@@ -0,0 +1,174 @@
+//    - jquery.event.livehack.js
+(function() {
+
+	var event = jQuery.event,
+
+		//helper that finds handlers by type and calls back a function, this is basically handle
+		// events - the events object
+		// types - an array of event types to look for
+		// callback(type, handlerFunc, selector) - a callback
+		// selector - an optional selector to filter with, if there, matches by selector
+		//     if null, matches anything, otherwise, matches with no selector
+		findHelper = function( events, types, callback, selector ) {
+			var t, type, typeHandlers, all, h, handle, 
+				namespaces, namespace,
+				match;
+			for ( t = 0; t < types.length; t++ ) {
+				type = types[t];
+				all = type.indexOf(".") < 0;
+				if (!all ) {
+					namespaces = type.split(".");
+					type = namespaces.shift();
+					namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
+				}
+				typeHandlers = (events[type] || []).slice(0);
+
+				for ( h = 0; h < typeHandlers.length; h++ ) {
+					handle = typeHandlers[h];
+					
+					match = (all || namespace.test(handle.namespace));
+					
+					if(match){
+						if(selector){
+							if (handle.selector === selector  ) {
+								callback(type, handle.origHandler || handle.handler);
+							}
+						} else if (selector === null){
+							callback(type, handle.origHandler || handle.handler, handle.selector);
+						}
+						else if (!handle.selector ) {
+							callback(type, handle.origHandler || handle.handler);
+							
+						} 
+					}
+					
+					
+				}
+			}
+		};
+
+	/**
+	 * Finds event handlers of a given type on an element.
+	 * @param {HTMLElement} el
+	 * @param {Array} types an array of event names
+	 * @param {String} [selector] optional selector
+	 * @return {Array} an array of event handlers
+	 */
+	event.find = function( el, types, selector ) {
+		var events = ( $._data(el) || {} ).events,
+			handlers = [],
+			t, liver, live;
+
+		if (!events ) {
+			return handlers;
+		}
+		findHelper(events, types, function( type, handler ) {
+			handlers.push(handler);
+		}, selector);
+		return handlers;
+	};
+	/**
+	 * Finds all events.  Group by selector.
+	 * @param {HTMLElement} el the element
+	 * @param {Array} types event types
+	 */
+	event.findBySelector = function( el, types ) {
+		var events = $._data(el).events,
+			selectors = {},
+			//adds a handler for a given selector and event
+			add = function( selector, event, handler ) {
+				var select = selectors[selector] || (selectors[selector] = {}),
+					events = select[event] || (select[event] = []);
+				events.push(handler);
+			};
+
+		if (!events ) {
+			return selectors;
+		}
+		//first check live:
+		/*$.each(events.live || [], function( i, live ) {
+			if ( $.inArray(live.origType, types) !== -1 ) {
+				add(live.selector, live.origType, live.origHandler || live.handler);
+			}
+		});*/
+		//then check straight binds
+		findHelper(events, types, function( type, handler, selector ) {
+			add(selector || "", type, handler);
+		}, null);
+
+		return selectors;
+	};
+	event.supportTouch = "ontouchend" in document;
+	
+	$.fn.respondsTo = function( events ) {
+		if (!this.length ) {
+			return false;
+		} else {
+			//add default ?
+			return event.find(this[0], $.isArray(events) ? events : [events]).length > 0;
+		}
+	};
+	$.fn.triggerHandled = function( event, data ) {
+		event = (typeof event == "string" ? $.Event(event) : event);
+		this.trigger(event, data);
+		return event.handled;
+	};
+	/**
+	 * Only attaches one event handler for all types ...
+	 * @param {Array} types llist of types that will delegate here
+	 * @param {Object} startingEvent the first event to start listening to
+	 * @param {Object} onFirst a function to call 
+	 */
+	event.setupHelper = function( types, startingEvent, onFirst ) {
+		if (!onFirst ) {
+			onFirst = startingEvent;
+			startingEvent = null;
+		}
+		var add = function( handleObj ) {
+
+			var bySelector, selector = handleObj.selector || "";
+			if ( selector ) {
+				bySelector = event.find(this, types, selector);
+				if (!bySelector.length ) {
+					$(this).delegate(selector, startingEvent, onFirst);
+				}
+			}
+			else {
+				//var bySelector = event.find(this, types, selector);
+				if (!event.find(this, types, selector).length ) {
+					event.add(this, startingEvent, onFirst, {
+						selector: selector,
+						delegate: this
+					});
+				}
+
+			}
+
+		},
+			remove = function( handleObj ) {
+				var bySelector, selector = handleObj.selector || "";
+				if ( selector ) {
+					bySelector = event.find(this, types, selector);
+					if (!bySelector.length ) {
+						$(this).undelegate(selector, startingEvent, onFirst);
+					}
+				}
+				else {
+					if (!event.find(this, types, selector).length ) {
+						event.remove(this, startingEvent, onFirst, {
+							selector: selector,
+							delegate: this
+						});
+					}
+				}
+			};
+		$.each(types, function() {
+			event.special[this] = {
+				add: add,
+				remove: remove,
+				setup: function() {},
+				teardown: function() {}
+			};
+		});
+	};
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.event.pause.js

@@ -0,0 +1,92 @@
+// Dependencies:
+//
+//    - jquery.event.pause.js
+//    - jquery.event.default.js
+
+(function($){
+
+
+var current,
+	rnamespaces = /\.(.*)$/,
+	returnFalse = function(){return false},
+	returnTrue = function(){return true};
+
+$.Event.prototype.isPaused = returnFalse
+
+/**
+ * @function jQuery.Event.prototype.pause
+ * @parent jQuery.event.pause
+ *
+ * `event.paused()` pauses an event (to be resumed later):
+ *
+ *      $('.tab').on('show', function(ev) {
+ *          ev.pause();
+ *          // Resume the event after 1 second
+ *          setTimeout(function() {
+ *              ev.resume();
+ *          }, 1000);
+ *      });
+ */
+$.Event.prototype.pause = function(){
+	// stop the event from continuing temporarily
+	// keep the current state of the event ...
+	this.pausedState = {
+		isDefaultPrevented : this.isDefaultPrevented() ?
+			returnTrue : returnFalse,
+		isPropagationStopped : this.isPropagationStopped() ?
+			returnTrue : returnFalse
+	};
+	
+	this.stopImmediatePropagation();
+	this.preventDefault();
+	this.isPaused = returnTrue;
+};
+
+/**
+ * @function jQuery.Event.prototype.resume
+ * @parent jQuery.event.pause
+ *
+ * `event.resume()` resumes a paused event:
+ *
+ *      $('.tab').on('show', function(ev) {
+ *          ev.pause();
+ *          // Resume the event after 1 second
+ *          setTimeout(function() {
+ *              ev.resume();
+ *          }, 1000);
+ *      });
+ */
+$.Event.prototype.resume = function(){
+	// temporarily remove all event handlers of this type 
+	var handleObj = this.handleObj,
+		currentTarget = this.currentTarget;
+	// temporarily overwrite special handle
+	var origType = jQuery.event.special[ handleObj.origType ],
+		origHandle = origType && origType.handle;
+		
+	if(!origType){
+		jQuery.event.special[ handleObj.origType ] = {};
+	}
+	jQuery.event.special[ handleObj.origType ].handle = function(ev){
+		// remove this once we have passed the handleObj
+		if(ev.handleObj === handleObj && ev.currentTarget === currentTarget){
+			if(!origType){
+				delete jQuery.event.special[ handleObj.origType ];
+			} else {
+				jQuery.event.special[ handleObj.origType ].handle = origHandle;
+			}
+		}
+	}
+	delete this.pausedState;
+	// reset stuff
+	this.isPaused = this.isImmediatePropagationStopped = returnFalse;
+	
+	if(!this.isPropagationStopped()){
+		// fire the event again, no events will get fired until
+		// same currentTarget / handler
+		$.event.trigger(this, [], this.target);
+	}
+	
+};
+
+})(jQuery)