jquerypp-rails 1.0

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

@@ -0,0 +1,191 @@
+// Dependencies:
+//
+//    - jquery.dimensions.js
+//    - jquery.styles.js
+
+(function($) {
+
+var
+	//margin is inside border
+	weird = /button|select/i,
+	getBoxes = {},
+    checks = {
+        width: ["Left", "Right"],
+        height: ['Top', 'Bottom'],
+        oldOuterHeight: $.fn.outerHeight,
+        oldOuterWidth: $.fn.outerWidth,
+        oldInnerWidth: $.fn.innerWidth,
+        oldInnerHeight: $.fn.innerHeight
+    };
+
+$.each({ 
+
+/**
+ * @function jQuery.fn.outerWidth
+ * @parent jQuery.dimensions
+ *
+ * `jQuery.fn.outerWidth([value], [includeMargins])` lets you set
+ * the outer width of an object where:
+ *
+ *      outerWidth = width + padding + border + (margin)
+ *
+ * And can be used like:
+ *
+ *      $("#foo").outerWidth(100); //sets outer width
+ *      $("#foo").outerWidth(100, true); // uses margins
+ *      $("#foo").outerWidth(); //returns outer width
+ *      $("#foo").outerWidth(true); //returns outer width + margins
+ *
+ * When setting the outerWidth, it adjusts the width of the element.
+ * If *includeMargin* is set to `true` margins will also be included.
+ * It is also possible to animate the outer width:
+ * 
+ *      $('#foo').animate({ outerWidth: 200 });
+ *
+ * @param {Number} [width] The width to set
+ * @param {Boolean} [includeMargin=false] Makes setting the outerWidth adjust
+ * for margins.
+ * @return {jQuery|Number} Returns the outer width or the jQuery wrapped elements
+ * if you are setting the outer width.
+ */
+width: 
+/**
+ * @function jQuery.fn.innerWidth
+ * @parent jQuery.dimensions
+ *
+ * `jQuery.fn.innerWidth([value])` lets you set the inner width of an element where
+ * 
+ *      innerWidth = width + padding
+ *      
+ * Use it like:
+ *
+ *      $("#foo").innerWidth(100); //sets inner width
+ *      $("#foo").outerWidth(); // returns inner width
+ *      
+ * Or in an animation like:
+ * 
+ *      $('#foo').animate({ innerWidth : 200 });
+ *
+ * Setting inner width adjusts the width of the element.
+ *
+ * @param {Number} [width] The inner width to set
+ * @return {jQuery|Number} Returns the inner width or the jQuery wrapped elements
+ * if you are setting the inner width.
+ */
+"Width", 
+/**
+ * @function jQuery.fn.outerHeight
+ * @parent jQuery.dimensions
+ *
+ * `jQuery.fn.outerHeight([value], [includeMargins])` lets
+ * you set the outer height of an object where:
+ *
+ *      outerHeight = height + padding + border + (margin)
+ *
+ * And can be used like:
+ *
+ *      $("#foo").outerHeight(100); //sets outer height
+ *      $("#foo").outerHeight(100, true); // uses margins
+ *      $("#foo").outerHeight(); //returns outer height
+ *      $("#foo").outerHeight(true); //returns outer height + margins
+ *
+ * When setting the outerHeight, it adjusts the height of the element.
+ * If *includeMargin* is set to `true` margins will also be included.
+ * It is also possible to animate the outer heihgt:
+ *
+ *      $('#foo').animate({ outerHeight : 200 });
+ *
+ * @param {Number} [height] The height to set
+ * @param {Boolean} [includeMargin=false] Makes setting the outerHeight adjust
+ * for margins.
+ * @return {jQuery|Number} Returns the outer height or the jQuery wrapped elements
+ * if you are setting the outer height.
+ */
+height: 
+/**
+ * @function jQuery.fn.innerHeight
+ * @parent jQuery.dimensions
+ *
+ * `jQuery.fn.innerHeight([value])` lets you set the inner height of an element where
+ *
+ *      innerHeight = height + padding
+ *
+ * Use it like:
+ *
+ *      $("#foo").innerHeight(100); //sets inner height
+ *      $("#foo").outerHeight(); // returns inner height
+ *
+ * Or in an animation like:
+ *
+ *      $('#foo').animate({ innerHeight : 200 });
+ *
+ * Setting inner height adjusts the height of the element.
+ *
+ * @param {Number} [height] The inner height to set
+ * @return {jQuery|Number} Returns the inner height or the jQuery wrapped elements
+ * if you are setting the inner height.
+ */
+// for each 'height' and 'width'
+"Height" }, function(lower, Upper) {
+
+    //used to get the padding and border for an element in a given direction
+    getBoxes[lower] = function(el, boxes) {
+        var val = 0;
+        if (!weird.test(el.nodeName)) {
+            //make what to check for ....
+            var myChecks = [];
+            $.each(checks[lower], function() {
+                var direction = this;
+                $.each(boxes, function(name, val) {
+                    if (val)
+                        myChecks.push(name + direction+ (name == 'border' ? "Width" : "") );
+                })
+            })
+            $.each($.styles(el, myChecks), function(name, value) {
+                val += (parseFloat(value) || 0);
+            })
+        }
+        return val;
+    }
+
+    //getter / setter
+    $.fn["outer" + Upper] = function(v, margin) {
+        var first = this[0];
+		if (typeof v == 'number') {
+			// Setting the value
+            first && this[lower](v - getBoxes[lower](first, {padding: true, border: true, margin: margin}))
+            return this;
+        } else {
+			// Return the old value
+            return first ? checks["oldOuter" + Upper].call(this, v) : null;
+        }
+    }
+    $.fn["inner" + Upper] = function(v) {
+        var first = this[0];
+		if (typeof v == 'number') {
+			// Setting the value
+            first&& this[lower](v - getBoxes[lower](first, { padding: true }))
+            return this;
+        } else {
+			// Return the old value
+            return first ? checks["oldInner" + Upper].call(this, v) : null;
+        }
+    }
+    //provides animations
+	var animate = function(boxes){
+		// Return the animation function
+		return function(fx){
+			if (fx.state == 0) {
+	            fx.start = $(fx.elem)[lower]();
+	            fx.end = fx.end - getBoxes[lower](fx.elem,boxes);
+	        }
+	        fx.elem.style[lower] = (fx.pos * (fx.end - fx.start) + fx.start) + "px"
+		}
+	}
+    $.fx.step["outer" + Upper] = animate({padding: true, border: true})
+	$.fx.step["outer" + Upper+"Margin"] =  animate({padding: true, border: true, margin: true})
+	$.fx.step["inner" + Upper] = animate({padding: true})
+
+})
+
+})(jQuery)

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

