This is a text

').text("todos") + * .appendTo(document.body) + * // indicate we want our mouse on the top-right of it + * drag.representative(rep, rep.width(), 0); + * }) + * + * @param {HTMLElement} element the element you want to actually drag. This should be + * already in the DOM. + * @param {Number} offsetX the x position where you want your mouse on the representative element (defaults to 0) + * @param {Number} offsetY the y position where you want your mouse on the representative element (defaults to 0) + * @return {drag} returns the drag object for chaining. + */ + representative: function( element, offsetX, offsetY ) { + this._offsetX = offsetX || 0; + this._offsetY = offsetY || 0; + + var p = this.mouseStartPosition; + // Just set the representative as the drag element + this.movingElement = $(element); + this.movingElement.css({ + top: (p.y() - this._offsetY) + "px", + left: (p.x() - this._offsetX) + "px", + display: 'block', + position: 'absolute' + }).show(); + this.noSelection(this.movingElement) + this.mouseElementPosition = new $.Vector(this._offsetX, this._offsetY); + return this; + }, + /** + * `drag.revert([val])` makes the [$.Drag::representative representative] element revert back to it + * original position after the drag motion has completed. The revert is done with an animation. + * + * $("#todos").on(".handle","dragend",function( ev, drag ) { + * drag.revert(); + * }) + * + * @param {Boolean} [val] optional, set to false if you don't want to revert. + * @return {drag} the drag object for chaining + */ + revert: function( val ) { + this._revert = val === undefined ? true : val; + return this; + }, + /** + * `drag.vertical()` isolates the drag to vertical movement. For example: + * + * $("#images").on(".thumbnail","draginit", function(ev, drag){ + * drag.vertical(); + * }); + * + * Call `vertical()` in "draginit" or "dragdown". + * + * @return {drag} the drag object for chaining. + */ + vertical: function() { + this._vertical = true; + return this; + }, + /** + * `drag.horizontal()` isolates the drag to horizontal movement. For example: + * + * $("#images").on(".thumbnail","draginit", function(ev, drag){ + * drag.horizontal(); + * }); + * + * Call `horizontal()` in "draginit" or "dragdown". + * + * @return {drag} the drag object for chaining. + */ + horizontal: function() { + this._horizontal = true; + return this; + }, + /** + * `drag.only([only])` indicates if you __only__ want a drag motion and the drag should + * not notify drops. The default value is `false`. Call it with no arguments or pass it true + * to prevent drop events. + * + * $("#images").on(".thumbnail","dragdown", function(ev, drag){ + * drag.only(); + * }); + * + * @param {Boolean} [only] true if you want to prevent drops, false if otherwise. + * @return {Boolean} the current value of only. + */ + only: function( only ) { + return (this._only = (only === undefined ? true : only)); + }, + + /** + * `distance([val])` sets or reads the distance the mouse must move before a drag motion is started. This should be set in + * "dragdown" and delays "draginit" being called until the distance is covered. The distance + * is measured in pixels. The default distance is 0 pixels meaning the drag motion starts on the first + * mousemove after a mousedown. + * + * Set this to make drag motion a little "stickier" to start. + * + * $("#images").on(".thumbnail","dragdown", function(ev, drag){ + * drag.distance(10); + * }); + * + * @param {Number} [val] The number of pixels the mouse must move before "draginit" is called. + * @return {drag|Number} returns the drag instance for chaining if the drag value is being set or the + * distance value if the distance is being read. + */ + distance: function(val){ + if(val !== undefined){ + this._distance = val; + return this; + }else{ + return this._distance + } + } + }); + /** + * @add jQuery.event.special + */ + event.setupHelper([ + /** + * @attribute dragdown + * @parent jQuery.event.drag + * + * `dragdown` is called when a drag movement has started on a mousedown. + * The event handler gets an instance of [jQuery.Drag] passed as the second + * parameter. Listening to `dragdown` allows you to customize + * the behavior of a drag motion, especially when `draginit` should be called. + * + * $(".handles").delegate("dragdown", function(ev, drag){ + * // call draginit only when the mouse has moved 20 px + * drag.distance(20); + * }) + * + * Typically, when a drag motion is started, `event.preventDefault` is automatically + * called, preventing text selection. However, if you listen to + * `dragdown`, this default behavior is not called. You are responsible for calling it + * if you want it (you probably do). + * + * ### Why might you not want to call `preventDefault`? + * + * You might want it if you want to allow text selection on element + * within the drag element. Typically these are input elements. + * + * $(".handles").delegate("dragdown", function(ev, drag){ + * if(ev.target.nodeName === "input"){ + * drag.cancel(); + * } else { + * ev.preventDefault(); + * } + * }) + */ + 'dragdown', + /** + * @attribute draginit + * @parent jQuery.event.drag + * + * `draginit` is triggered when the drag motion starts. Use it to customize the drag behavior + * using the [jQuery.Drag] instance passed as the second parameter: + * + * $(".draggable").on('draginit', function(ev, drag) { + * // Only allow vertical drags + * drag.vertical(); + * // Create a draggable copy of the element + * drag.ghost(); + * }); + */ + 'draginit', + /** + * @attribute dragover + * @parent jQuery.event.drag + * + * `dragover` is triggered when a drag is over a [jQuery.event.drop drop element]. + * The event handler gets an instance of [jQuery.Drag] passed as the second + * parameter and an instance of [jQuery.Drop] passed as the third argument: + * + * $('.draggable').on('dragover', function(ev, drag, drop) { + * // Add the drop-here class indicating that the drag + * // can be dropped here + * drag.element.addClass('drop-here'); + * }); + */ + 'dragover', + /** + * @attribute dragmove + * @parent jQuery.event.drag + * + * `dragmove` is triggered when the drag element moves (similar to a mousemove). + * The event handler gets an instance of [jQuery.Drag] passed as the second + * parameter. + * Use [jQuery.Drag::location] to determine the current position + * as a [jQuery.Vector vector]. + * + * For example, `dragmove` can be used to create a draggable element to resize + * a container: + * + * $('.resizer').on('dragmove', function(ev, drag) { + * $('#container').width(drag.location.x()) + * .height(drag.location.y()); + * }); + */ + 'dragmove', + /** + * @attribute dragout + * @parent jQuery.event.drag + * + * `dragout` is called when the drag leaves a drop point. + * The event handler gets an instance of [jQuery.Drag] passed as the second + * parameter. + * + * $('.draggable').on('dragout', function(ev, drag) { + * // Remove the drop-here class + * // (e.g. crossing the drag element out indicating that it + * // can't be dropped here + * drag.element.removeClass('drop-here'); + * }); + */ + 'dragout', + /** + * @attribute dragend + * @parent jQuery.event.drag + * + * `dragend` is called when the drag operation is completed. + * The event handler gets an instance of [jQuery.Drag] passed as the second + * parameter. + * + * $('.draggable').on('dragend', function(ev, drag) + * // Calculation on whether revert should be invoked, alterations based on position of the end event + * }); + */ + 'dragend', + /** + * @attribute dragcleanup + * @parent jQuery.event.drag + * + * `dragcleanup` is called after dragend and revert (if applied) + * The event handler gets an instance of [jQuery.Drag] passed as the second + * parameter. + * + * $('.draggable').on('dragcleanup', function(ev, drag) + * // cleanup + * }); + */ + 'dragcleanup'], startEvent, function( e ) { + $.Drag.mousedown.call($.Drag, e, this); + }); + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/drag/limit.js b/dist/event/drag/limit.js new file mode 100644 index 00000000..b24eaa1a --- /dev/null +++ b/dist/event/drag/limit.js @@ -0,0 +1,76 @@ +(function( $ ) { + + + $.Drag.prototype + /** + * @function limit + * @plugin jquery/event/drag/limit + * @download http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/event/drag/limit/limit.js + * `drag.limit(container, [center])` limits a drag to a containing element. + * + * $("#todos").on(".todo","draginit", function( ev, drag ) { + * drag.limit($("#todos").parent()) + * }) + * + * @param {jQuery} container the jQuery-wrapped container element you do not want the drag element to escape. + * @param {String} [center] can set the limit to the center of the object. Can be + * 'x', 'y' or 'both'. By default it will keep the outer edges of the moving element within the + * container element. If you provide x, it will keep the horizontal center of the moving element + * within the container element. If you provide y, it will keep the vertical center of the moving + * element within the container element. If you provide both, it will keep the center of the + * moving element within the containing element. + * @return {drag} returns the drag for chaining. + */ + .limit = function( container, center ) { + //on draws ... make sure this happens + var styles = container.styles('borderTopWidth', 'paddingTop', 'borderLeftWidth', 'paddingLeft'), + paddingBorder = new $.Vector( + parseInt(styles.borderLeftWidth, 10) + parseInt(styles.paddingLeft, 10) || 0, parseInt(styles.borderTopWidth, 10) + parseInt(styles.paddingTop, 10) || 0); + + this._limit = { + offset: container.offsetv().plus(paddingBorder), + size: container.dimensionsv(), + center : center === true ? 'both' : center + }; + return this; + }; + + var oldPosition = $.Drag.prototype.position; + $.Drag.prototype.position = function( offsetPositionv ) { + //adjust required_css_position accordingly + if ( this._limit ) { + var limit = this._limit, + center = limit.center && limit.center.toLowerCase(), + movingSize = this.movingElement.dimensionsv('outer'), + halfHeight = center && center != 'x' ? movingSize.height() / 2 : 0, + halfWidth = center && center != 'y' ? movingSize.width() / 2 : 0, + lot = limit.offset.top(), + lof = limit.offset.left(), + height = limit.size.height(), + width = limit.size.width(); + + //check if we are out of bounds ... + //above + if ( offsetPositionv.top()+halfHeight < lot ) { + offsetPositionv.top(lot - halfHeight); + } + //below + if ( offsetPositionv.top() + movingSize.height() - halfHeight > lot + height ) { + offsetPositionv.top(lot + height - movingSize.height() + halfHeight); + } + //left + if ( offsetPositionv.left()+halfWidth < lof ) { + offsetPositionv.left(lof - halfWidth); + } + //right + if ( offsetPositionv.left() + movingSize.width() -halfWidth > lof + width ) { + offsetPositionv.left(lof + width - movingSize.left()+halfWidth); + } + } + + oldPosition.call(this, offsetPositionv); + }; + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/drag/scroll.js b/dist/event/drag/scroll.js new file mode 100644 index 00000000..f0669449 --- /dev/null +++ b/dist/event/drag/scroll.js @@ -0,0 +1,153 @@ +(function($) { //needs drop to determine if respondable + +/** + * @add jQuery.Drag.prototype + */ +$.Drag.prototype. + /** + * @plugin jquery/event/drag/scroll + * @download http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/drag/scroll/scroll.js + * + * `drag.scrolls(elements, [options])` scroll elements with + * a scroll bar as the drag moves to borders. + * + * The following sets up the drag motions to scroll `#todos` and the window. Scrolling will + * start 50px away from a boundary and the speed will increase to 50px of scroll every 15ms. + * + * $('#todos').on(".todo","draginit", function(ev, drag){ + * drag.scrolls($('#todos').add(window), { + * distance : 50, + * delta : function(diff) { return (50 - diff) / 2}, + * direction : "y" + * }) + * }) + * + * @param {jQuery} elements an array of elements to scroll. The window can be in this array. + * @param {Object} [options] changes the default settings. + * + * - `distance` {number} 30 - how many pixels away from a boundry where we start scrolling + * - `delta(diff)` {Function} - returns how far we should scroll. It is passed how many pixels the cursor is + * from the boundry. + * - `direction` {String} - direction scrolling should happen. "xy" is the default. + */ + scrolls = function(elements, options){ + var elements = $(elements); + + for(var i = 0 ; i < elements.length; i++){ + this.constructor.responder._elements.push( elements.eq(i).data("_dropData", new $.Scrollable(elements[i], options) )[0] ) + } + }, + +$.Scrollable = function(element, options){ + this.element = jQuery(element); + this.options = $.extend({ + // when we should start scrolling + distance : 30, + // how far we should move + delta : function(diff, distance){ + return (distance - diff) / 2; + }, + direction: "xy" + }, options); + this.x = this.options.direction.indexOf("x") != -1; + this.y = this.options.direction.indexOf("y") != -1; +} +$.extend($.Scrollable.prototype,{ + init: function( element ) { + this.element = jQuery(element); + }, + callHandlers: function( method, el, ev, drag ) { + this[method](el || this.element[0], ev, this, drag) + }, + dropover: function() { + + }, + dropon: function() { + this.clear_timeout(); + }, + dropout: function() { + this.clear_timeout(); + }, + dropinit: function() { + + }, + dropend: function() {}, + clear_timeout: function() { + if(this.interval){ + clearTimeout(this.interval) + this.interval = null; + } + }, + distance: function( diff ) { + return (30 - diff) / 2; + }, + dropmove: function( el, ev, drop, drag ) { + + //if we were about to call a move, clear it. + this.clear_timeout(); + + //position of the mouse + var mouse = ev.vector(), + + //get the object we are going to get the boundries of + location_object = $(el == document.documentElement ? window : el), + + //get the dimension and location of that object + dimensions = location_object.dimensionsv('outer'), + position = location_object.offsetv(), + + //how close our mouse is to the boundries + bottom = position.y()+dimensions.y() - mouse.y(), + top = mouse.y() - position.y(), + right = position.x()+dimensions.x() - mouse.x(), + left = mouse.x() - position.x(), + + //how far we should scroll + dx =0, dy =0, + distance = this.options.distance; + + //check if we should scroll + if(bottom < distance && this.y) { + dy = this.options.delta(bottom,distance); + } else if(top < distance && this.y) { + dy = -this.options.delta(top,distance); + } + + if(right < distance && this.options && this.x) { + dx = this.options.delta(right,distance); + } else if(left < distance && this.x) { + dx = -this.options.delta(left,distance); + } + + //if we should scroll + if(dx || dy){ + //set a timeout that will create a mousemove on that object + var self = this; + this.interval = setTimeout( function(){ + self.move($(el), drag.movingElement, dx, dy, ev, ev.clientX, ev.clientY, ev.screenX, ev.screenY) + },15) + } + }, + /** + * Scrolls an element then calls mouse a mousemove in the same location. + * @hide + */ + move: function( scroll_element, drag_element, dx, dy, ev/*, x,y,sx, sy*/ ) { + scroll_element.scrollTop( scroll_element.scrollTop() + dy); + scroll_element.scrollLeft(scroll_element.scrollLeft() + dx); + + drag_element.trigger( + $.event.fix({type: "mousemove", + clientX: ev.clientX, + clientY: ev.clientY, + screenX: ev.screenX, + screenY: ev.screenY, + pageX: ev.pageX, + pageY: ev.pageY})) + //drag_element.synthetic('mousemove',{clientX: x, clientY: y, screenX: sx, screenY: sy}) + } +}) + +return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/drag/step.js b/dist/event/drag/step.js new file mode 100644 index 00000000..37504c94 --- /dev/null +++ b/dist/event/drag/step.js @@ -0,0 +1,81 @@ +(function( $ ) { + var round = function( x, m ) { + return Math.round(x / m) * m; + } + + $.Drag.prototype. + /** + * @function step + * @plugin jquery/event/drag/step + * @download http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/drag/step/step.js + * makes the drag move in steps of amount pixels. + * + * drag.step({x: 5}, $('foo'), "xy") + * + * ## Demo + * + * @demo jquery/event/drag/step/step.html + * + * @param {number|Object} amount make the drag move the amount in pixels from the top-left of container. + * + * If the amount is a `number`, the drag will move step-wise that number pixels in both + * dimensions. If it's an object like `{x: 20, y: 10}` the drag will move in steps 20px from + * left to right and 10px up and down. + * + * @param {jQuery} [container] the container to move in reference to. If not provided, the document is used. + * @param {String} [center] Indicates how to position the drag element in relationship to the container. + * + * - If nothing is provided, places the top left corner of the drag element at + * 'amount' intervals from the top left corner of the container. + * - If 'x' is provided, it centers the element horizontally on the top-left corner. + * - If 'y' is provided, it centers the element vertically on the top-left corner of the container. + * - If 'xy' is provided, it centers the element on the top-left corner of the container. + * + * @return {jQuery.Drag} the drag object for chaining. + */ + step = function( amount, container, center ) { + //on draws ... make sure this happens + if ( typeof amount == 'number' ) { + amount = { + x: amount, + y: amount + } + } + container = container || $(document.body); + this._step = amount; + + var styles = container.styles("borderTopWidth", "paddingTop", "borderLeftWidth", "paddingLeft"); + var top = parseInt(styles.borderTopWidth) + parseInt(styles.paddingTop), + left = parseInt(styles.borderLeftWidth) + parseInt(styles.paddingLeft); + + this._step.offset = container.offsetv().plus(left, top); + this._step.center = center; + return this; + }; + + (function() { + var oldPosition = $.Drag.prototype.position; + $.Drag.prototype.position = function( offsetPositionv ) { + //adjust required_css_position accordingly + if ( this._step ) { + var step = this._step, + center = step.center && step.center.toLowerCase(), + movingSize = this.movingElement.dimensionsv('outer'), + lot = step.offset.top()- (center && center != 'x' ? movingSize.height() / 2 : 0), + lof = step.offset.left() - (center && center != 'y' ? movingSize.width() / 2 : 0); + + if ( this._step.x ) { + offsetPositionv.left(Math.round(lof + round(offsetPositionv.left() - lof, this._step.x))) + } + if ( this._step.y ) { + offsetPositionv.top(Math.round(lot + round(offsetPositionv.top() - lot, this._step.y))) + } + } + + oldPosition.call(this, offsetPositionv) + } + })(); + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/drop.js b/dist/event/drop.js new file mode 100644 index 00000000..e6a78c8f --- /dev/null +++ b/dist/event/drop.js @@ -0,0 +1,456 @@ +(function($){ + var event = $.event; + /** + * @add jQuery.event.special + */ + var eventNames = [ + /** + * @attribute dropover + * @parent jQuery.event.drop + * + * `dropover` is triggered when a [jQuery.event.drag drag] is first moved onto this + * drop element. + * The event handler gets an instance of [jQuery.Drag] passed as the second and a + * [jQuery.Drop] as the third parameter. + * This event can be used to highlight the element when a drag is moved over it: + * + * $('.droparea').on('dropover', function(ev, drop, drag) { + * $(this).addClass('highlight'); + * }); + */ + "dropover", + /** + * @attribute dropon + * @parent jQuery.event.drop + * + * `dropon` is triggered when a drag is dropped on a drop element. + * The event handler gets an instance of [jQuery.Drag] passed as the second and a + * [jQuery.Drop] as the third parameter. + * + * $('.droparea').on('dropon', function(ev, drop, drag) { + * $(this).html('Dropped: ' + drag.element.text()); + * }); + */ + "dropon", + /** + * @attribute dropout + * @parent jQuery.event.drop + * + * `dropout` is called when a drag is moved out of this drop element. + * The event handler gets an instance of [jQuery.Drag] passed as the second and a + * [jQuery.Drop] as the third parameter. + * + * $('.droparea').on('dropover', function(ev, drop, drag) { + * // Remove the drop element highlight + * $(this).removeClass('highlight'); + * }); + */ + "dropout", + /** + * @attribute dropinit + * @parent jQuery.event.drop + * + * `dropinit` is called when a drag motion starts and the drop elements are initialized. + * The event handler gets an instance of [jQuery.Drag] passed as the second and a + * [jQuery.Drop] as the third parameter. + * Calling [jQuery.Drop.prototype.cancel drop.cancel()] prevents the element from + * being dropped on: + * + * $('.droparea').on('dropover', function(ev, drop, drag) { + * if(drag.element.hasClass('not-me')) { + * drop.cancel(); + * } + * }); + */ + "dropinit", + /** + * @attribute dropmove + * @parent jQuery.event.drop + * + * `dropmove` is triggered repeatedly when a drag is moved over a drop + * (similar to a mousemove). + * The event handler gets an instance of [jQuery.Drag] passed as the second and a + * [jQuery.Drop] as the third parameter. + * + * $('.droparea').on('dropmove', function(ev, drop, drag) { + * $(this).html(drag.location.x() + '/' + drag.location.y()); + * }); + */ + "dropmove", + /** + * @attribute dropend + * @parent jQuery.event.drop + * + * `dropend` is called when the drag motion is done for this drop element. + * The event handler gets an instance of [jQuery.Drag] passed as the second and a + * [jQuery.Drop] as the third parameter. + * + * + * $('.droparea').on('dropend', function(ev, drop, drag) { + * // Remove the drop element highlight + * $(this).removeClass('highlight'); + * }); + */ + "dropend"]; + + /** + * @class jQuery.Drop + * @parent jQuery.event.drop + * @plugin jquery/event/drop + * @download http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/drop/drop.js + * @test jquery/event/drag/qunit.html + * + * The `jQuery.Drop` constructor is never called directly but an instance is passed to the + * to the `dropinit`, `dropover`, `dropmove`, `dropon`, and `dropend` event handlers as the + * third argument (the second will be the [jQuery.Drag]): + * + * $('#dropper').on('dropover', function(el, drop, drag) { + * // drop -> $.Drop + * // drag -> $.Drag + * }); + */ + $.Drop = function(callbacks, element){ + $.extend(this,callbacks); + this.element = $(element); + } + // add the elements ... + $.each(eventNames, function(){ + event.special[this] = { + add: function( handleObj ) { + //add this element to the compiles list + var el = $(this), current = (el.data("dropEventCount") || 0); + el.data("dropEventCount", current+1 ) + if(current==0){ + $.Drop.addElement(this); + } + }, + remove: function() { + var el = $(this), current = (el.data("dropEventCount") || 0); + el.data("dropEventCount", current-1 ) + if(current<=1){ + $.Drop.removeElement(this); + } + } + } + }); + + $.extend($.Drop,{ + /** + * @static + */ + lowerName: "drop", + _rootElements: [], //elements that are listening for drops + _elements: $(), //elements that can be dropped on + last_active: [], + endName: "dropon", + // adds an element as a 'root' element + // this element might have events that we need to respond to + addElement: function( el ) { + // check other elements + for(var i =0; i < this._rootElements.length ; i++ ){ + if(el ==this._rootElements[i]) return; + } + this._rootElements.push(el); + }, + removeElement: function( el ) { + for(var i =0; i < this._rootElements.length ; i++ ){ + if(el == this._rootElements[i]){ + this._rootElements.splice(i,1) + return; + } + } + }, + /** + * @hide + * For a list of affected drops, sorts them by which is deepest in the DOM first. + */ + sortByDeepestChild: function( a, b ) { + // Use jQuery.compare to compare two elements + var compare = a.element.compare(b.element); + if(compare & 16 || compare & 4) return 1; + if(compare & 8 || compare & 2) return -1; + return 0; + }, + /** + * @hide + * Tests if a drop is within the point. + */ + isAffected: function( point, moveable, responder ) { + return ((responder.element != moveable.element) && (responder.element.within(point[0], point[1], responder._cache).length == 1)); + }, + /** + * @hide + * Calls dropout and sets last active to null + * @param {Object} drop + * @param {Object} drag + * @param {Object} event + */ + deactivate: function( responder, mover, event ) { + mover.out(event, responder) + responder.callHandlers(this.lowerName+'out',responder.element[0], event, mover) + }, + /** + * @hide + * Calls dropover + * @param {Object} drop + * @param {Object} drag + * @param {Object} event + */ + activate: function( responder, mover, event ) { //this is where we should call over + mover.over(event, responder) + responder.callHandlers(this.lowerName+'over',responder.element[0], event, mover); + }, + move: function( responder, mover, event ) { + responder.callHandlers(this.lowerName+'move',responder.element[0], event, mover) + }, + /** + * `$.Drop.compile()` gets all elements that are droppable and adds them to a list. + * + * This should be called if and when new drops are added to the page + * during the motion of a single drag. + * + * This is called by default when a drag motion starts. + * + * ## Use + * + * After adding an element or drop, call compile. + * + * $("#midpoint").bind("dropover",function(){ + * // when a drop hovers over midpoint, + * // make drop a drop. + * $("#drop").bind("dropover", function(){ + * + * }); + * $.Drop.compile(); + * }); + */ + compile: function( event, drag ) { + // if we called compile w/o a current drag + if(!this.dragging && !drag){ + return; + }else if(!this.dragging){ + this.dragging = drag; + this.last_active = []; + } + var el, + drops, + selector, + dropResponders, + newEls = [], + dragging = this.dragging; + + // go to each root element and look for drop elements + for(var i=0; i < this._rootElements.length; i++){ //for each element + el = this._rootElements[i] + + // gets something like {"": ["dropinit"], ".foo" : ["dropover","dropmove"] } + var drops = $.event.findBySelector(el, eventNames) + + // get drop elements by selector + for(selector in drops){ + dropResponders = selector ? jQuery(selector, el) : [el]; + + // for each drop element + for(var e= 0; e < dropResponders.length; e++){ + + // add the callbacks to the element's Data + // there already might be data, so we merge it + if( this.addCallbacks(dropResponders[e], drops[selector], dragging) ){ + newEls.push(dropResponders[e]) + }; + } + } + } + // once all callbacks are added, call init on everything ... + this.add(newEls, event, dragging) + }, + + // adds the drag callbacks object to the element or merges other callbacks ... + // returns true or false if the element is new ... + // onlyNew lets only new elements add themselves + addCallbacks : function(el, callbacks, onlyNew){ + var origData = $.data(el,"_dropData"); + if(!origData){ + $.data(el,"_dropData", new $.Drop(callbacks, el)); + return true; + }else if(!onlyNew){ + var origCbs = origData; + // merge data + for(var eventName in callbacks){ + origCbs[eventName] = origCbs[eventName] ? + origCbs[eventName].concat(callbacks[eventName]) : + callbacks[eventName]; + } + return false; + } + }, + // calls init on each element's drags. + // if its cancelled it's removed + // adds to the current elements ... + add: function( newEls, event, drag , dragging) { + var i = 0, + drop; + + while(i < newEls.length){ + drop = $.data(newEls[i],"_dropData"); + drop.callHandlers(this.lowerName+'init', newEls[i], event, drag) + if(drop._canceled){ + newEls.splice(i,1) + }else{ + i++; + } + } + this._elements.push.apply(this._elements, newEls) + }, + show: function( point, moveable, event ) { + var element = moveable.element; + if(!this._elements.length) return; + + var respondable, + affected = [], + propagate = true, + i = 0, + j, + la, + toBeActivated, + aff, + oldLastActive = this.last_active, + responders = [], + self = this, + drag; + + // what's still affected ... we can also move element out here + while( i < this._elements.length){ + drag = $.data(this._elements[i],"_dropData"); + + if (!drag) { + this._elements.splice(i, 1) + } + else { + i++; + if (self.isAffected(point, moveable, drag)) { + affected.push(drag); + } + } + } + + // we should only trigger on lowest children + affected.sort(this.sortByDeepestChild); + event.stopRespondPropagate = function(){ + propagate = false; + } + + toBeActivated = affected.slice(); + + // all these will be active + this.last_active = affected; + + // deactivate everything in last_active that isn't active + for (j = 0; j < oldLastActive.length; j++) { + la = oldLastActive[j]; + i = 0; + while((aff = toBeActivated[i])){ + if(la == aff){ + toBeActivated.splice(i,1);break; + }else{ + i++; + } + } + if(!aff){ + this.deactivate(la, moveable, event); + } + if(!propagate) return; + } + for(var i =0; i < toBeActivated.length; i++){ + this.activate(toBeActivated[i], moveable, event); + if(!propagate) return; + } + + // activate everything in affected that isn't in last_active + for (i = 0; i < affected.length; i++) { + this.move(affected[i], moveable, event); + + if(!propagate) return; + } + }, + end: function( event, moveable ) { + var la, + endName = this.lowerName+'end', + onEvent = $.Event(this.endName, event), + dropData; + + // call dropon + // go through the actives ... if you are over one, call dropped on it + for(var i = 0; i < this.last_active.length; i++){ + la = this.last_active[i] + if( this.isAffected(event.vector(), moveable, la) && la[this.endName]){ + la.callHandlers(this.endName, null, onEvent, moveable); + } + + if (onEvent.isPropagationStopped()) { + break; + } + } + // call dropend + for(var r =0; r< length; i++){ + this[method][i].call(el || this.element[0], ev, this, drag) + } + }, + /** + * `drop.cache(value)` sets the drop to cache positions of draggable elements. + * This should be called on `dropinit`. For example: + * + * $('#dropable').on('dropinit', function( el, ev, drop ) { + * drop.cache(); + * }); + * + * @param {Boolean} [value=true] Whether to cache drop elements or not. + */ + cache: function( value ) { + this._cache = value != null ? value : true; + }, + /** + * `drop.cancel()` prevents this drop from being dropped on. + * + * $('.droparea').on('dropover', function(ev, drop, drag) { + * if(drag.element.hasClass('not-me')) { + * drop.cancel(); + * } + * }); + */ + cancel: function() { + this._canceled = true; + } + }); + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/fastfix.js b/dist/event/fastfix.js new file mode 100644 index 00000000..467c723f --- /dev/null +++ b/dist/event/fastfix.js @@ -0,0 +1,113 @@ +(function ($) { + // http://bitovi.com/blog/2012/04/faster-jquery-event-fix.html + // https://gist.github.com/2377196 + + // IE 8 has Object.defineProperty but it only defines DOM Nodes. According to + // http://kangax.github.com/es5-compat-table/#define-property-ie-note + // All browser that have Object.defineProperties also support Object.defineProperty properly + if(Object.defineProperties) { + var + // Use defineProperty on an object to set the value and return it + set = function (obj, prop, val) { + if(val !== undefined) { + Object.defineProperty(obj, prop, { + value : val + }); + } + return val; + }, + // special converters + special = { + pageX : function (original) { + if(!original) { + return; + } + + var eventDoc = this.target.ownerDocument || document; + doc = eventDoc.documentElement; + body = eventDoc.body; + return original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); + }, + pageY : function (original) { + if(!original) { + return; + } + + var eventDoc = this.target.ownerDocument || document; + doc = eventDoc.documentElement; + body = eventDoc.body; + return original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); + }, + relatedTarget : function (original) { + if(!original) { + return; + } + + return original.fromElement === this.target ? original.toElement : original.fromElement; + }, + metaKey : function (originalEvent) { + if(!originalEvent) { + return; + } + return originalEvent.ctrlKey; + }, + which : function (original) { + if(!original) { + return; + } + + return original.charCode != null ? original.charCode : original.keyCode; + } + }; + + // Get all properties that should be mapped + $.each($.event.keyHooks.props.concat($.event.mouseHooks.props).concat($.event.props), function (i, prop) { + if (prop !== "target") { + (function () { + Object.defineProperty($.Event.prototype, prop, { + get : function () { + // get the original value, undefined when there is no original event + var originalValue = this.originalEvent && this.originalEvent[prop]; + // overwrite getter lookup + return this['_' + prop] !== undefined ? this['_' + prop] : set(this, prop, + // if we have a special function and no value + special[prop] && originalValue === undefined ? + // call the special function + special[prop].call(this, this.originalEvent) : + // use the original value + originalValue) + }, + set : function (newValue) { + // Set the property with underscore prefix + this['_' + prop] = newValue; + } + }); + })(); + } + }); + + $.event.fix = function (event) { + if (event[ $.expando ]) { + return event; + } + // Create a jQuery event with at minimum a target and type set + var originalEvent = event, + event = $.Event(originalEvent); + event.target = originalEvent.target; + // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) + if (!event.target) { + event.target = originalEvent.srcElement || document; + } + + // Target should not be a text node (#504, Safari) + if (event.target.nodeType === 3) { + event.target = event.target.parentNode; + } + + return event; + } + } + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/hover.js b/dist/event/hover.js new file mode 100644 index 00000000..3e2fecae --- /dev/null +++ b/dist/event/hover.js @@ -0,0 +1,291 @@ +(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; + var pending = $.data(delegate,"_hover"+selector); + // prevents another mouseenter until current has run its course + if(pending) { + // Under some circumstances, mouseleave may never fire + // (e.g., the element is removed while hovered) + // so if we've entered another element, wait the leave time, + // then force it to release. + if(!pending.forcing) { + pending.forcing = true; + clearTimeout(pending.leaveTimer); + var leaveTime = pending.leaving ? + Math.max(0,pending.hover.leave - (new Date() - pending.leaving)) : + pending.hover.leave; + var self = this; + + setTimeout(function() { + pending.callHoverLeave(); + onmouseenter.call(self,ev); + },leaveTime); + } + return; + } + 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) + pending.leaving = new Date(); + leaveTimer = pending.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) + }, + hoverenter = function() { + $.each(event.find(delegate, ["hoverenter"], selector), function () { + this.call(enteredEl, lastEv, hover) + }) + hovered = true; + }; + pending = { + callHoverLeave: callHoverLeave, + hover: hover + }; + $.data(delegate,"_hover"+selector, pending); + + // 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) + }) + + if (hover._delay === 0) { + hoverenter(); + } else { + timer = setTimeout(function () { + // check that we aren't moving around + if (dist < hover._distance && $(enteredEl).queue().length == 0) { + hoverenter(); + 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) + + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/key.js b/dist/event/key.js new file mode 100644 index 00000000..d0c4cf8c --- /dev/null +++ b/dist/event/key.js @@ -0,0 +1,174 @@ +(function($){ + + // copied from jQuery 1.8.3 + var uaMatch = function( ua ) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) || + /(webkit)[ \/]([\w.]+)/.exec( ua ) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) || + /(msie) ([\w.]+)/.exec( ua ) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + } + + var keymap = {}, + reverseKeyMap = {}, + currentBrowser = 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. + */ + $.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+""] + } + +return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/livehack.js b/dist/event/livehack.js new file mode 100644 index 00000000..f204cff7 --- /dev/null +++ b/dist/event/livehack.js @@ -0,0 +1,178 @@ +(function($) { + + var event = $.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 || "", + namespace = handleObj.namespace ? '.'+handleObj.namespace : ''; + + if ( selector ) { + bySelector = event.find(this, types, selector); + if (!bySelector.length ) { + $(this).delegate(selector, startingEvent + namespace, onFirst); + } + } + else { + //var bySelector = event.find(this, types, selector); + if (!event.find(this, types, selector).length ) { + event.add(this, startingEvent + namespace, 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() {} + }; + }); + }; + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/pause.js b/dist/event/pause.js new file mode 100644 index 00000000..0e54c30f --- /dev/null +++ b/dist/event/pause.js @@ -0,0 +1,89 @@ +(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 = $.event.special[ handleObj.origType ], + origHandle = origType && origType.handle; + + if(!origType){ + $.event.special[ handleObj.origType ] = {}; + } + $.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 $.event.special[ handleObj.origType ]; + } else { + $.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); + } + +}; + +return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/resize.js b/dist/event/resize.js new file mode 100644 index 00000000..7a3c4cc8 --- /dev/null +++ b/dist/event/resize.js @@ -0,0 +1,45 @@ +(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; + } + } + }); + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/reverse.js b/dist/event/reverse.js new file mode 100644 index 00000000..e2b51872 --- /dev/null +++ b/dist/event/reverse.js @@ -0,0 +1,92 @@ +(function($) { + $.event.reverse = function(name, attributes) { + var bound = $(), + count = 0, + dispatch = $.event.handle || $.event.dispatch; + + $.event.special[name] = { + setup: function() { + // add and sort the resizers array + // don't add window because it can't be compared easily + if ( this !== window ) { + bound.push(this); + $.unique(bound); + } + // returns false if the window + return this !== window; + }, + teardown: function() { + // we shouldn't have to sort + bound = bound.not(this); + // returns false if the window + return this !== window; + }, + add: function( handleObj ) { + var origHandler = handleObj.handler; + handleObj.origHandler = origHandler; + + handleObj.handler = function( ev, data ) { + var isWindow = this === window; + if(attributes && attributes.handler) { + var result = attributes.handler.apply(this, arguments); + if(result === true) { + return; + } + } + + // if this is the first handler for this event ... + if ( count === 0 ) { + // prevent others from doing what we are about to do + count++; + var where = data === false ? ev.target : this + + // trigger all this element's handlers + dispatch.call(where, ev, data); + if ( ev.isPropagationStopped() ) { + count--; + return; + } + + // get all other elements within this element that listen to move + // and trigger their resize events + var index = bound.index(this), + length = bound.length, + child, sub; + + // if index == -1 it's the window + while (++index < length && (child = bound[index]) && (isWindow || $.contains(where, child)) ) { + + // call the event + dispatch.call(child, ev, data); + + if ( ev.isPropagationStopped() ) { + // move index until the item is not in the current child + while (++index < length && (sub = bound[index]) ) { + if (!$.contains(child, sub) ) { + // set index back one + index--; + break + } + } + } + } + + // prevent others from responding + ev.stopImmediatePropagation(); + count--; + } else { + handleObj.origHandler.call(this, ev, data); + } + } + } + }; + + // automatically bind on these + $([document, window]).bind(name, function() {}); + + return $.event.special[name]; + } + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/event/swipe.js b/dist/event/swipe.js new file mode 100644 index 00000000..aa00ed0c --- /dev/null +++ b/dist/event/swipe.js @@ -0,0 +1,130 @@ +(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 : 320, + /** + * @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 && distance <= swipe.max ) { + 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; + }) +}); + +return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/lang/json.js b/dist/lang/json.js new file mode 100644 index 00000000..20680c1c --- /dev/null +++ b/dist/lang/json.js @@ -0,0 +1,198 @@ +(function($) { + /** + * @page jQuery.toJSON jQuery.toJSON + * @parent jquerymx.lang + * + * jQuery.toJSON( json-serializble ) + * + * Converts the given argument into a JSON respresentation. + * + * If an object has a "toJSON" function, that will + * be used to get the representation. + * Non-integer/string keys are skipped in the + * object, as are keys that point to a function. + * + * json-serializble: + * The *thing* to be converted. + */ + $.toJSON = function(o, replacer, space, recurse) + { + if (typeof(JSON) == 'object' && JSON.stringify) + return JSON.stringify(o, replacer, space); + + if (!recurse && $.isFunction(replacer)) + o = replacer("", o); + + if (typeof space == "number") + space = " ".substring(0, space); + space = (typeof space == "string") ? space.substring(0, 10) : ""; + + var type = typeof(o); + + if (o === null) + return "null"; + + if (type == "undefined" || type == "function") + return undefined; + + if (type == "number" || type == "boolean") + return o + ""; + + if (type == "string") + return $.quoteString(o); + + if (type == 'object') + { + if (typeof o.toJSON == "function") + return $.toJSON( o.toJSON(), replacer, space, true ); + + if (o.constructor === Date) + { + var month = o.getUTCMonth() + 1; + if (month < 10) month = '0' + month; + + var day = o.getUTCDate(); + if (day < 10) day = '0' + day; + + var year = o.getUTCFullYear(); + + var hours = o.getUTCHours(); + if (hours < 10) hours = '0' + hours; + + var minutes = o.getUTCMinutes(); + if (minutes < 10) minutes = '0' + minutes; + + var seconds = o.getUTCSeconds(); + if (seconds < 10) seconds = '0' + seconds; + + var milli = o.getUTCMilliseconds(); + if (milli < 100) milli = '0' + milli; + if (milli < 10) milli = '0' + milli; + + return '"' + year + '-' + month + '-' + day + 'T' + + hours + ':' + minutes + ':' + seconds + + '.' + milli + 'Z"'; + } + + var process = ($.isFunction(replacer)) ? + function (k, v) { return replacer(k, v); } : + function (k, v) { return v; }, + nl = (space) ? "\n" : "", + sp = (space) ? " " : ""; + + if (o.constructor === Array) + { + var ret = []; + for (var i = 0; i < o.length; i++) + ret.push(( $.toJSON( process(i, o[i]), replacer, space, true ) || "null" ).replace(/^/gm, space)); + + return "[" + nl + ret.join("," + nl) + nl + "]"; + } + + var pairs = [], proplist; + if ($.isArray(replacer)) { + proplist = $.map(replacer, function (v) { + return (typeof v == "string" || typeof v == "number") ? + v + "" : + null; + }); + } + for (var k in o) { + var name, val, type = typeof k; + + if (proplist && $.inArray(k + "", proplist) == -1) + continue; + + if (type == "number") + name = '"' + k + '"'; + else if (type == "string") + name = $.quoteString(k); + else + continue; //skip non-string or number keys + + val = $.toJSON( process(k, o[k]), replacer, space, true ); + + if (typeof val == "undefined") + continue; //skip pairs where the value is a function. + + pairs.push((name + ":" + sp + val).replace(/^/gm, space)); + } + + return "{" + nl + pairs.join("," + nl) + nl + "}"; + } + }; + + /** + * @function jQuery.evalJSON + * Evaluates a given piece of json source. + **/ + $.evalJSON = function(src) + { + if (typeof(JSON) == 'object' && JSON.parse) + return JSON.parse(src); + return eval("(" + src + ")"); + }; + + /** + * @function jQuery.secureEvalJSON + * Evals JSON in a way that is *more* secure. + **/ + $.secureEvalJSON = function(src) + { + if (typeof(JSON) == 'object' && JSON.parse) + return JSON.parse(src); + + var filtered = src; + filtered = filtered.replace(/\\["\\\/bfnrtu]/g, '@'); + filtered = filtered.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']'); + filtered = filtered.replace(/(?:^|:|,)(?:\s*\[)+/g, ''); + + if (/^[\],:{}\s]*$/.test(filtered)) + return eval("(" + src + ")"); + else + throw new SyntaxError("Error parsing JSON, source is not valid."); + }; + + /** + * @function jQuery.quoteString + * + * Returns a string-repr of a string, escaping quotes intelligently. + * Mostly a support function for toJSON. + * + * Examples: + * + * jQuery.quoteString("apple") //-> "apple" + * + * jQuery.quoteString('"Where are we going?", she asked.') + * // -> "\"Where are we going?\", she asked." + **/ + $.quoteString = function(string) + { + if (string.match(_escapeable)) + { + return '"' + string.replace(_escapeable, function (a) + { + var c = _meta[a]; + if (typeof c === 'string') return c; + c = a.charCodeAt(); + return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16); + }) + '"'; + } + return '"' + string + '"'; + }; + + var _escapeable = /["\\\x00-\x1f\x7f-\x9f]/g; + + var _meta = { + '\b': '\\b', + '\t': '\\t', + '\n': '\\n', + '\f': '\\f', + '\r': '\\r', + '"' : '\\"', + '\\': '\\\\' + }; + + return $; +} +)(jQuery); \ No newline at end of file diff --git a/dist/lang/vector.js b/dist/lang/vector.js new file mode 100644 index 00000000..75787923 --- /dev/null +++ b/dist/lang/vector.js @@ -0,0 +1,216 @@ +(function($){ + var getSetZero = function(v){ return v !== undefined ? (this.array[0] = v) : this.array[0] }, + getSetOne = function(v){ return v !== undefined ? (this.array[1] = v) : this.array[1]}; + +/** + * @class jQuery.Vector + * @parent jquerypp + * + * `jQuery.Vector` represents a multi dimensional vector with shorthand methods for + * working with two dimensions. + * + * It is mainly used in [jQuery.event.drag drag] & [jQuery.event.drop drop] events. + * + * @constructor creates a new vector instance from the arguments. Example: + * + * new jQuery.Vector(1,2) + */ + $.Vector = function(arr) { + var array = $.isArray(arr) ? arr : $.makeArray(arguments); + this.update(array); + }; + $.Vector.prototype = + /* @Prototype*/ + { + /** + * Applys the function to every item in the vector and returns a new vector. + * + * @param {Function} f The function to apply + * @return {jQuery.Vector} A new $.Vector instance + */ + app: function( f ) { + var i, newArr = []; + + for ( i = 0; i < this.array.length; i++ ) { + newArr.push(f(this.array[i], i)); + } + return new $.Vector(newArr); + }, + /** + * Adds two vectors together and returns a new instance. Example: + * + * new $.Vector(1,2).plus(2,3) //-> (3, 5) + * new $.Vector(3,5).plus(new Vector(4,5)) //-> (7, 10) + * + * @return {$.Vector} + */ + plus: function() { + var i, args = arguments[0] instanceof $.Vector ? arguments[0].array : $.makeArray(arguments), + arr = this.array.slice(0), + vec = new $.Vector(); + for ( i = 0; i < args.length; i++ ) { + arr[i] = (arr[i] ? arr[i] : 0) + args[i]; + } + return vec.update(arr); + }, + /** + * Subtract one vector from another and returns a new instance. Example: + * + * new $.Vector(4, 5).minus(2, 1) //-> (2, 4) + * + * @return {jQuery.Vector} + */ + minus: function() { + var i, args = arguments[0] instanceof $.Vector ? arguments[0].array : $.makeArray(arguments), + arr = this.array.slice(0), + vec = new $.Vector(); + for ( i = 0; i < args.length; i++ ) { + arr[i] = (arr[i] ? arr[i] : 0) - args[i]; + } + return vec.update(arr); + }, + /** + * Returns the current vector if it is equal to the vector passed in. + * + * `null` if otherwise. + * + * @return {jQuery.Vector} + */ + equals: function() { + var i, args = arguments[0] instanceof $.Vector ? arguments[0].array : $.makeArray(arguments), + arr = this.array.slice(0), + vec = new $.Vector(); + for ( i = 0; i < args.length; i++ ) { + if ( arr[i] != args[i] ) { + return null; + } + } + return vec.update(arr); + }, + /** + * Returns the first value of the vector. + * You can also access the same value through the following aliases the + * [jQuery.Vector.prototype.left vector.left()] and [jQuery.Vector.prototype.left vector.width()] + * aliases. + * + * For example: + * + * var v = new $.Vector(2, 5); + * v.x() //-> 2 + * v.left() //-> 2 + * v.width() //-> 2 + * + * @return {Number} The first value of the vector + */ + x: getSetZero, + /** + * @hide + * Alias for [jQuery.Vector.prototype.x]. + * + * @return {Number} + */ + left: getSetZero, + /** + * @hide + * Alias for [jQuery.Vector.prototype.x]. + * + * @return {Number} + */ + width: getSetZero, + /** + * Returns the second value of the vector. + * You can also access the same value through the [jQuery.Vector.prototype.top vector.top()] + * and [jQuery.Vector.prototype.height vector.height()] aliases. + * + * For example: + * + * var v = new $.Vector(2, 5); + * v.y() //-> 5 + * v.top() //-> 5 + * v.height() //-> 5 + * + * @return {Number} The first value of the vector + */ + y: getSetOne, + /** + * @hide + * Alias for [jQuery.Vector.prototype.y]. + * + * @return {Number} + */ + top: getSetOne, + /** + * @hide + * Alias for [jQuery.Vector.prototype.y]. + * + * @return {Number} + */ + height: getSetOne, + /** + * Returns a string representation of the vector in the form of (x,y,...) + * + * var v = new $.Vector(4, 6, 1, 3); + * v.toString() //-> (4, 6, 1, 3) + * + * @return {String} + */ + toString: function() { + return "(" + this.array.join(', ') + ")"; + }, + /** + * Replaces the vectors contents + * + * var v = new $.Vector(2, 3); + * + * @param {Object} array + */ + update: function( array ) { + var i; + if ( this.array ) { + for ( i = 0; i < this.array.length; i++ ) { + delete this.array[i]; + } + } + this.array = array; + for ( i = 0; i < array.length; i++ ) { + this[i] = this.array[i]; + } + return this; + } + }; + + $.Event.prototype.vector = function() { + // Get the first touch element for touch events + var touches = "ontouchend" in document && this.originalEvent.touches && this.originalEvent.touches.length + ? this.originalEvent.changedTouches[0] : this; + if ( this.originalEvent.synthetic ) { + var doc = document.documentElement, + body = document.body; + return new $.Vector(touches.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0), + touches.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0)); + } else { + return new $.Vector(touches.pageX, touches.pageY); + } + }; + + $.fn.offsetv = function() { + if ( this[0] == window ) { + return new $.Vector(window.pageXOffset ? window.pageXOffset : document.documentElement.scrollLeft, window.pageYOffset ? window.pageYOffset : document.documentElement.scrollTop); + } else { + var offset = this.offset() || {}; + return new $.Vector(offset.left, offset.top); + } + }; + + $.fn.dimensionsv = function( which ) { + if ( this[0] == window || !which ) { + return new $.Vector(this.width(), this.height()); + } + else { + return new $.Vector(this[which + "Width"](), this[which + "Height"]()); + } + }; + + return $; +} +)(jQuery); \ No newline at end of file From fd3fe783ff56800ca293e33c510e1e6092dba3b3 Mon Sep 17 00:00:00 2001 From: Adam Miskiewicz Date: Fri, 14 Jun 2013 15:43:08 -0400 Subject: [PATCH 7/9] adding bower.json --- bower.json | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 bower.json diff --git a/bower.json b/bower.json new file mode 100644 index 00000000..391a6cff --- /dev/null +++ b/bower.json @@ -0,0 +1,7 @@ +{ + "name" : "jquerypp", + "version": "1.0.1", + "main": [ + "./dist/jquerypp.js" + ] +} \ No newline at end of file From 72bb8489059ae89997d6a0dfeee423fd16abe4a8 Mon Sep 17 00:00:00 2001 From: Nick Hudkins Date: Wed, 16 Oct 2013 16:48:21 -0400 Subject: [PATCH 8/9] form params should use prop if it is to be friendly and good --- dist/dom/form_params.js | 4 ++-- dist/jquerypp.js | 4 ++-- dom/form_params/form_params.js | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/dist/dom/form_params.js b/dist/dom/form_params.js index f6834f16..bf306306 100644 --- a/dist/dom/form_params.js +++ b/dist/dom/form_params.js @@ -113,14 +113,14 @@ // Nested these if statements for performance if ( $this.is(":radio") ) { if ( $this.val() == value ) { - $this.attr("checked", true); + $this.prop("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); + $this.prop("checked", true); } } else { $this.val( value ); diff --git a/dist/jquerypp.js b/dist/jquerypp.js index 059c574c..00b01d08 100644 --- a/dist/jquerypp.js +++ b/dist/jquerypp.js @@ -835,14 +835,14 @@ // Nested these if statements for performance if ($this.is(":radio")) { if ($this.val() == value) { - $this.attr("checked", true); + $this.prop("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); + $this.prop("checked", true); } } else { $this.val(value); diff --git a/dom/form_params/form_params.js b/dom/form_params/form_params.js index dea3b397..666d90a5 100644 --- a/dom/form_params/form_params.js +++ b/dom/form_params/form_params.js @@ -107,14 +107,14 @@ steal("jquery", function( $ ) { // Nested these if statements for performance if ( $this.is(":radio") ) { if ( $this.val() == value ) { - $this.attr("checked", true); + $this.prop("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); + $this.prop("checked", true); } } else { $this.val( value ); From 6fc2b472e77e6eba742138e7811030c780c6500a Mon Sep 17 00:00:00 2001 From: Nick Hudkins Date: Thu, 17 Oct 2013 00:46:52 -0400 Subject: [PATCH 9/9] it changed, so trigger a change event --- dist/dom/form_params.js | 4 ++-- dist/jquerypp.js | 4 ++-- dom/form_params/form_params.js | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/dist/dom/form_params.js b/dist/dom/form_params.js index bf306306..0006c258 100644 --- a/dist/dom/form_params.js +++ b/dist/dom/form_params.js @@ -113,14 +113,14 @@ // Nested these if statements for performance if ( $this.is(":radio") ) { if ( $this.val() == value ) { - $this.prop("checked", true); + $this.prop("checked", true).trigger('change'); } } 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.prop("checked", true); + $this.prop("checked", true).trigger('change'); } } else { $this.val( value ); diff --git a/dist/jquerypp.js b/dist/jquerypp.js index 00b01d08..56ec5b0e 100644 --- a/dist/jquerypp.js +++ b/dist/jquerypp.js @@ -835,14 +835,14 @@ // Nested these if statements for performance if ($this.is(":radio")) { if ($this.val() == value) { - $this.prop("checked", true); + $this.prop("checked", true).trigger('change'); } } 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.prop("checked", true); + $this.prop("checked", true).trigger('change'); } } else { $this.val(value); diff --git a/dom/form_params/form_params.js b/dom/form_params/form_params.js index 666d90a5..a85e1e45 100644 --- a/dom/form_params/form_params.js +++ b/dom/form_params/form_params.js @@ -107,14 +107,14 @@ steal("jquery", function( $ ) { // Nested these if statements for performance if ( $this.is(":radio") ) { if ( $this.val() == value ) { - $this.prop("checked", true); + $this.prop("checked", true).trigger('change'); } } 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.prop("checked", true); + $this.prop("checked", true).trigger('change'); } } else { $this.val( value );