jquerypp-rails 1.0

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

@@ -0,0 +1,47 @@
+// Dependencies:
+//
+//    - jquery.event.resize.js
+//    - jquery/event/reverse/reverse.js
+
+(function( $ ) {
+	var
+		// bind on the window window resizes to happen
+		win = $(window),
+		windowWidth = 0,
+		windowHeight = 0,
+		timer;
+
+	$(function() {
+		windowWidth = win.width();
+		windowHeight = win.height();
+	});
+
+	$.event.reverse('resize', {
+		handler : function(ev, data) {
+			var isWindow = this === window;
+
+			// if we are the window and a real resize has happened
+			// then we check if the dimensions actually changed
+			// if they did, we will wait a brief timeout and
+			// trigger resize on the window
+			// this is for IE, to prevent window resize 'infinate' loop issues
+			if ( isWindow && ev.originalEvent ) {
+				var width = win.width(),
+					height = win.height();
+
+
+				if ((width != windowWidth || height != windowHeight)) {
+					//update the new dimensions
+					windowWidth = width;
+					windowHeight = height;
+					clearTimeout(timer)
+					timer = setTimeout(function() {
+						win.trigger("resize");
+					}, 1);
+
+				}
+				return true;
+			}
+		}
+	});
+})(jQuery)

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