@@ -0,0 +1,115 @@
+//    - jquery.event.default.js
+(function($){
+
+/**
+ * @function jQuery.fn.triggerAsync
+ * @parent jQuery.event.pause
+ * @plugin jquery/event/default
+ *
+ * `jQuery.fn.triggerAsync(type, [data], [success], [prevented]` triggers an event and calls success
+ * when the event has finished propagating through the DOM and no other handler
+ * called `event.preventDefault()` or returned `false`.
+ *
+ *     $('#panel').triggerAsync('show', function() {
+ *        $('#panel').show();
+ *     });
+ *
+ * You can also provide a callback that gets called if `event.preventDefault()` was called on the event:
+ *
+ *     $('panel').triggerAsync('show', function(){
+ *         $('#panel').show();
+ *     },function(){ 
+ *         $('#other').addClass('error');
+ *     });
+ *
+ * @param {String} type The type of event
+ * @param {Object} data The data for the event
+ * @param {Function} success a callback function which occurs upon success
+ * @param {Function} prevented a callback function which occurs if preventDefault was called
+ */
+$.fn.triggerAsync = function(type, data, success, prevented){
+	if(typeof data == 'function'){
+		success = data;
+		data = undefined;
+	}
+	
+	if ( this[0] ) {
+		// Create a new jQuery event object and store the original preventDefault
+		var event = $.Event( type ),
+			old = event.preventDefault;
+
+		event.preventDefault = function(){
+			old.apply(this, arguments);
+			// call the prevented callback when event.preventDefault is called
+			prevented && prevented(this)
+		}
+		// Trigger the event with the success callback as the success handler
+		jQuery.event.trigger( {type: type, _success: success}, data, this[0]  );
+	} else{
+		// If we have no elements call the success callback right away
+		success.call(this);
+	}
+	return this;
+}
+	
+
+
+/**
+ * @add jQuery.event.special
+ */
+//cache default types for performance
+var types = {}, rnamespaces= /\.(.*)$/, $event = $.event;
+/**
+ * @attribute default
+ * @parent specialevents
+ * @plugin jquery/event/default
+ * @download  http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/default/default.js
+ * @test jquery/event/default/qunit.html
+ *
+ */
+$event.special["default"] = {
+	add: function( handleObj ) {
+		//save the type
+		types[handleObj.namespace.replace(rnamespaces,"")] = true;
+	},
+	setup: function() {return true}
+}
+
+// overwrite trigger to allow default types
+var oldTrigger = $event.trigger;
+
+$event.trigger =  function defaultTriggerer( event, data, elem, onlyHandlers){
+	// Event object or event type
+	var type = event.type || event,
+		// Caller can pass in an Event, Object, or just an event type string
+		event = typeof event === "object" ?
+			// jQuery.Event object
+			event[ jQuery.expando ] ? event :
+			// Object literal
+			new jQuery.Event( type, event ) :
+			// Just the event type (string)
+			new jQuery.Event( type),
+		res = oldTrigger.call($.event, event, data, elem, onlyHandlers);
+	
+	if(!onlyHandlers && !event.isDefaultPrevented() && event.type.indexOf("default") !== 0) {
+		// Trigger the default. event
+		oldTrigger("default."+event.type, data, elem)
+		if(event._success){
+			event._success(event)
+		}
+	}
+	// code for paused
+	if( event.isPaused && event.isPaused() ){
+		// set back original stuff
+		event.isDefaultPrevented = 
+			event.pausedState.isDefaultPrevented;
+		event.isPropagationStopped = 
+			event.pausedState.isPropagationStopped;
+	}
+	return res;
+};
+	
+	
+	
+	
+})(jQuery)

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

@@ -0,0 +1,23 @@
+//    - jquery.event.destroyed.js
+(function( $ ) {
+	/**
+	 * @attribute destroyed
+	 * @download  http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/dom/destroyed/destroyed.js
+	 * @test jquery/event/destroyed/qunit.html
+	 */
+
+	// Store the old jQuery.cleanData
+	var oldClean = jQuery.cleanData;
+
+	// Overwrites cleanData which is called by jQuery on manipulation methods
+	$.cleanData = function( elems ) {
+		for ( var i = 0, elem;
+		(elem = elems[i]) !== undefined; i++ ) {
+			// Trigger the destroyed event
+			$(elem).triggerHandler("destroyed");
+		}
+		// Call the old jQuery.cleanData
+		oldClean(elems);
+	};
+
+})(jQuery)