@@ -0,0 +1,133 @@
+// Dependencies:
+//
+//    - jquery.event.swipe.js
+//    - jquery.event.livehack.js
+
+(function($){
+var isPhantom = /Phantom/.test(navigator.userAgent),
+	supportTouch = !isPhantom && "ontouchend" in document,
+	scrollEvent = "touchmove scroll",
+	// Use touch events or map it to mouse events
+	touchStartEvent = supportTouch ? "touchstart" : "mousedown",
+	touchStopEvent = supportTouch ? "touchend" : "mouseup",
+	touchMoveEvent = supportTouch ? "touchmove" : "mousemove",
+	data = function(event){
+		var d = event.originalEvent.touches ?
+			event.originalEvent.touches[ 0 ] :
+			event;
+		return {
+			time: (new Date).getTime(),
+			coords: [ d.pageX, d.pageY ],
+			origin: $( event.target )
+		};
+	};
+
+/**
+ * @add jQuery.event.swipe
+ */
+var swipe = $.event.swipe = {
+	/**
+	 * @attribute delay
+	 * Delay is the upper limit of time the swipe motion can take in milliseconds.  This defaults to 500.
+	 * 
+	 * A user must perform the swipe motion in this much time.
+	 */
+	delay : 500,
+	/**
+	 * @attribute max
+	 * The maximum distance the pointer must travel in pixels.  The default is 75 pixels.
+	 */
+	max : 75,
+	/**
+	 * @attribute min
+	 * The minimum distance the pointer must travel in pixels.  The default is 30 pixels.
+	 */
+	min : 30
+};
+
+$.event.setupHelper( [
+
+/**
+ * @hide
+ * @attribute swipe
+ */
+"swipe",
+/**
+ * @hide
+ * @attribute swipeleft
+ */
+'swipeleft',
+/**
+ * @hide
+ * @attribute swiperight
+ */
+'swiperight',
+/**
+ * @hide
+ * @attribute swipeup
+ */
+'swipeup',
+/**
+ * @hide
+ * @attribute swipedown
+ */
+'swipedown'], touchStartEvent, function(ev){
+	var
+		// update with data when the event was started
+		start = data(ev),
+		stop,
+		delegate = ev.delegateTarget || ev.currentTarget,
+		selector = ev.handleObj.selector,
+		entered = this;
+	
+	function moveHandler(event){
+		if ( !start ) {
+			return;
+		}
+		// update stop with the data from the current event
+		stop = data(event);
+
+		// prevent scrolling
+		if ( Math.abs( start.coords[0] - stop.coords[0] ) > 10 ) {
+			event.preventDefault();
+		}
+	};
+
+	// Attach to the touch move events
+	$(document.documentElement).bind(touchMoveEvent, moveHandler)
+		.one(touchStopEvent, function(event){
+			$(this).unbind( touchMoveEvent, moveHandler);
+			// if start and stop contain data figure out if we have a swipe event
+			if ( start && stop ) {
+				// calculate the distance between start and stop data
+				var deltaX = Math.abs(start.coords[0] - stop.coords[0]),
+					deltaY = Math.abs(start.coords[1] - stop.coords[1]),
+					distance = Math.sqrt(deltaX*deltaX+deltaY*deltaY);
+
+				// check if the delay and distance are matched
+				if ( stop.time - start.time < swipe.delay && distance >= swipe.min ) {
+					var events = ['swipe'];
+					// check if we moved horizontally
+					if( deltaX >= swipe.min && deltaY < swipe.min) {
+						// based on the x coordinate check if we moved left or right
+						events.push( start.coords[0] > stop.coords[0] ? "swipeleft" : "swiperight" );
+					} else
+					// check if we moved vertically
+					if(deltaY >= swipe.min && deltaX < swipe.min){
+						// based on the y coordinate check if we moved up or down
+						events.push( start.coords[1] < stop.coords[1] ? "swipedown" : "swipeup" );
+					}
+
+					// trigger swipe events on this guy
+					$.each($.event.find(delegate, events, selector), function(){
+						this.call(entered, ev, {start : start, end: stop})
+					})
+				
+				}
+			}
+			// reset start and stop
+			start = stop = undefined;
+		})
+});
+
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.fills.js

@@ -0,0 +1,249 @@
+// Dependencies:
+//
+//    - jquery.fills.js
+//    - jquery.event.resize.js
+//    - jquery.dimensions.js
+//    - jquery/event/reverse/reverse.js
+//    - jquery.styles.js
+
+(function( $ ) {
+	//evil things we should ignore
+	var matches = /script|td/,
+
+		// if we are trying to fill the page
+		isThePage = function( el ) {
+			return el === document || el === document.documentElement || el === window || el === document.body
+		},
+		//if something lets margins bleed through
+		bleeder = function( el ) {
+			if ( el[0] == window ) {
+				return false;
+			}
+			var styles = el.styles('borderBottomWidth', 'paddingBottom')
+			return !parseInt(styles.borderBottomWidth) && !parseInt(styles.paddingBottom)
+		},
+		//gets the bottom of this element
+		bottom = function( el, offset ) {
+			//where offsetTop starts
+			return el.outerHeight() + offset(el);
+		}
+		pageOffset = function( el ) {
+			return el.offset().top
+		},
+		offsetTop = function( el ) {
+			return el[0].offsetTop;
+		},
+		inFloat = function( el, parent ) {
+			while ( el && el != parent ) {
+				var flt = $(el).css('float')
+				if ( flt == 'left' || flt == 'right' ) {
+					return flt;
+				}
+				el = el.parentNode
+			}
+		},
+		/**
+		 * @function jQuery.fn.fills
+		 * @parent jQuery.fills
+		 * @test jquery/dom/fills/funcunit.html
+		 * @plugin jquery/dom/fills
+		 *
+		 * Fills a parent element's height with the current element.
+		 * This is extremely useful for complex layout, especially when you want to account for line-wrapping.
+		 *
+		 * ## Basic Example
+		 *
+		 * If you have the following html:
+		 *
+		 *     <div id='box'>
+		 * 	    <p>I am a long heading.</p>
+		 * 	    <div id='child'>I'm a child.</div>
+		 *     </div>
+		 *
+		 * The follow makes `#child` fill up `#box`:
+		 *
+		 *     $('#child').can_ui_layout_fill("#box")
+		 *
+		 * ## Limitations
+		 *
+		 * Fill currently does not well with:
+		 *
+		 *   - Bleeding margins - Where margins leak through parent elements
+		 *     because the parent elements do not have a padding or border.
+		 *
+		 *   - Tables - You shouldn't be using tables to do layout anyway.
+		 *
+		 *   - Floated Elements - the child element has `float: left` or `float: right`
+		 *
+		 *
+		 * @param {HTMLElement|selector|Object} [parent] the parent element
+		 * to fill, defaults to the element's parent.
+		 *
+		 * The following fills the parent to `#child`:
+		 *
+		 *     $('#child').fills()
+		 *
+		 * A selector can also be pased.  This selector is passed to jQuery's
+		 * closet method.  The following matches the first `#parent` element that
+		 * is a parentNode of `#child`:
+		 *
+		 *     $('#child').fills("#parent")
+		 *
+		 * An element or window can also be passed.  The following will make
+		 * `#child` big enough so the entire window is filled:
+		 *
+		 *      $('#child').fills(window)
+		 *
+		 * If you pass an object, the following options are available:
+		 *
+		 * - __parent__ - The parent element selector or jQuery object
+		 * - __className__ - A class name to add to the element that fills
+		 * - __all__ - Reset the parents height when resizing
+		 *
+		 * @return {jQuery} the original jQuery collection for chaining.
+		 */
+		filler = $.fn.fills = function( parent ) {
+			var options = parent;
+			options || (options = {});
+			if(typeof options == 'string'){
+				options = this.closest(options)
+			}
+			if ( options.jquery || options.nodeName ) {
+				options = {parent: options };
+			}
+			// Set the parent
+			options.parent || (options.parent = $(this).parent());
+			options.parent = $(options.parent)
+
+			// setup stuff on every element
+			if(options.className) {
+				this.addClass(options.className)
+			}
+
+			var thePage = isThePage(options.parent[0]);
+			
+			if ( thePage ) {
+				options.parent = $(window)
+			}
+
+			this.each(function(){
+				var evData = {
+					filler: $(this),
+					inFloat: inFloat(this, thePage ? document.body : options.parent[0]),
+					options: options
+				},
+				cb = function() {
+					filler.parentResize.apply(this, arguments)
+				}
+				// Attach to the `resize` event
+				$(options.parent).bind('resize', evData, cb);
+
+				$(this).bind('destroyed', evData, function( ev ) {
+					if(options.className) {
+						$(ev.target).removeClass(options.className)
+					}
+					$(options.parent).unbind('resize', cb)
+				});
+				
+			});
+
+			// resize to get things going
+			var func = function() {
+				options.parent.resize();
+			}
+
+			if ( $.isReady ) {
+				func();
+			} else {
+				$(func)
+			}
+			return this;
+		};
+
+
+	$.extend(filler, {
+		parentResize : function( ev ) {
+			if (ev.data.filler.is(':hidden')) {
+				return;
+			}
+			
+			var parent = $(this),
+				isWindow = this == window,
+				container = (isWindow ? $(document.body) : parent),
+
+				//if the parent bleeds margins, we don't care what the last element's margin is
+				isBleeder = bleeder(parent),
+				children = container.children().filter(function() {
+					if ( matches.test(this.nodeName.toLowerCase()) ) {
+						return false;
+					}
+
+					var get = $.styles(this, ['position', 'display']);
+					return get.position !== "absolute" && get.position !== "fixed"
+						&& get.display !== "none" && !jQuery.expr.filters.hidden(this)
+				}),
+				last = children.eq(-1),
+				first,
+				parentHeight = parent.height() - (isWindow ? parseInt(container.css('marginBottom'), 10) || 0 : 0),
+				currentSize;
+			var div = '<div style="height: 0px; line-height:0px;overflow:hidden;' + (ev.data.inFloat ? 'clear: both' : '') + ';"/>'
+
+			if ( isBleeder ) {
+				//temporarily add a small div to use to figure out the 'bleed-through' margin
+				//of the last element
+				last = $(div).appendTo(container);
+				
+			}
+
+			//for performance, we want to figure out the currently used height of the parent element
+			// as quick as possible
+			// we can use either offsetTop or offset depending ...
+			if ( last && last.length > 0 ) {
+				if ( last.offsetParent()[0] === container[0] ) {
+
+					currentSize = last[0].offsetTop + last.outerHeight();
+				} else if (last.offsetParent()[0] === container.offsetParent()[0]) {
+					// add pos abs for IE7 but
+					// might need to adjust for the addition of first's hheight
+					var curLast =last[0].offsetTop;
+					first = $(div).prependTo(container);
+					
+					currentSize = ( curLast + last.outerHeight() ) - first[0].offsetTop;
+					
+					first.remove();
+				} else {
+					// add first so we know where to start from .. do not bleed in this case
+					first = $(div).prependTo(container);
+
+					currentSize = ( last.offset().top + last.outerHeight() ) - first.offset().top;
+					first.remove();
+				}
+			}
+
+			// what the difference between the parent height and what we are going to take up is
+			var delta = parentHeight - currentSize,
+				// the current height of the object
+				fillerHeight = ev.data.filler.height();
+
+			//adjust the height
+			if ( ev.data.options.all ) {
+				// we don't care about anything else, we are likely absolutely positioned
+				// we need to fill the parent width
+				// temporarily collapse, then expand
+				ev.data.filler.height(0).width(0);
+				var parentWidth = parent.width(),
+					parentHeight = parent.height();
+
+				ev.data.filler.outerHeight(parentHeight);
+				ev.data.filler.outerWidth(parentWidth);
+			} else {
+				ev.data.filler.height(fillerHeight + delta)
+			}
+
+			//remove the temporary element
+			if ( isBleeder ) {
+				last.remove();
+			}
+		}
+	});
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.form_params.js

@@ -0,0 +1,167 @@
+//    - jquery.form_params.js
+(function( $ ) {
+	var
+		// use to parse bracket notation like my[name][attribute]
+		keyBreaker = /[^\[\]]+/g,
+		// converts values that look like numbers and booleans and removes empty strings
+		convertValue = function( value ) {
+			if ( $.isNumeric( value )) {
+				return parseFloat( value );
+			} else if ( value === 'true') {
+				return true;
+			} else if ( value === 'false' ) {
+				return false;
+			} else if ( value === '' ) {
+				return undefined;
+			}
+			return value;
+		},
+		// Access nested data
+		nestData = function( elem, type, data, parts, value, seen, fullName ) {
+			var name = parts.shift();
+			// Keep track of the dot separated fullname. Used to uniquely track seen values
+			// and if they should be converted to an array or not
+			fullName = fullName ? fullName + '.' + name : name;
+
+			if (parts.length ) {
+				if ( ! data[ name ] ) {
+					data[ name ] = {};
+				}
+
+				// Recursive call
+				nestData( elem, type, data[ name ], parts, value, seen, fullName);
+			} else {
+
+				// Handle same name case, as well as "last checkbox checked"
+				// case
+				if ( fullName in seen && type != "radio" && ! $.isArray( data[ name ] )) {
+					if ( name in data ) {
+						data[ name ] = [ data[name] ];
+					} else {
+						data[ name ] = [];
+					}
+				} else {
+					seen[ fullName ] = true;
+				}
+
+				// Finally, assign data
+				if ( ( type == "radio" || type == "checkbox" ) && ! elem.is(":checked") ) {
+					return
+				}
+
+				if ( ! data[ name ] ) {
+					data[ name ] = value;
+				} else {
+					data[ name ].push( value );
+				}
+				
+
+			}
+
+		};
+
+	/**
+	 * @function jQuery.fn.formParams
+	 * @parent jQuery.formParams
+	 * @plugin jquery/dom/form_params
+	 * @test jquery/dom/form_params/qunit.html
+	 *
+	 * Returns a JavaScript object for values in a form.
+	 * It creates nested objects by using bracket notation in the form element name.
+	 *
+	 * @param {Object} [params] If an object is passed, the form will be repopulated
+	 * with the values of the object based on the name of the inputs within
+	 * the form
+	 * @param {Boolean} [convert=false] True if strings that look like numbers
+	 * and booleans should be converted and if empty string should not be added
+	 * to the result.
+	 * @return {Object} An object of name-value pairs.
+	 */
+	$.fn.extend({
+		formParams: function( params ) {
+
+			var convert;
+
+			// Quick way to determine if something is a boolean
+			if ( !! params === params ) {
+				convert = params;
+				params = null;
+			}
+
+			if ( params ) {
+				return this.setParams( params );
+			} else {
+				return this.getParams( convert );
+			}
+		},
+		setParams: function( params ) {
+
+			// Find all the inputs
+			this.find("[name]").each(function() {
+				
+				var value = params[ $(this).attr("name") ],
+					$this;
+				
+				// Don't do all this work if there's no value
+				if ( value !== undefined ) {
+					$this = $(this);
+					
+					// Nested these if statements for performance
+					if ( $this.is(":radio") ) {
+						if ( $this.val() == value ) {
+							$this.attr("checked", true);
+						}
+					} else if ( $this.is(":checkbox") ) {
+						// Convert single value to an array to reduce
+						// complexity
+						value = $.isArray( value ) ? value : [value];
+						if ( $.inArray( $this.val(), value ) > -1) {
+							$this.attr("checked", true);
+						}
+					} else {
+						$this.val( value );
+					}
+				}
+			});
+		},
+		getParams: function( convert ) {
+			var data = {},
+				// This is used to keep track of the checkbox names that we've
+				// already seen, so we know that we should return an array if
+				// we see it multiple times. Fixes last checkbox checked bug.
+				seen = {},
+				current;
+
+			this.find("[name]:not(:disabled)").each(function() {
+				var $this    = $(this),
+					type     = $this.attr("type"),
+					name     = $this.attr("name"),
+					value    = $this.val(),
+					parts;
+
+				// Don't accumulate submit buttons and nameless elements
+				if ( type == "submit" || ! name ) {
+					return;
+				}
+
+				// Figure out name parts
+				parts = name.match( keyBreaker );
+				if ( ! parts.length ) {
+					parts = [name];
+				}
+
+				// Convert the value
+				if ( convert ) {
+					value = convertValue( value );
+				}
+
+				// Assign data recursively
+				nestData( $this, type, data, parts, value, seen );
+
+			});
+
+			return data;
+		}
+	});
+
+})(jQuery)