├── jquery ├── qunit.js └── qunit.css ├── event.drag ├── jquery.event.drag.js ├── test │ ├── requirements.js │ ├── index.html │ ├── live.js │ ├── properties.js │ ├── binding.js │ ├── method.js │ ├── handlers.js │ ├── interaction.js │ └── touch.js └── jquery.event.drag.live.js ├── event.linger ├── jquery.event.linger.js └── test │ ├── requirements.js │ ├── index.html │ ├── method.js │ ├── binding.js │ ├── handlers.js │ └── interaction.js ├── event.keyend └── jquery.event.keyend.js ├── fire ├── test │ ├── requirements.js │ ├── index.html │ ├── form.js │ ├── object.js │ ├── mutation.js │ ├── key.js │ ├── mouse.js │ ├── custom.js │ └── touch.js └── jquery.fire.js ├── event.drop ├── test │ ├── binding.js │ ├── index.html │ ├── requirements.js │ ├── live.js │ ├── method.js │ ├── properties.js │ ├── handlers.js │ ├── interaction.js │ ├── touch.js │ └── tolerance.js ├── jquery.event.drop.live.js └── jquery.event.drop.js └── event.wheel └── jquery.event.wheel.js /jquery/qunit.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/threedubmedia/jquery.threedubmedia/HEAD/jquery/qunit.js -------------------------------------------------------------------------------- /event.drag/jquery.event.drag.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/threedubmedia/jquery.threedubmedia/HEAD/event.drag/jquery.event.drag.js -------------------------------------------------------------------------------- /event.linger/jquery.event.linger.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/threedubmedia/jquery.threedubmedia/HEAD/event.linger/jquery.event.linger.js -------------------------------------------------------------------------------- /event.keyend/jquery.event.keyend.js: -------------------------------------------------------------------------------- 1 | ;(function( $ ){ 2 | $.fn.keyend = function( fn ){ 3 | return this[ fn ? "bind" : "trigger" ]( "keyend", fn ); 4 | }; 5 | var keyend = $.event.special.keyend = { 6 | delay: 400, 7 | setup: function( data ){ 8 | $( this ).bind("keypress",{ delay: data.delay }, keyend.handler ); 9 | }, 10 | teardown: function(){ 11 | $( this ).unbind("keypress", keyend.handler ); 12 | }, 13 | handler: function( event ){ 14 | clearTimeout( event.data.timer ); 15 | event.data.timer = setTimeout(function(){ 16 | $( event.currentTarget ).keyend(); 17 | }, event.data.delay || keyend.delay ); 18 | } 19 | }; 20 | })( jQuery ); -------------------------------------------------------------------------------- /event.linger/test/requirements.js: -------------------------------------------------------------------------------- 1 | module("Requirements"); 2 | 3 | test("jQuery",function(){ 4 | 5 | expect( 2 ); 6 | 7 | // make sure the right jquery is included 8 | ok( window.jQuery, "jQuery exists" ); 9 | ok( parseFloat( jQuery([]).jquery ) >= 1.4, "jQuery version is 1.4 or greater" ); 10 | 11 | }); 12 | 13 | test("Installation",function(){ 14 | 15 | expect( 4 ); 16 | 17 | // make sure the event interface is complete 18 | ok( jQuery.event.special.lingerstart, "LINGERSTART special event is defined" ); 19 | ok( jQuery.event.special.linger, "LINGER special event is defined" ); 20 | ok( jQuery.event.special.lingerend, "LINGEREND special event is defined" ); 21 | ok( jQuery([]).linger, "$('...').linger() method is defined" ); 22 | 23 | }); -------------------------------------------------------------------------------- /event.drag/test/requirements.js: -------------------------------------------------------------------------------- 1 | module("Requirements"); 2 | 3 | test("jQuery",function(){ 4 | 5 | expect( 2 ); 6 | 7 | // make sure the right jquery is included 8 | ok( window.jQuery, "jQuery exists" ); 9 | ok( parseFloat( jQuery([]).jquery ) >= 1.4, "jQuery version is 1.4 or greater" ); 10 | 11 | }); 12 | 13 | test("Installation",function(){ 14 | 15 | expect( 5 ); 16 | 17 | // make sure the event interface is complete 18 | ok( jQuery.event.special.draginit, '"draginit" special event is defined' ); 19 | ok( jQuery.event.special.dragstart, '"dragstart" special event is defined' ); 20 | ok( jQuery.event.special.drag, '"drag" special event is defined' ); 21 | ok( jQuery.event.special.dragend, '"dragend" special event is defined' ); 22 | ok( jQuery([]).drag, "$.fn.drag method is defined" ); 23 | 24 | }); -------------------------------------------------------------------------------- /fire/test/requirements.js: -------------------------------------------------------------------------------- 1 | module("Requirements"); 2 | 3 | test("jQuery",function(){ 4 | 5 | expect( 2 ); 6 | 7 | // make sure the right jquery is included 8 | ok( window.jQuery, "jQuery exists" ); 9 | ok( parseFloat( jQuery([]).jquery ) >= 1.4, "jQuery version is 1.4 or greater" ); 10 | 11 | }); 12 | 13 | test("Installation",function(){ 14 | 15 | expect( 8 ); 16 | 17 | // make sure the plugin interface is complete 18 | ok( jQuery.fn.fire, "FIRE method is defined" ); 19 | ok( jQuery.fire, "CONSTRUCTOR is defined" ); 20 | ok( jQuery.fire.defaults, "DEFAULTS are defined" ); 21 | ok( jQuery.fire.prototype.create, "CREATE method is defined" ); 22 | ok( jQuery.fire.prototype.event, "EVENT method is defined" ); 23 | ok( jQuery.fire.prototype.mouse, "MOUSE method is defined" ); 24 | ok( jQuery.fire.prototype.key, "KEY method is defined" ); 25 | ok( jQuery.fire.prototype.dispatch, "DISPATCH method is defined" ); 26 | }); -------------------------------------------------------------------------------- /event.linger/test/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | ThreeDubMedia · jQuery.event.linger.js 17 | 18 | 19 |

jQuery.event.linger.js Unit Tests

20 |

21 |

22 |
    23 | 24 | -------------------------------------------------------------------------------- /fire/test/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | ThreeDubMedia · jQuery.fire.js 19 | 20 | 21 |

    jQuery.fire.js Unit Tests

    22 |

    23 |

    24 |
      25 | 26 | -------------------------------------------------------------------------------- /event.drop/test/binding.js: -------------------------------------------------------------------------------- 1 | module("Event Binding"); 2 | 3 | $.each(['dropinit','dropstart','drop','dropend'],function( i, type ){ 4 | 5 | test('"'+ type +'"',function(){ 6 | 7 | expect( 9 ); 8 | 9 | // make sure the event handler gets bound to the element 10 | var $elem = $('
      '), 11 | elem = $elem[0], 12 | count = 0, 13 | fn = function(){ 14 | count += 1; 15 | }; 16 | 17 | ok( $elem.bind( type, fn )[0] == elem, '.bind("'+ type +'", fn )' ); 18 | ok( $.data( elem, $.event.special.drop.datakey ), "drop data exists" ); 19 | ok( $.data( elem, "events" ), "event data exists" ); 20 | ok( $.data( elem, "events" )[ type ][0], '"'+ type +'" event handler added' ); 21 | 22 | ok( $elem.trigger( type )[0] == elem, '.trigger("'+ type +'")' ); 23 | ok( count == 1, "handler was triggered"); 24 | 25 | ok( $elem.unbind( type )[0] == elem, '.unbind("'+ type +'")' ); 26 | ok( !$.data( elem, "events" ), "event data removed" ); 27 | ok( !$.data( elem, $.event.special.drop.datakey ), "drop data removed" ); 28 | 29 | $elem.remove(); 30 | 31 | }); 32 | }); -------------------------------------------------------------------------------- /event.drag/test/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | ThreeDubMedia · jQuery.event.drag.js 21 | 22 | 23 |

      jQuery.event.drag.js Unit Tests

      24 |

      25 |

      26 |
        27 | 28 | -------------------------------------------------------------------------------- /event.drag/test/live.js: -------------------------------------------------------------------------------- 1 | module("Live Delegation"); 2 | 3 | $.each(["draginit","dragstart","drag","dragend"],function( i, type ){ 4 | 5 | test('"'+ type+'"',function(){ 6 | 7 | expect( i ? 5 : 1 ); 8 | 9 | if ( !i ){ 10 | ok( true, 'Not supported for this event type.'); 11 | return; 12 | } 13 | 14 | // set up the delegation 15 | $('.drag').live( type, function( event ){ 16 | count += 1; 17 | equals( this, $drag[0], event.type+" target" ); 18 | }); 19 | // local refs 20 | var count = 0, 21 | // add a div to test the delegation 22 | $drag = $('
        ').appendTo( document.body ); 23 | 24 | // manual triggering 25 | ok( $drag.trigger( type ), '.trigger("'+ type +'")'); 26 | equals( count, 1, "event was triggered"); 27 | 28 | // simulate a complete drag 29 | $drag 30 | .fire("mousedown",{ pageX:50, pageY:50 }) 31 | .fire("mousemove",{ pageX:51, pageY:51 }) 32 | .fire("mouseup",{ pageX:51, pageY:51 }) 33 | .fire("click",{ pageX:51, pageY:51 }); 34 | 35 | equals( count, 2, "event was delegated"); 36 | 37 | // remove delegation 38 | $('.drag').die( type ); 39 | $drag.remove(); 40 | }); 41 | }); -------------------------------------------------------------------------------- /event.drop/test/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | ThreeDubMedia · jQuery.event.drop.js 25 | 26 | 27 |

        jQuery.event.drop.js Unit Tests

        28 |

        29 |

        30 |
          31 | 32 | -------------------------------------------------------------------------------- /event.drop/test/requirements.js: -------------------------------------------------------------------------------- 1 | module("Requirements"); 2 | 3 | test("jQuery",function(){ 4 | 5 | expect( 2 ); 6 | 7 | // make sure the right jquery is included 8 | ok( window.jQuery, "jQuery exists" ); 9 | ok( parseFloat( jQuery([]).jquery ) >= 1.4, "jQuery version is 1.4 or greater" ); 10 | }); 11 | 12 | test("$.event.special.drag",function(){ 13 | 14 | expect( 5 ); 15 | 16 | // make sure the event interface is complete 17 | ok( jQuery.event.special.draginit, '"draginit" special event is defined' ); 18 | ok( jQuery.event.special.dragstart, '"dragstart" special event is defined' ); 19 | ok( jQuery.event.special.drag, '"drag" special event is defined' ); 20 | ok( jQuery.event.special.dragend, '"dragend" special event is defined' ); 21 | ok( jQuery([]).drag, "$.fn.drag method is defined" ); 22 | 23 | }); 24 | 25 | test("Installation",function(){ 26 | 27 | expect( 6 ); 28 | 29 | // make sure the event interface is complete 30 | ok( jQuery.event.special.dropinit, '"dropinit" special event is defined' ); 31 | ok( jQuery.event.special.dropstart, '"dropstart" special event is defined' ); 32 | ok( jQuery.event.special.drop, '"drop" special event is defined' ); 33 | ok( jQuery.event.special.dropend, '"dropend" special event is defined' ); 34 | ok( jQuery([]).drop, '$.fn.drop method is defined' ); 35 | ok( jQuery.drop, '$.drop method is defined' ); 36 | 37 | }); -------------------------------------------------------------------------------- /event.linger/test/method.js: -------------------------------------------------------------------------------- 1 | module("Linger Method"); 2 | 3 | $.each(['start','','end'],function( i, type ){ 4 | 5 | test('"linger'+ type +'"',function(){ 6 | 7 | expect( 11 ); 8 | 9 | // make sure the event handler gets bound to the element 10 | var $elem = $('
          '), 11 | elem = $elem[0], 12 | count = 0, 13 | fn = function(){ 14 | count += 1; 15 | }, 16 | opts = { 17 | speed: 111, 18 | delay: 222, 19 | persist: 333 20 | }, 21 | data; 22 | 23 | ok( $elem.linger( type, fn )[0] == elem, ".linger("+( type ? "'"+ type +"'," : "" )+" fn )" ); 24 | ok( $.data( elem, $.event.special.linger.datakey ), "linger data exists" ); 25 | ok( $.data( elem, "events" ), "event data exists" ); 26 | ok( $.data( elem, "events" )[ 'linger'+type ][0], 'linger'+ type +" event handler added" ); 27 | 28 | ok( $elem.linger( type )[0] == elem, ".linger("+( type ? "'"+ type +"'" : "" )+")" ); 29 | ok( count == 1, "handler was triggered"); 30 | 31 | $elem.unbind( type ); 32 | 33 | ok( $elem.linger( type, fn, opts )[0] == elem, ".linger("+( type ? "'"+ type +"'," : "" )+" fn, opts )" ); 34 | ok( data = $.data( elem, $.event.special.linger.datakey ), "linger data exists" ); 35 | 36 | ok( data.speed == opts.speed, "'speed' option stored" ); 37 | ok( data.delay == opts.delay, "'delay' option stored" ); 38 | ok( data.persist == opts.persist, "'persist' option stored" ); 39 | 40 | $elem.remove(); 41 | 42 | }); 43 | }); -------------------------------------------------------------------------------- /event.linger/test/binding.js: -------------------------------------------------------------------------------- 1 | module("Bind Method"); 2 | 3 | $.each(['lingerstart','linger','lingerend'],function( i, type ){ 4 | 5 | test('"'+ type +'"', function(){ 6 | 7 | expect( 14 ); 8 | 9 | // make sure the event handler gets bound to the element 10 | var $elem = $('
          '), 11 | elem = $elem[0], 12 | count = 0, 13 | fn = function(){ 14 | count += 1; 15 | }, 16 | opts = { 17 | speed: 111, 18 | delay: 222, 19 | persist: 333 20 | }, 21 | data; 22 | 23 | ok( $elem.bind( type, fn )[0] == elem, ".bind('"+ type +"', fn )" ); 24 | ok( $.data( elem, $.event.special.linger.datakey ), "linger data exists" ); 25 | ok( $.data( elem, "events" ), "event data exists" ); 26 | ok( $.data( elem, "events" )[ type ][0], type +" event handler added" ); 27 | 28 | ok( $elem.trigger( type )[0] == elem, ".trigger('"+ type +"')" ); 29 | ok( count == 1, "handler was triggered"); 30 | 31 | ok( $elem.unbind( type )[0] == elem, ".unbind('"+ type +"')" ); 32 | ok( !$.data( elem, "events" ), "event data removed" ); 33 | ok( !$.data( elem, $.event.special.linger.datakey ), "linger data removed" ); 34 | 35 | ok( $elem.bind( type, opts, fn )[0] == elem, ".bind('"+ type +"', data, fn )" ); 36 | ok( data = $.data( elem, $.event.special.linger.datakey ), "linger data exists" ); 37 | 38 | ok( data.speed == opts.speed, "'speed' option stored" ); 39 | ok( data.delay == opts.delay, "'delay' option stored" ); 40 | ok( data.persist == opts.persist, "'persist' option stored" ); 41 | 42 | $elem.remove(); 43 | 44 | }); 45 | }); -------------------------------------------------------------------------------- /event.drop/test/live.js: -------------------------------------------------------------------------------- 1 | module("Live Delegation"); 2 | 3 | $.each(["dropinit","dropstart","drop","dropend"],function( i, type ){ 4 | 5 | test('"'+ type+'"',function(){ 6 | 7 | expect( i ? 5 : 1 ); 8 | 9 | if ( !i ){ 10 | ok( true, 'Not supported for this event type.'); 11 | return; 12 | } 13 | 14 | // set up the delegation 15 | $('.drop').live( type, function( event ){ 16 | count += 1; 17 | equals( this, $drop[0], event.type+" target" ); 18 | }); 19 | // local refs 20 | var count = 0, 21 | // add a div to test the delegation 22 | $drop = $('
          ') 23 | .css({ 24 | position: 'absolute', 25 | top: 0, left: 0, 26 | height: 100, width: 100 27 | }) 28 | .appendTo( document.body ), 29 | // add a dragger 30 | $drag = $('
          ') 31 | .css({ 32 | position: 'absolute', 33 | top: 0, left: 0, 34 | height: 100, width: 100 35 | }) 36 | .appendTo( document.body ) 37 | .drag(function(){ }); 38 | 39 | // check triggering of the event handlers 40 | ok( $drop.trigger( type ), '.trigger("'+ type +'")'); 41 | equals( count, 1, "event was triggered"); 42 | 43 | // simulate a complete drag 44 | $drag 45 | .fire("mousedown",{ pageX:50, pageY:50 }) 46 | .fire("mousemove",{ pageX:51, pageY:51 }) 47 | .fire("mouseup",{ pageX:51, pageY:51 }) 48 | .fire("click",{ pageX:51, pageY:51 }); 49 | 50 | // check the event handler counts 51 | equals( count, 2, "event was delegated"); 52 | 53 | // remove delegation 54 | $('.drop').die( type ); 55 | $drag.remove(); 56 | $drop.remove(); 57 | 58 | }); 59 | 60 | }); -------------------------------------------------------------------------------- /fire/test/form.js: -------------------------------------------------------------------------------- 1 | module("Form Events"); 2 | 3 | // test each of the following events 4 | $.each([ 5 | "focus","blur","change", 6 | "submit","select","reset" 7 | ],function( i, type ){ 8 | // test each event type 9 | test( '"'+ type +'"', function(){ 10 | expect( 0 ); 11 | 12 | // custom event properties 13 | var props = { 14 | //keyCode: Math.round( Math.random() * 256 ), 15 | //charCode: Math.round( Math.random() * 256 ), 16 | ctrlKey: Math.round( Math.random() ) ? true : false, 17 | altKey: Math.round( Math.random() ) ? true : false, 18 | shiftKey: Math.round( Math.random() ) ? true : false 19 | }, 20 | // new test element 21 | $div = $('
          ').appendTo( document.body ); 22 | // test the document too for bubbling 23 | $div.add( document ).bind( type, function( ev ){ 24 | 25 | equals( ev.currentTarget, this, "event.currentTarget"); 26 | equals( ev.target, $div[0], "event.target" ); 27 | equals( ev.type, type, "event.type" ); 28 | 29 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 30 | equals( ev.altKey, props.altKey, "event.altKey" ); 31 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 32 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 33 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 34 | }); 35 | 36 | // make sure that metaKey and ctrlKey are equal 37 | props.metaKey = props.ctrlKey; 38 | // fire the event with bubbling 39 | props.bubbles = true; 40 | $div.fire( type, props ); 41 | 42 | // fire the event without bubbling 43 | props.bubbles = false; 44 | $div.fire( type, props ); 45 | 46 | // cleanup 47 | $( document ).unbind( type ); 48 | $div.remove(); 49 | }); 50 | }); -------------------------------------------------------------------------------- /fire/test/object.js: -------------------------------------------------------------------------------- 1 | module("Object/Frame Events"); 2 | 3 | // test each of the following events 4 | $.each([ 5 | "abort","scroll","resize", 6 | "error","load","unload" 7 | ],function( i, type ){ 8 | // test each event type 9 | test( '"'+ type +'"', function(){ 10 | expect( 0 ); 11 | 12 | // custom event properties 13 | var props = { 14 | //keyCode: Math.round( Math.random() * 256 ), 15 | //charCode: Math.round( Math.random() * 256 ), 16 | ctrlKey: Math.round( Math.random() ) ? true : false, 17 | altKey: Math.round( Math.random() ) ? true : false, 18 | shiftKey: Math.round( Math.random() ) ? true : false 19 | }, 20 | // new test element 21 | $div = $('
          ').appendTo( document.body ); 22 | // test the document too for bubbling 23 | $div.add( document ).bind( type, function( ev ){ 24 | 25 | equals( ev.currentTarget, this, "event.currentTarget"); 26 | equals( ev.target, $div[0], "event.target" ); 27 | equals( ev.type, type, "event.type" ); 28 | 29 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 30 | equals( ev.altKey, props.altKey, "event.altKey" ); 31 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 32 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 33 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 34 | }); 35 | 36 | // make sure that metaKey and ctrlKey are equal 37 | props.metaKey = props.ctrlKey; 38 | // fire the event with bubbling 39 | props.bubbles = true; 40 | $div.fire( type, props ); 41 | 42 | // fire the event without bubbling 43 | props.bubbles = false; 44 | $div.fire( type, props ); 45 | 46 | // cleanup 47 | $( document ).unbind( type ); 48 | $div.remove(); 49 | }); 50 | }); -------------------------------------------------------------------------------- /event.wheel/jquery.event.wheel.js: -------------------------------------------------------------------------------- 1 | /*! 2 | * jquery.event.wheel - v 1.0.0 - http://jquery-ux.com/ 3 | * Copyright (c) 2010 Michael Helgeson, Three Dub Media 4 | * Open Source MIT License - http://jquery-ux.com/license 5 | */ 6 | // Created: 2008-07-01 7 | // Updated: 2010-01-08 8 | // REQUIRES: jquery 1.3+ 9 | 10 | ;(function( $ ){ // secure $ jQuery alias 11 | 12 | // jquery method 13 | $.fn.wheel = function( fn ){ 14 | return this[ fn ? "bind" : "trigger" ]( "wheel", fn ); 15 | }; 16 | 17 | // special event config 18 | var wheel = $.event.special.wheel = { 19 | events: "DOMMouseScroll mousewheel" // IE, opera, safari, firefox 20 | +( $.browser.mozilla && $.browser.version < "1.9" ? " mousemove" : "" ), // firefox 2 21 | setup: function(){ 22 | $.event.add( this, wheel.events, wheel.handler, {} ); 23 | }, 24 | teardown: function(){ 25 | $.event.remove( this, wheel.events, wheel.handler ); 26 | }, 27 | handler: function( event ){ 28 | switch ( event.type ){ 29 | case "mousewheel": // IE, opera, safari 30 | event.delta = event.wheelDelta/120; 31 | if ( window.opera ){ 32 | event.delta *= -1; 33 | } 34 | break; 35 | case "DOMMouseScroll": // firefox 36 | $.extend( event, event.data ); // fix event properties in FF2 37 | event.delta = -event.detail/3; 38 | break; 39 | case "mousemove": // FF2 has incorrect event positions 40 | return $.extend( event.data, { // store the correct properties 41 | clientX: event.clientX, pageX: event.pageX, 42 | clientY: event.clientY, pageY: event.pageY 43 | }); 44 | } 45 | event.type = "wheel"; // hijack the event 46 | return $.event.handle.call( this, event, event.delta ); 47 | } 48 | }; 49 | 50 | })( jQuery ); // confine scope -------------------------------------------------------------------------------- /fire/test/mutation.js: -------------------------------------------------------------------------------- 1 | module("Mutation Events"); 2 | 3 | // test each of the following events 4 | $.each([ 5 | "DOMSubtreeModified","DOMNodeInserted", 6 | "DOMNodeRemoved","DOMNodeRemovedFromDocument", 7 | "DOMNodeInsertedIntoDocument","DOMAttrModified", 8 | "DOMCharacterDataModified" 9 | ],function( i, type ){ 10 | // test each event type 11 | test( '"'+ type +'"', function(){ 12 | expect( 0 ); 13 | 14 | // custom event properties 15 | var props = { 16 | //keyCode: Math.round( Math.random() * 256 ), 17 | //charCode: Math.round( Math.random() * 256 ), 18 | ctrlKey: Math.round( Math.random() ) ? true : false, 19 | altKey: Math.round( Math.random() ) ? true : false, 20 | shiftKey: Math.round( Math.random() ) ? true : false 21 | }, 22 | // new test element 23 | $div = $('
          ').appendTo( document.body ); 24 | // test the document too for bubbling 25 | $div.add( document ).bind( type, function( ev ){ 26 | 27 | equals( ev.currentTarget, this, "event.currentTarget"); 28 | equals( ev.target, $div[0], "event.target" ); 29 | equals( ev.type, type, "event.type" ); 30 | 31 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 32 | equals( ev.altKey, props.altKey, "event.altKey" ); 33 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 34 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 35 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 36 | }); 37 | 38 | // make sure that metaKey and ctrlKey are equal 39 | props.metaKey = props.ctrlKey; 40 | // fire the event with bubbling 41 | props.bubbles = true; 42 | $div.fire( type, props ); 43 | 44 | // fire the event without bubbling 45 | props.bubbles = false; 46 | $div.fire( type, props ); 47 | 48 | // cleanup 49 | $( document ).unbind( type ); 50 | $div.remove(); 51 | }); 52 | }); -------------------------------------------------------------------------------- /fire/test/key.js: -------------------------------------------------------------------------------- 1 | module("Key Events"); 2 | 3 | // test each of the following events 4 | $.each([ 5 | "keydown","keyup","keypress" 6 | ],function( i, type ){ 7 | // test each event type 8 | test( '"'+ type +'"', function(){ 9 | expect( i < 2 ? 27 : 30 ); 10 | 11 | // custom event properties 12 | var props = { 13 | keyCode: Math.round( Math.random() * 256 ), 14 | charCode: Math.round( Math.random() * 256 ), 15 | ctrlKey: Math.round( Math.random() ) ? true : false, 16 | altKey: Math.round( Math.random() ) ? true : false, 17 | shiftKey: Math.round( Math.random() ) ? true : false 18 | }, 19 | // new test element 20 | $div = $('
          ').appendTo( document.body ); 21 | // test the document too for bubbling 22 | $div.add( document ).bind( type, function( ev ){ 23 | 24 | equals( ev.currentTarget, this, "event.currentTarget"); 25 | equals( ev.target, $div[0], "event.target" ); 26 | equals( ev.type, type, "event.type" ); 27 | equals( ev.keyCode, props.keyCode, "event.keyCode" ); 28 | if ( type == "keypress" ){ 29 | equals( ev.charCode, props.charCode, "event.charCode" ); 30 | } 31 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 32 | equals( ev.altKey, props.altKey, "event.altKey" ); 33 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 34 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 35 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 36 | }); 37 | 38 | // make sure that metaKey and ctrlKey are equal 39 | props.metaKey = props.ctrlKey; 40 | // fire the event with bubbling 41 | props.bubbles = true; 42 | $div.fire( type, props ); 43 | 44 | // fire the event without bubbling 45 | props.bubbles = false; 46 | $div.fire( type, props ); 47 | 48 | // cleanup 49 | $( document ).unbind( type ); 50 | $div.remove(); 51 | }); 52 | }); -------------------------------------------------------------------------------- /event.drop/test/method.js: -------------------------------------------------------------------------------- 1 | module("Drop Method"); 2 | 3 | $.each(['init','start','','end'],function( i, type ){ 4 | 5 | test('"drop'+ type +'"',function(){ 6 | 7 | expect( 9 ); 8 | 9 | // make sure the event handler gets bound to the element 10 | var $elem = $('
          '), 11 | elem = $elem[0], 12 | count = 0, 13 | fn = function(){ 14 | count += 1; 15 | }; 16 | 17 | ok( $elem.drop( type, fn )[0] == elem, ".drop("+( type ? '"'+ type +'",' : "" )+" fn )" ); 18 | ok( $.data( elem, $.event.special.drop.datakey ), "drop data exists" ); 19 | ok( $.data( elem, "events" ), "event data exists" ); 20 | ok( $.data( elem, "events" )[ 'drop'+type ][0], '"drop'+ type +'" event handler added' ); 21 | 22 | ok( $elem.drop( type )[0] == elem, ".drop("+( type ? '"'+ type +'"' : "" )+")" ); 23 | ok( count == 1, "handler was triggered"); 24 | 25 | ok( $elem.unbind( "drop"+ type )[0] == elem, '.unbind("drop'+ type +'")' ); 26 | ok( !$.data( elem, "events" ), "event data removed" ); 27 | ok( !$.data( elem, $.event.special.drag.datakey ), "drag data removed" ); 28 | 29 | $elem.remove(); 30 | 31 | }); 32 | 33 | }); 34 | 35 | test('$.drop()',function(){ 36 | 37 | expect( 4 ); 38 | 39 | // call the static method with settings 40 | var drop = $.event.special.drop, 41 | def = { 42 | multi: drop.multi, 43 | delay: drop.delay, 44 | mode: drop.mode, 45 | tolerance: null 46 | }, 47 | opts = { 48 | multi: 99, 49 | delay: 88, 50 | mode: 77, 51 | tolerance: function(){} 52 | }; 53 | $.drop( opts ); 54 | 55 | ok( drop.multi == opts.multi, "multi option was set" ); 56 | ok( drop.delay == opts.delay, "delay option was set" ); 57 | ok( drop.mode == opts.mode, "mode option was set" ); 58 | ok( drop.tolerance == opts.tolerance, "tolerance option was set" ); 59 | 60 | // restore defaults 61 | $.drop( def ); 62 | 63 | }); -------------------------------------------------------------------------------- /fire/test/mouse.js: -------------------------------------------------------------------------------- 1 | module("Mouse Events"); 2 | 3 | // test each of the following events 4 | $.each([ 5 | "click","dblclick", 6 | "mouseover","mouseout", 7 | "mousedown","mouseup","mousemove" 8 | ],function( i, type ){ 9 | // test each event type 10 | test( '"'+ type +'"', function(){ 11 | expect( 33 ); 12 | 13 | // custom event properties 14 | var props = { 15 | pageX: Math.round( Math.random() * 500 ), 16 | pageY: Math.round( Math.random() * 500 ), 17 | ctrlKey: Math.round( Math.random() ) ? true : false, 18 | altKey: Math.round( Math.random() ) ? true : false, 19 | shiftKey: Math.round( Math.random() ) ? true : false, 20 | button: Math.round( Math.random() * 2 ) 21 | }, 22 | // new test element 23 | $div = $('
          ').appendTo( document.body ); 24 | // test the document too for bubbling 25 | $div.add( document ).bind( type, function( ev ){ 26 | 27 | equals( ev.currentTarget, this, "event.currentTarget"); 28 | equals( ev.target, $div[0], "event.target" ); 29 | equals( ev.type, type, "event.type" ); 30 | equals( ev.pageX, props.pageX, "event.pageX" ); 31 | equals( ev.pageY, props.pageY, "event.pageY" ); 32 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 33 | equals( ev.altKey, props.altKey, "event.altKey" ); 34 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 35 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 36 | equals( ev.button, props.button, "event.button" ); 37 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 38 | }); 39 | 40 | // make sure that metaKey and ctrlKey are equal 41 | props.metaKey = props.ctrlKey; 42 | // fire the event with bubbling 43 | props.bubbles = true; 44 | $div.fire( type, props ); 45 | 46 | // fire the event without bubbling 47 | props.bubbles = false; 48 | $div.fire( type, props ); 49 | 50 | // cleanup 51 | $( document ).unbind( type ); 52 | $div.remove(); 53 | }); 54 | }); -------------------------------------------------------------------------------- /event.drop/test/properties.js: -------------------------------------------------------------------------------- 1 | module("Callback Properties"); 2 | 3 | $.each(["init","start","","end"],function( i, type ){ 4 | 5 | test('"drop'+ type +'" callback',function(){ 6 | 7 | expect( i ? 10 : 12 ); 8 | 9 | // create the markup for the test 10 | var $drag = $('
          ') 11 | .appendTo( document.body ) 12 | .css({ 13 | position: 'absolute', 14 | top: 0, 15 | left: 0, 16 | height: 100, 17 | width: 100 18 | }) 19 | .bind("draginit",function( ev, dd ){ 20 | same( dd.drop, [], 'draginit: "drop"' ); 21 | same( dd.available, [], 'draginit: "available"' ); 22 | }) 23 | .bind("dragstart",function( ev, dd ){ 24 | same( dd.drop, [], 'dragstart: "drop"' ); 25 | same( dd.available, available, 'dragstart: "available"' ); 26 | }) 27 | .bind("drag",function( ev, dd ){ 28 | same( dd.drop, [], 'drag: "drop"' ); 29 | same( dd.available, available, 'drag: "available"' ); 30 | }) 31 | .bind("dragend",function( ev, dd ){ 32 | same( dd.drop, drop, 'dragend: "drop"' ); 33 | same( dd.available, available, 'dragend: "available"' ); 34 | $drag.remove(); 35 | $drop.remove(); 36 | }), 37 | $drop = $('
          ') 38 | .appendTo( document.body ) 39 | .css({ 40 | position: 'absolute', 41 | top: 0, 42 | left: 0, 43 | height: 100, 44 | width: 100 45 | }) 46 | .drop( type, function( ev, dd ){ 47 | same( dd.drop, i < 2 ? [] : drop, 'drop'+ type +': "drop"' ); 48 | same( dd.available, i < 1 ? [] : available, 'drop'+ type +': "available"' ); 49 | }), 50 | available = $drop.toArray(), 51 | drop = $drop.eq(0).toArray(); 52 | 53 | $.drop({ mode:'overlap', multi:false }); 54 | // simulate a complete drag and drop 55 | $drag 56 | .fire("mousedown",{ pageX:50, pageY:50 }) 57 | .fire("mousemove",{ pageX:51, pageY:51 }) 58 | .fire("mouseup",{ pageX:51, pageY:51 }) 59 | .trigger("click"); 60 | }); 61 | 62 | }); -------------------------------------------------------------------------------- /fire/test/custom.js: -------------------------------------------------------------------------------- 1 | module("Custom Events"); 2 | 3 | if ( !document.createEvent ){ 4 | test("Custom Event Simulation Not Supported",function(){ 5 | ok( true, 'This browser does not support "document.createEvent" and cannot simulate custom events.'); 6 | }); 7 | } 8 | else { 9 | 10 | // test each of the following events 11 | $.each([ 12 | "snap","crackle","pop" 13 | ],function( i, type ){ 14 | // test each event type 15 | test( '"'+ type +'"', function(){ 16 | expect( 33 ); 17 | 18 | // custom event properties 19 | var props = { 20 | pageX: Math.round( Math.random() * 500 ), 21 | pageY: Math.round( Math.random() * 500 ), 22 | ctrlKey: Math.round( Math.random() ) ? true : false, 23 | altKey: Math.round( Math.random() ) ? true : false, 24 | shiftKey: Math.round( Math.random() ) ? true : false, 25 | button: Math.round( Math.random() * 2 ) 26 | }, 27 | // new test element 28 | $div = $('
          ').appendTo( document.body ); 29 | // test the document too for bubbling 30 | $div.add( document ).bind( type, function( ev ){ 31 | 32 | equals( ev.currentTarget, this, "event.currentTarget"); 33 | equals( ev.target, $div[0], "event.target" ); 34 | equals( ev.type, type, "event.type" ); 35 | equals( ev.pageX, props.pageX, "event.pageX" ); 36 | equals( ev.pageY, props.pageY, "event.pageY" ); 37 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 38 | equals( ev.altKey, props.altKey, "event.altKey" ); 39 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 40 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 41 | equals( ev.button, props.button, "event.button" ); 42 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 43 | }); 44 | 45 | // make sure that metaKey and ctrlKey are equal 46 | props.metaKey = props.ctrlKey; 47 | // fire the event with bubbling 48 | props.bubbles = true; 49 | $div.fire( type, props ); 50 | 51 | // fire the event without bubbling 52 | props.bubbles = false; 53 | $div.fire( type, props ); 54 | 55 | // cleanup 56 | $( document ).unbind( type ); 57 | $div.remove(); 58 | }); 59 | }); 60 | 61 | } -------------------------------------------------------------------------------- /fire/test/touch.js: -------------------------------------------------------------------------------- 1 | module("Touch Events"); 2 | 3 | if ( !document.createEvent ){ 4 | test("Touch Simulation Not Supported",function(){ 5 | ok( true, 'This browser does not support "document.createEvent" and cannot simulate touch events.'); 6 | }); 7 | } 8 | else { 9 | 10 | // test each of the following events 11 | $.each([ 12 | "touchstart","touchmove","touchend" 13 | ],function( i, type ){ 14 | // test each event type 15 | test( '"'+ type +'"', function(){ 16 | expect( 33 ); 17 | 18 | // custom event properties 19 | var props = { 20 | pageX: Math.round( Math.random() * 500 ), 21 | pageY: Math.round( Math.random() * 500 ), 22 | ctrlKey: Math.round( Math.random() ) ? true : false, 23 | altKey: Math.round( Math.random() ) ? true : false, 24 | shiftKey: Math.round( Math.random() ) ? true : false, 25 | button: Math.round( Math.random() * 2 ) 26 | }, 27 | // new test element 28 | $div = $('
          ').appendTo( document.body ); 29 | // test the document too for bubbling 30 | $div.add( document ).bind( type, function( ev ){ 31 | 32 | equals( ev.currentTarget, this, "event.currentTarget"); 33 | equals( ev.target, $div[0], "event.target" ); 34 | equals( ev.type, type, "event.type" ); 35 | equals( ev.pageX, props.pageX, "event.pageX" ); 36 | equals( ev.pageY, props.pageY, "event.pageY" ); 37 | equals( ev.ctrlKey, props.ctrlKey, "event.ctrlKey" ); 38 | equals( ev.altKey, props.altKey, "event.altKey" ); 39 | equals( ev.shiftKey, props.shiftKey, "event.shiftKey" ); 40 | equals( ev.metaKey, props.metaKey, "event.metaKey" ); 41 | equals( ev.button, props.button, "event.button" ); 42 | equals( ev.bubbles, props.bubbles, "event.bubbles" ); 43 | }); 44 | 45 | // make sure that metaKey and ctrlKey are equal 46 | props.metaKey = props.ctrlKey; 47 | // fire the event with bubbling 48 | props.bubbles = true; 49 | $div.fire( type, props ); 50 | 51 | // fire the event without bubbling 52 | props.bubbles = false; 53 | $div.fire( type, props ); 54 | 55 | // cleanup 56 | $( document ).unbind( type ); 57 | $div.remove(); 58 | }); 59 | }); 60 | 61 | } -------------------------------------------------------------------------------- /event.drag/test/properties.js: -------------------------------------------------------------------------------- 1 | module("Callback Properties"); 2 | 3 | $.each(["init","start","","end"],function( i, type ){ 4 | 5 | test('"drag'+ type +'" callback',function(){ 6 | 7 | expect( 13 ); 8 | 9 | // create the markup for the test 10 | var $div = $('
          ') 11 | .appendTo( document.body ), 12 | // starting position 13 | sx = Math.round( Math.random() * 90 ) + 5, 14 | sy = Math.round( Math.random() * 90 ) + 5, 15 | // mouse offset position 16 | mx = Math.round( Math.random() * 90 ) + 5, 17 | my = Math.round( Math.random() * 90 ) + 5, 18 | // distance dragged 19 | dx = Math.round( Math.random() * 90 ) + 5, 20 | dy = Math.round( Math.random() * 90 ) + 5; 21 | 22 | $div 23 | .drag( type, function( event, dd ){ 24 | 25 | ok( dd.target == $div[0], "target: [drag target]" ); 26 | ok( dd.drag == $div[0], "drag: [drag target]" ); 27 | ok( dd.proxy == $div[0], "proxy: [drag target]" ); 28 | 29 | equals( dd.startX, sx + mx, "startX" ); 30 | equals( dd.startY, sy + my, "startY" ); 31 | 32 | equals( dd.deltaX, i ? dx : 0, "deltaX" ); 33 | equals( dd.deltaY, i ? dy : 0, "deltaY" ); 34 | 35 | equals( dd.originalX, sx, "originalX" ); 36 | equals( dd.originalY, sy, "originalY" ); 37 | 38 | equals( dd.offsetX, i ? sx + dx : sx, "offsetX" ); 39 | equals( dd.offsetY, i ? sy + dy : sy, "offsetY" ); 40 | 41 | ok( dd.drop.constructor == Array && !dd.drop.length, "drop: []" ); 42 | ok( dd.available.constructor == Array && !dd.available.length, "available: []" ); 43 | 44 | }) 45 | .css({ 46 | position: 'absolute', 47 | top: sy, 48 | left: sx, 49 | height: 100, 50 | width: 100 51 | }) 52 | // simulate a drag 53 | .fire("mousedown",{ 54 | pageX: sx + mx, 55 | pageY: sy + my 56 | }) 57 | .fire("mousemove",{ 58 | pageX: sx + mx + dx, 59 | pageY: sy + my + dy 60 | }) 61 | .fire("mouseup",{ 62 | pageX: sx + mx + dx, 63 | pageY: sy + my + dy 64 | }) 65 | .fire("click",{ 66 | pageX: sx + mx + dx, 67 | pageY: sy + my + dy 68 | }); 69 | $div.remove(); 70 | }); 71 | }); -------------------------------------------------------------------------------- /event.drag/test/binding.js: -------------------------------------------------------------------------------- 1 | module("Event Binding"); 2 | 3 | $.each(['draginit','dragstart','drag','dragend'],function( i, type ){ 4 | 5 | test('"'+ type +'"',function(){ 6 | 7 | expect( 27 ); 8 | 9 | // make sure the event handler gets bound to the element 10 | var $elem = $('
          '), 11 | elem = $elem[0], 12 | count = 0, 13 | fn = function(){ 14 | count += 1; 15 | }, 16 | opts = { 17 | which: 99, 18 | distance: 88, 19 | not: 77, 20 | handle: 66, 21 | relative: 55, 22 | drop: 44, 23 | click: 33 24 | }, 25 | def = $.event.special[ type ].defaults, 26 | data; 27 | 28 | ok( $elem.bind( type, fn )[0] == elem, '.bind("'+ type +'", fn )' ); 29 | ok( data = $.data( elem, $.event.special.drag.datakey ), "drag data exists" ); 30 | ok( $.data( elem, "events" ), "event data exists" ); 31 | ok( $.data( elem, "events" )[ type ][0], '"'+ type +'" event handler added' ); 32 | 33 | ok( data.which == def.which, '"which" default stored' ); 34 | ok( data.distance == def.distance, '"distance" default stored' ); 35 | ok( data.not == def.not, '"not" default stored' ); 36 | ok( data.handle == def.handle, '"handle" default stored' ); 37 | ok( data.relative == def.relative, '"relative" default stored' ); 38 | ok( data.drop == def.drop, '"drop" default stored' ); 39 | ok( data.click == def.click, '"click" default stored' ); 40 | 41 | ok( $elem.trigger( type )[0] == elem, '.trigger("'+ type +'")' ); 42 | ok( count == 1, "handler was triggered"); 43 | 44 | ok( $elem.unbind( type )[0] == elem, '.unbind("'+ type +'")' ); 45 | ok( !$.data( elem, "events" ), "event data removed" ); 46 | ok( !$.data( elem, $.event.special.drag.datakey ), "drag data removed" ); 47 | 48 | ok( $elem.bind( type, opts, fn )[0] == elem, '.bind("'+ type +'", data, fn )' ); 49 | ok( data = $.data( elem, $.event.special.drag.datakey ), "drag data exists" ); 50 | ok( $.data( elem, "events" ), "event data exists" ); 51 | ok( $.data( elem, "events" )[ type ][0], '"drag'+ type +'" event handler added' ); 52 | 53 | ok( data.which == opts.which, '"which" option stored' ); 54 | ok( data.distance == opts.distance, '"distance" option stored' ); 55 | ok( data.not == opts.not, '"not" option stored' ); 56 | ok( data.handle == opts.handle, '"handle" option stored' ); 57 | ok( data.relative == opts.relative, '"relative" option stored' ); 58 | ok( data.drop == opts.drop, '"drop" option stored' ); 59 | ok( data.click == opts.click, '"click" option stored' ); 60 | 61 | $elem.remove(); 62 | 63 | }); 64 | }); -------------------------------------------------------------------------------- /event.drag/test/method.js: -------------------------------------------------------------------------------- 1 | module("Drag Method"); 2 | 3 | $.each(['init','start','','end'],function( i, type ){ 4 | 5 | test('"drag'+ type +'"',function(){ 6 | 7 | expect( 27 ); 8 | 9 | // make sure the event handler gets bound to the element 10 | var $elem = $('
          '), 11 | elem = $elem[0], 12 | count = 0, 13 | fn = function(){ 14 | count += 1; 15 | }, 16 | opts = { 17 | which: 99, 18 | distance: 88, 19 | not: 77, 20 | handle: 66, 21 | relative: 55, 22 | drop: 44, 23 | click: 33 24 | }, 25 | def = $.event.special[ 'drag'+ type ].defaults, 26 | data; 27 | 28 | ok( $elem.drag( type, fn )[0] == elem, '.drag('+( type ? '"'+ type +'",' : '' )+' fn )' ); 29 | ok( data = $.data( elem, $.event.special.drag.datakey ), "drag data exists" ); 30 | ok( $.data( elem, "events" ), "event data exists" ); 31 | ok( $.data( elem, "events" )[ 'drag'+type ][0], '"drag'+ type +'" event handler added' ); 32 | 33 | ok( data.which == def.which, '"which" default stored' ); 34 | ok( data.distance == def.distance, '"distance" default stored' ); 35 | ok( data.not == def.not, '"not" default stored' ); 36 | ok( data.handle == def.handle, '"handle" default stored' ); 37 | ok( data.relative == def.relative, '"relative" default stored' ); 38 | ok( data.drop == def.drop, '"drop" default stored' ); 39 | ok( data.click == def.click, '"click" default stored' ); 40 | 41 | ok( $elem.drag( type )[0] == elem, '.drag('+( type ? '"'+ type +'"' : '' )+')' ); 42 | ok( count == 1, "handler was triggered"); 43 | 44 | ok( $elem.unbind( "drag"+ type )[0] == elem, '.unbind("drag'+ type +'")' ); 45 | ok( !$.data( elem, "events" ), "event data removed" ); 46 | ok( !$.data( elem, $.event.special.drag.datakey ), "drag data removed" ); 47 | 48 | ok( $elem.drag( type, fn, opts )[0] == elem, '.drag('+( type ? '"'+ type +'",' : '' )+' fn, opts )' ); 49 | ok( data = $.data( elem, $.event.special.drag.datakey ), "drag data exists" ); 50 | ok( $.data( elem, "events" ), "event data exists" ); 51 | ok( $.data( elem, "events" )[ 'drag'+type ][0], '"drag'+ type +'" event handler added' ); 52 | 53 | ok( data.which == opts.which, '"which" option stored' ); 54 | ok( data.distance == opts.distance, '"distance" option stored' ); 55 | ok( data.not == opts.not, '"not" option stored' ); 56 | ok( data.handle == opts.handle, '"handle" option stored' ); 57 | ok( data.relative == opts.relative, '"relative" option stored' ); 58 | ok( data.drop == opts.drop, '"drop" option stored' ); 59 | ok( data.click == opts.click, '"click" option stored' ); 60 | 61 | $elem.remove(); 62 | 63 | }); 64 | }); -------------------------------------------------------------------------------- /event.drag/jquery.event.drag.live.js: -------------------------------------------------------------------------------- 1 | /*! 2 | * jquery.event.drag.live - v 2.2 3 | * Copyright (c) 2010 Three Dub Media - http://threedubmedia.com 4 | * Open Source MIT License - http://threedubmedia.com/code/license 5 | */ 6 | // Created: 2010-06-07 7 | // Updated: 2012-05-21 8 | // REQUIRES: jquery 1.7.x, event.drag 2.2 9 | 10 | ;(function( $ ){ 11 | 12 | // local refs (increase compression) 13 | var $event = $.event, 14 | // ref the special event config 15 | drag = $event.special.drag, 16 | // old drag event add method 17 | origadd = drag.add, 18 | // old drag event teradown method 19 | origteardown = drag.teardown; 20 | 21 | // allow events to bubble for delegation 22 | drag.noBubble = false; 23 | 24 | // the namespace for internal live events 25 | drag.livekey = "livedrag"; 26 | 27 | // new drop event add method 28 | drag.add = function( obj ){ 29 | // call the old method 30 | origadd.apply( this, arguments ); 31 | // read the data 32 | var data = $.data( this, drag.datakey ); 33 | // bind the live "draginit" delegator 34 | if ( !data.live && obj.selector ){ 35 | data.live = true; 36 | $event.add( this, "draginit."+ drag.livekey, drag.delegate ); 37 | } 38 | }; 39 | 40 | // new drop event teardown method 41 | drag.teardown = function(){ 42 | // call the old method 43 | origteardown.apply( this, arguments ); 44 | // read the data 45 | var data = $.data( this, drag.datakey ) || {}; 46 | // bind the live "draginit" delegator 47 | if ( data.live ){ 48 | // remove the "live" delegation 49 | $event.remove( this, "draginit."+ drag.livekey, drag.delegate ); 50 | data.live = false; 51 | } 52 | }; 53 | 54 | // identify potential delegate elements 55 | drag.delegate = function( event ){ 56 | // local refs 57 | var elems = [], target, 58 | // element event structure 59 | events = $.data( this, "events" ) || {}; 60 | // query live events 61 | $.each( events || [], function( key, arr ){ 62 | // no event type matches 63 | if ( key.indexOf("drag") !== 0 ) 64 | return; 65 | $.each( arr || [], function( i, obj ){ 66 | // locate the element to delegate 67 | target = $( event.target ).closest( obj.selector, event.currentTarget )[0]; 68 | // no element found 69 | if ( !target ) 70 | return; 71 | // add an event handler 72 | $event.add( target, obj.origType+'.'+drag.livekey, obj.origHandler || obj.handler, obj.data ); 73 | // remember new elements 74 | if ( $.inArray( target, elems ) < 0 ) 75 | elems.push( target ); 76 | }); 77 | }); 78 | // if there are no elements, break 79 | if ( !elems.length ) 80 | return false; 81 | // return the matched results, and clenup when complete 82 | return $( elems ).bind("dragend."+ drag.livekey, function(){ 83 | $event.remove( this, "."+ drag.livekey ); // cleanup delegation 84 | }); 85 | }; 86 | 87 | })( jQuery ); -------------------------------------------------------------------------------- /event.drop/jquery.event.drop.live.js: -------------------------------------------------------------------------------- 1 | /*! 2 | * jquery.event.drop.live - v 2.2 3 | * Copyright (c) 2010 Three Dub Media - http://threedubmedia.com 4 | * Open Source MIT License - http://threedubmedia.com/code/license 5 | */ 6 | // Created: 2010-06-07 7 | // Updated: 2012-05-21 8 | // REQUIRES: jquery 1.7.x, event.drag 2.2, event.drop 2.2 9 | 10 | ;(function($){ // secure $ jQuery alias 11 | 12 | // local refs (increase compression) 13 | var $event = $.event, 14 | // ref the drop special event config 15 | drop = $event.special.drop, 16 | // old drop event add method 17 | origadd = drop.add, 18 | // old drop event teradown method 19 | origteardown = drop.teardown; 20 | 21 | // allow events to bubble for delegation 22 | drop.noBubble = false; 23 | 24 | // the namespace for internal live events 25 | drop.livekey = "livedrop"; 26 | 27 | // new drop event add method 28 | drop.add = function( obj ){ 29 | // call the old method 30 | origadd.apply( this, arguments ); 31 | // read the data 32 | var data = $.data( this, drop.datakey ); 33 | // bind the live "dropinit" delegator 34 | if ( !data.live && obj.selector ){ 35 | data.live = true; 36 | $event.add( this, "dropinit."+ drop.livekey, drop.delegate ); 37 | } 38 | }; 39 | 40 | // new drop event teardown method 41 | drop.teardown = function(){ 42 | // call the old method 43 | origteardown.apply( this, arguments ); 44 | // read the data 45 | var data = $.data( this, drop.datakey ) || {}; 46 | // remove the live "dropinit" delegator 47 | if ( data.live ){ 48 | // remove the "live" delegation 49 | $event.remove( this, "dropinit", drop.delegate ); 50 | data.live = false; 51 | } 52 | }; 53 | 54 | // identify potential delegate elements 55 | drop.delegate = function( event, dd ){ 56 | // local refs 57 | var elems = [], $targets, 58 | // element event structure 59 | events = $.data( this, "events" ) || {}; 60 | // query live events 61 | $.each( events || [], function( key, arr ){ 62 | // no event type matches 63 | if ( key.indexOf("drop") !== 0 ) 64 | return; 65 | $.each( arr, function( i, obj ){ 66 | // locate the elements to delegate 67 | $targets = $( event.currentTarget ).find( obj.selector ); 68 | // no element found 69 | if ( !$targets.length ) 70 | return; 71 | // take each target... 72 | $targets.each(function(){ 73 | // add an event handler 74 | $event.add( this, obj.origType +'.'+ drop.livekey, obj.origHandler || obj.handler, obj.data ); 75 | // remember new elements 76 | if ( $.inArray( this, elems ) < 0 ) 77 | elems.push( this ); 78 | }); 79 | }); 80 | }); 81 | // may not exist when artifically triggering dropinit event 82 | if ( dd ) 83 | // clean-up after the interaction ends 84 | $event.add( dd.drag, "dragend."+drop.livekey, function(){ 85 | $.each( elems.concat( this ), function(){ 86 | $event.remove( this, '.'+ drop.livekey ); 87 | }); 88 | }); 89 | //drop.delegates.push( elems ); 90 | return elems.length ? $( elems ) : false; 91 | }; 92 | 93 | })( jQuery ); // confine scope -------------------------------------------------------------------------------- /event.linger/test/handlers.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Event Handlers"); 4 | 5 | // a simple re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | obj.$div = $('
          ') 9 | .css({ 10 | position: 'absolute', 11 | top: 0, 12 | left: 0, 13 | height: 100, 14 | width: 100 15 | }) 16 | .append('
          ') 17 | .appendTo( document.body ) 18 | .bind("lingerstart linger lingerend", opts || {}, function( event ){ 19 | obj[ event.type ] += 1; 20 | return obj.returned[ event.type ]; 21 | }); 22 | $.extend( obj, { lingerstart:0, linger:0, lingerend:0 }); 23 | obj.returned = {}; 24 | }, 25 | done: function(){ 26 | obj.$div.remove(); 27 | start(); 28 | } 29 | }; 30 | 31 | asyncTest('"lingerstart" return false',function(){ 32 | 33 | expect( 3 ); 34 | 35 | // prep interaction 36 | obj.init(); 37 | // set the return value 38 | obj.returned['lingerstart'] = false; 39 | // simulate interaction 40 | obj.$div 41 | .fire("mouseover",{ pageX:50, pageY:50 }) 42 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 43 | // wait 100 ms (default delay) 44 | setTimeout(function(){ 45 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 46 | // wait 100 ms (persist) 47 | setTimeout(function(){ 48 | // inspect results 49 | equals( obj.lingerstart, 1, "lingerstart"); 50 | equals( obj.linger, 0, "linger"); 51 | equals( obj.lingerend, 0, "lingerend"); 52 | obj.done(); 53 | }, 100 ); 54 | }, 100 ); 55 | 56 | }); 57 | 58 | asyncTest('"linger" return false',function(){ 59 | 60 | expect( 3 ); 61 | 62 | // prep interaction 63 | obj.init({ persist:100 }); 64 | // set the return value 65 | obj.returned['linger'] = false; 66 | // simulate interaction 67 | obj.$div 68 | .fire("mouseover",{ pageX:50, pageY:50 }) 69 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 70 | // wait 300 ms (3x default delay) 71 | setTimeout(function(){ 72 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 73 | // wait 100 ms (persist) 74 | setTimeout(function(){ 75 | // inspect results 76 | equals( obj.lingerstart, 1, "lingerstart"); 77 | equals( obj.linger, 3, "linger"); 78 | equals( obj.lingerend, 0, "lingerend"); 79 | obj.done(); 80 | }, 100 ); 81 | }, 350 ); 82 | 83 | }); 84 | 85 | asyncTest('"lingerend" return false',function(){ 86 | 87 | expect( 3 ); 88 | 89 | // prep interaction 90 | obj.init({ persist:100 }); 91 | // set the return value 92 | obj.returned['lingerend'] = false; 93 | // simulate interaction 94 | obj.$div 95 | .fire("mouseover",{ pageX:50, pageY:50 }) 96 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 97 | // wait 100 ms (default delay) 98 | setTimeout(function(){ 99 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 100 | // wait 300 ms (3x persist) 101 | setTimeout(function(){ 102 | // inspect results 103 | equals( obj.lingerstart, 1, "lingerstart"); 104 | equals( obj.linger, 1, "linger"); 105 | equals( obj.lingerend, 3, "lingerend"); 106 | obj.done(); 107 | }, 350 ); 108 | }, 300 ); 109 | }); 110 | 111 | })(); -------------------------------------------------------------------------------- /jquery/qunit.css: -------------------------------------------------------------------------------- 1 | ol#qunit-tests { 2 | font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 3 | margin:0; 4 | padding:0; 5 | list-style-position:inside; 6 | 7 | font-size: smaller; 8 | } 9 | ol#qunit-tests li{ 10 | padding:0.4em 0.5em 0.4em 2.5em; 11 | border-bottom:1px solid #fff; 12 | font-size:small; 13 | list-style-position:inside; 14 | } 15 | ol#qunit-tests li ol{ 16 | box-shadow: inset 0px 2px 13px #999; 17 | -moz-box-shadow: inset 0px 2px 13px #999; 18 | -webkit-box-shadow: inset 0px 2px 13px #999; 19 | margin-top:0.5em; 20 | margin-left:0; 21 | padding:0.5em; 22 | background-color:#fff; 23 | border-radius:15px; 24 | -moz-border-radius: 15px; 25 | -webkit-border-radius: 15px; 26 | } 27 | ol#qunit-tests li li{ 28 | border-bottom:none; 29 | margin:0.5em; 30 | background-color:#fff; 31 | list-style-position: inside; 32 | padding:0.4em 0.5em 0.4em 0.5em; 33 | } 34 | 35 | ol#qunit-tests li li.pass{ 36 | border-left:26px solid #C6E746; 37 | background-color:#fff; 38 | color:#5E740B; 39 | } 40 | ol#qunit-tests li li.fail{ 41 | border-left:26px solid #EE5757; 42 | background-color:#fff; 43 | color:#710909; 44 | } 45 | ol#qunit-tests li.pass{ 46 | background-color:#D2E0E6; 47 | color:#528CE0; 48 | } 49 | ol#qunit-tests li.fail{ 50 | background-color:#EE5757; 51 | color:#000; 52 | } 53 | ol#qunit-tests li strong { 54 | cursor:pointer; 55 | } 56 | h1#qunit-header{ 57 | background-color:#0d3349; 58 | margin:0; 59 | padding:0.5em 0 0.5em 1em; 60 | color:#fff; 61 | font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 62 | border-top-right-radius:15px; 63 | border-top-left-radius:15px; 64 | -moz-border-radius-topright:15px; 65 | -moz-border-radius-topleft:15px; 66 | -webkit-border-top-right-radius:15px; 67 | -webkit-border-top-left-radius:15px; 68 | text-shadow: rgba(0, 0, 0, 0.5) 4px 4px 1px; 69 | } 70 | h2#qunit-banner{ 71 | font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 72 | height:5px; 73 | margin:0; 74 | padding:0; 75 | } 76 | h2#qunit-banner.qunit-pass{ 77 | background-color:#C6E746; 78 | } 79 | h2#qunit-banner.qunit-fail, #qunit-testrunner-toolbar { 80 | background-color:#EE5757; 81 | } 82 | #qunit-testrunner-toolbar { 83 | font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 84 | padding:0; 85 | /*width:80%;*/ 86 | padding:0em 0 0.5em 2em; 87 | font-size: small; 88 | } 89 | h2#qunit-userAgent { 90 | font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 91 | background-color:#2b81af; 92 | margin:0; 93 | padding:0; 94 | color:#fff; 95 | font-size: small; 96 | padding:0.5em 0 0.5em 2.5em; 97 | text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px; 98 | } 99 | p#qunit-testresult{ 100 | font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 101 | margin:0; 102 | font-size: small; 103 | color:#2b81af; 104 | border-bottom-right-radius:15px; 105 | border-bottom-left-radius:15px; 106 | -moz-border-radius-bottomright:15px; 107 | -moz-border-radius-bottomleft:15px; 108 | -webkit-border-bottom-right-radius:15px; 109 | -webkit-border-bottom-left-radius:15px; 110 | background-color:#D2E0E6; 111 | padding:0.5em 0.5em 0.5em 2.5em; 112 | } 113 | strong b.fail{ 114 | color:#710909; 115 | } 116 | strong b.pass{ 117 | color:#5E740B; 118 | } 119 | -------------------------------------------------------------------------------- /event.drop/test/handlers.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Event Handlers"); 4 | 5 | // a simple re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | obj.$drag = $('
          ') 9 | .appendTo( document.body ) 10 | .css({ 11 | position: 'absolute', 12 | top: 0, 13 | left: 0, 14 | height: 100, 15 | width: 100 16 | }) 17 | .bind("dragend",{ drop:'.drop' },function( event, dd ){ 18 | same( dd.drop, obj.dragend, "drop (dragend)" ); 19 | }); 20 | obj.$drop = $('
          ') 21 | .appendTo( document.body ) 22 | .css({ 23 | position: 'absolute', 24 | top: 0, 25 | left: 0, 26 | height: 100, 27 | width: 100 28 | }) 29 | .bind("dropinit dropstart drop dropend",function( event, dd ){ 30 | obj[ event.type ] += 1; 31 | return obj.returned[ event.type ]; 32 | }); 33 | $.extend( obj, { dropinit:0, dropstart:0, drop:0, dropend:0 }); 34 | $.drop({ mode:'overlap', multi:false }); 35 | obj.returned = {}; 36 | obj.dragend = null; 37 | }, 38 | mouse: function(){ 39 | var start = { 40 | pageX: Math.round( Math.random() * 90 ) + 5, 41 | pageY: Math.round( Math.random() * 90 ) + 5 42 | }, 43 | end = { 44 | pageX: Math.round( Math.random() * 90 ) + start.pageX, 45 | pageY: Math.round( Math.random() * 90 ) + start.pageY 46 | }; 47 | // simulate a complete mouse drag 48 | obj.$drag 49 | .fire("mousedown", start ) 50 | .fire("mousemove", end ) 51 | .fire("mouseup", end ) 52 | .fire("click", end ); 53 | }, 54 | done: function( ms ){ 55 | obj.$drag.remove(); 56 | obj.$drop.remove(); 57 | start(); 58 | } 59 | }; 60 | 61 | asyncTest('"dropinit" return false',function(){ 62 | expect( 5 ); 63 | // test prep 64 | obj.init(); 65 | obj.returned['dropinit'] = false; 66 | obj.dragend = []; 67 | // simulate a partial drag 68 | obj.mouse(); 69 | // check counts 70 | equals( obj.dropinit, 1, "dropinit"); 71 | equals( obj.dropstart, 0, "dropstart"); 72 | equals( obj.drop, 0, "drop"); 73 | equals( obj.dropend, 0, "dropend"); 74 | // continue 75 | obj.done(); 76 | }); 77 | 78 | asyncTest('"dropstart" return false',function(){ 79 | expect( 5 ); 80 | // test prep 81 | obj.init(); 82 | obj.returned['dropstart'] = false; 83 | obj.dragend = []; 84 | // simulate a partial drag 85 | obj.mouse(); 86 | // check counts 87 | equals( obj.dropinit, 1, "dropinit"); 88 | equals( obj.dropstart, 1, "dropstart"); 89 | equals( obj.drop, 0, "drop"); 90 | equals( obj.dropend, 0, "dropend"); 91 | // continue 92 | obj.done(); 93 | }); 94 | 95 | 96 | asyncTest('"drop" return false',function(){ 97 | expect( 5 ); 98 | // test prep 99 | obj.init();// test DROP FALSE 100 | obj.returned['drop'] = false; 101 | obj.dragend = []; 102 | // simulate a partial drag 103 | obj.mouse(); 104 | // check counts 105 | equals( obj.dropinit, 1, "dropinit"); 106 | equals( obj.dropstart, 1, "dropstart"); 107 | equals( obj.drop, 1, "drop"); 108 | equals( obj.dropend, 0, "dropend"); 109 | // continue 110 | obj.done(); 111 | }); 112 | 113 | asyncTest('"dropinit" return elements',function(){ 114 | expect( 5 ); 115 | // test prep 116 | obj.init(); 117 | obj.returned['dropinit'] = obj.$drop.eq(1); 118 | obj.dragend = [ obj.$drop[1] ]; 119 | // simulate a partial drag 120 | obj.mouse(); 121 | // check counts 122 | equals( obj.dropinit, 1, "dropinit"); 123 | equals( obj.dropstart, 1, "dropstart"); 124 | equals( obj.drop, 1, "drop"); 125 | equals( obj.dropend, 1, "dropend"); 126 | // continue 127 | obj.done(); 128 | }); 129 | 130 | })(); -------------------------------------------------------------------------------- /event.drop/test/interaction.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Mouse Interaction"); 4 | 5 | // a simple re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | obj.$drag = $('
          ') 9 | .css({ 10 | position: 'absolute', 11 | top: 0, 12 | left: 0, 13 | height: 100, 14 | width: 100 15 | }) 16 | .appendTo( document.body ) 17 | .bind("draginit dragstart drag dragend click", opts || {}, function( event ){ 18 | obj[ event.type ] += 1; 19 | }); 20 | obj.$drop = $('
          ') 21 | .css({ 22 | position: 'absolute', 23 | top: 0, 24 | left: 0, 25 | height: 100, 26 | width: 100 27 | }) 28 | .appendTo( document.body ) 29 | .bind("dropinit dropstart drop dropend",function( event ){ 30 | obj[ event.type ] += 1; 31 | }); 32 | $.extend( obj, { 33 | draginit:0, dragstart:0, drag:0, dragend:0, 34 | dropinit:0, dropstart:0, drop:0, dropend:0, 35 | click:0 36 | }); 37 | }, 38 | mouse: function(){ 39 | var start = { 40 | pageX: Math.round( Math.random() * 90 ) + 5, 41 | pageY: Math.round( Math.random() * 90 ) + 5 42 | }, 43 | end = { 44 | pageX: Math.round( Math.random() * 90 ) + start.pageX, 45 | pageY: Math.round( Math.random() * 90 ) + start.pageY 46 | }; 47 | // simulate a complete mouse drag 48 | obj.$drag 49 | .fire("mousedown", start ) 50 | .fire("mousemove", end ) 51 | .fire("mouseup", end ) 52 | .fire("click", end ); 53 | }, 54 | done: function(){ 55 | obj.$drag.remove(); 56 | obj.$drop.remove(); 57 | start(); 58 | } 59 | }; 60 | 61 | asyncTest('Drag and Drop defaults',function(){ 62 | // prep DEFAULT interaction 63 | obj.init(); 64 | // simulate DEFAULT interaction 65 | obj.mouse(); 66 | // inspect results 67 | equals( obj.draginit, 1, "draginit"); 68 | equals( obj.dragstart, 1, "dragstart"); 69 | equals( obj.drag, 1, "drag"); 70 | equals( obj.dragend, 1, "dragend"); 71 | equals( obj.dropinit, 1, "dropinit"); 72 | equals( obj.dropstart, 1, "dropstart"); 73 | equals( obj.drop, 1, "drop"); 74 | equals( obj.dropend, 1, "dropend"); 75 | // continue 76 | obj.done(); 77 | }); 78 | 79 | asyncTest('Drag "drop" option (false)',function(){ 80 | // prep interaction 81 | obj.init({ drop:false }); 82 | // simulate drag 83 | obj.mouse(); 84 | // inspect results 85 | equals( obj.draginit, 1, "draginit"); 86 | equals( obj.dragstart, 1, "dragstart"); 87 | equals( obj.drag, 1, "drag"); 88 | equals( obj.dragend, 1, "dragend"); 89 | equals( obj.dropinit, 0, "dropinit"); 90 | equals( obj.dropstart, 0, "dropstart"); 91 | equals( obj.drop, 0, "drop"); 92 | equals( obj.dropend, 0, "dropend"); 93 | // continue 94 | obj.done(); 95 | }); 96 | 97 | asyncTest('Drag "drop" option (unmatched)',function(){ 98 | // prep interaction 99 | obj.init({ drop:'body' }); 100 | // simulate drag 101 | obj.mouse(); 102 | // inspect results 103 | equals( obj.draginit, 1, "draginit"); 104 | equals( obj.dragstart, 1, "dragstart"); 105 | equals( obj.drag, 1, "drag"); 106 | equals( obj.dragend, 1, "dragend"); 107 | equals( obj.dropinit, 0, "dropinit"); 108 | equals( obj.dropstart, 0, "dropstart"); 109 | equals( obj.drop, 0, "drop"); 110 | equals( obj.dropend, 0, "dropend"); 111 | // continue 112 | obj.done(); 113 | }); 114 | 115 | asyncTest('Drag "drop" option (matched)',function(){ 116 | // prep interaction 117 | obj.init({ drop:'div' }); 118 | // simulate drag 119 | obj.mouse(); 120 | // inspect results 121 | equals( obj.draginit, 1, "draginit"); 122 | equals( obj.dragstart, 1, "dragstart"); 123 | equals( obj.drag, 1, "drag"); 124 | equals( obj.dragend, 1, "dragend"); 125 | equals( obj.dropinit, 1, "dropinit"); 126 | equals( obj.dropstart, 1, "dropstart"); 127 | equals( obj.drop, 1, "drop"); 128 | equals( obj.dropend, 1, "dropend"); 129 | // continue 130 | obj.done(); 131 | }); 132 | 133 | })(); 134 | 135 | -------------------------------------------------------------------------------- /event.drop/test/touch.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Touch Interaction"); 4 | 5 | if ( !document.createEvent ){ 6 | test("Touch Simulation Not Supported",function(){ 7 | ok( true, 'This browser does not support "document.createEvent" and cannot simulate touch events.'); 8 | }); 9 | return; 10 | } 11 | 12 | // a simple re-usable test harness object 13 | var obj = { 14 | init: function( opts ){ 15 | obj.$drag = $('
          ') 16 | .css({ 17 | position: 'absolute', 18 | top: 0, 19 | left: 0, 20 | height: 100, 21 | width: 100 22 | }) 23 | .appendTo( document.body ) 24 | .bind("draginit dragstart drag dragend click", opts || {}, function( event ){ 25 | obj[ event.type ] += 1; 26 | }); 27 | obj.$drop = $('
          ') 28 | .css({ 29 | position: 'absolute', 30 | top: 0, 31 | left: 0, 32 | height: 100, 33 | width: 100 34 | }) 35 | .appendTo( document.body ) 36 | .bind("dropinit dropstart drop dropend",function( event ){ 37 | obj[ event.type ] += 1; 38 | }); 39 | $.extend( obj, { 40 | draginit:0, dragstart:0, drag:0, dragend:0, 41 | dropinit:0, dropstart:0, drop:0, dropend:0, 42 | click:0 43 | }); 44 | }, 45 | touch: function(){ 46 | var start = { 47 | pageX: Math.round( Math.random() * 90 ) + 5, 48 | pageY: Math.round( Math.random() * 90 ) + 5 49 | }, 50 | end = { 51 | pageX: Math.round( Math.random() * 90 ) + start.pageX, 52 | pageY: Math.round( Math.random() * 90 ) + start.pageY 53 | }; 54 | // simulate a complete mouse drag 55 | obj.$drag 56 | .fire("touchstart", start ) 57 | .fire("touchmove", end ) 58 | .fire("touchend", end ) 59 | .fire("click", end ); 60 | }, 61 | done: function(){ 62 | obj.$drag.remove(); 63 | obj.$drop.remove(); 64 | start(); 65 | } 66 | }; 67 | 68 | asyncTest('Drag and Drop defaults',function(){ 69 | // prep DEFAULT interaction 70 | obj.init(); 71 | // simulate DEFAULT interaction 72 | obj.touch(); 73 | // inspect results 74 | equals( obj.draginit, 1, "draginit"); 75 | equals( obj.dragstart, 1, "dragstart"); 76 | equals( obj.drag, 1, "drag"); 77 | equals( obj.dragend, 1, "dragend"); 78 | equals( obj.dropinit, 1, "dropinit"); 79 | equals( obj.dropstart, 1, "dropstart"); 80 | equals( obj.drop, 1, "drop"); 81 | equals( obj.dropend, 1, "dropend"); 82 | // continue 83 | obj.done(); 84 | }); 85 | 86 | asyncTest('Drag "drop" option (false)',function(){ 87 | // prep interaction 88 | obj.init({ drop:false }); 89 | // simulate drag 90 | obj.touch(); 91 | // inspect results 92 | equals( obj.draginit, 1, "draginit"); 93 | equals( obj.dragstart, 1, "dragstart"); 94 | equals( obj.drag, 1, "drag"); 95 | equals( obj.dragend, 1, "dragend"); 96 | equals( obj.dropinit, 0, "dropinit"); 97 | equals( obj.dropstart, 0, "dropstart"); 98 | equals( obj.drop, 0, "drop"); 99 | equals( obj.dropend, 0, "dropend"); 100 | // continue 101 | obj.done(); 102 | }); 103 | 104 | asyncTest('Drag "drop" option (unmatched)',function(){ 105 | // prep interaction 106 | obj.init({ drop:'body' }); 107 | // simulate drag 108 | obj.touch(); 109 | // inspect results 110 | equals( obj.draginit, 1, "draginit"); 111 | equals( obj.dragstart, 1, "dragstart"); 112 | equals( obj.drag, 1, "drag"); 113 | equals( obj.dragend, 1, "dragend"); 114 | equals( obj.dropinit, 0, "dropinit"); 115 | equals( obj.dropstart, 0, "dropstart"); 116 | equals( obj.drop, 0, "drop"); 117 | equals( obj.dropend, 0, "dropend"); 118 | // continue 119 | obj.done(); 120 | }); 121 | 122 | asyncTest('Drag "drop" option (matched)',function(){ 123 | // prep interaction 124 | obj.init({ drop:'div' }); 125 | // simulate drag 126 | obj.touch(); 127 | // inspect results 128 | equals( obj.draginit, 1, "draginit"); 129 | equals( obj.dragstart, 1, "dragstart"); 130 | equals( obj.drag, 1, "drag"); 131 | equals( obj.dragend, 1, "dragend"); 132 | equals( obj.dropinit, 1, "dropinit"); 133 | equals( obj.dropstart, 1, "dropstart"); 134 | equals( obj.drop, 1, "drop"); 135 | equals( obj.dropend, 1, "dropend"); 136 | // continue 137 | obj.done(); 138 | }); 139 | 140 | })(); -------------------------------------------------------------------------------- /fire/jquery.fire.js: -------------------------------------------------------------------------------- 1 | ;(function( $, window ){ 2 | 3 | /* 4 | http://www.w3.org/TR/DOM-Level-3-Events/#event-type-wheel 5 | */ 6 | 7 | // jQuery method 8 | $.fn.fire = function( type, opts ){ 9 | opts = opts || {}; 10 | // translate pageX to clientX 11 | if ( opts.pageX && !opts.clientX ) 12 | opts.clientX = opts.pageX - $( window ).scrollLeft(); 13 | // translate pageY to clientY 14 | if ( opts.pageY && !opts.clientY ) 15 | opts.clientY = opts.pageY - $( window ).scrollTop(); 16 | // iterate the jquery collection 17 | return this.each(function(){ 18 | // clone options uniquely for each instance 19 | opts = $.extend( {}, $.fire.defaults, opts ); 20 | // instanitate a new event 21 | new $.fire( this, type, opts ); 22 | }); 23 | }; 24 | 25 | // Constructor 26 | $.fire = function( element, type, opts ){ 27 | this.element = element; 28 | this.type = type; 29 | this.event = this.create( opts ); 30 | this.dispatch(); 31 | }; 32 | 33 | // Defaults 34 | $.fire.defaults = { 35 | bubbles: true, 36 | cancelable: true, 37 | view: window, 38 | detail: 0, 39 | screenX: 0, 40 | screenY: 0, 41 | clientX: 0, 42 | clientY: 0, 43 | ctrlKey: false, 44 | altKey: false, 45 | shiftKey: false, 46 | metaKey: false, 47 | button: 0 48 | }; 49 | 50 | // Methods 51 | $.fire.prototype = { 52 | create: function( opts ){ 53 | switch ( this.type ){ 54 | case "mousemove": 55 | opts.cancelable = false; 56 | case "mousedown": 57 | case "mouseup": 58 | case "mouseover": 59 | case "mouseout": 60 | case "click": 61 | case "dblclick": 62 | case "touchstart": 63 | case "touchmove": 64 | case "touchend": 65 | return this.mouse( opts ); 66 | case "keyup": 67 | case "keypress": 68 | case "keydown": 69 | return this.key( opts ); 70 | default: 71 | return this.event( opts ); 72 | } 73 | }, 74 | event: function( opts ){ 75 | var event; 76 | if ( document.createEvent ){ 77 | event = document.createEvent("HTMLEvents"); 78 | event.initEvent( 79 | this.type, 80 | opts.bubbles, 81 | opts.cancelable 82 | ); 83 | $.extend( event, { 84 | view: opts.view, 85 | detail: opts.detail, 86 | screenX: opts.screenX, 87 | screenY: opts.screenY, 88 | clientX: opts.clientX, 89 | clientY: opts.clientY, 90 | ctrlKey: opts.ctrlKey, 91 | altKey: opts.altKey, 92 | shiftKey: opts.shiftKey, 93 | metaKey: opts.metaKey, 94 | keyCode: opts.keyCode, 95 | charCode: opts.charCode, 96 | button: opts.button 97 | }); 98 | } 99 | else if ( document.createEventObject ) { 100 | event = $.extend( document.createEventObject(), opts ); 101 | } 102 | return event; 103 | }, 104 | mouse: function( opts ){ 105 | var event; 106 | if ( document.createEvent ){ 107 | event = document.createEvent("MouseEvents"); 108 | event.initMouseEvent( 109 | this.type, 110 | opts.bubbles, 111 | opts.cancelable, 112 | opts.view, 113 | opts.detail, 114 | opts.screenX, 115 | opts.screenY, 116 | opts.clientX, 117 | opts.clientY, 118 | opts.ctrlKey, 119 | opts.altKey, 120 | opts.shiftKey, 121 | opts.metaKey, 122 | opts.button, 123 | $( opts.relatedTarget )[0] || document.body.parentNode 124 | ); 125 | } 126 | else if ( document.createEventObject ) { 127 | event = this.event(); 128 | event.button = { 0:1, 1:4, 2:2 }[ event.button ] || event.button; 129 | } 130 | return event; 131 | }, 132 | key: function( opts ){ 133 | var event; 134 | if ( document.createEvent ) { 135 | try { 136 | event = document.createEvent("KeyEvents"); 137 | event.initKeyEvent( 138 | this.type, 139 | opts.bubbles, 140 | opts.cancelable, 141 | opts.view, 142 | opts.ctrlKey, 143 | opts.altKey, 144 | opts.shiftKey, 145 | opts.metaKey, 146 | opts.keyCode, 147 | opts.charCode 148 | ); 149 | } 150 | catch ( err ){ 151 | event = this.event( opts ); 152 | } 153 | } 154 | else if ( document.createEventObject ){ 155 | event = this.event( opts ); 156 | } 157 | if ( $.browser.msie || $.browser.opera ){ 158 | event.keyCode = opts.charCode > 0 ? opts.charCode : opts.keyCode; 159 | event.charCode = undefined; 160 | } 161 | return event; 162 | }, 163 | dispatch: function(){ 164 | if ( this.element.dispatchEvent ) 165 | this.element.dispatchEvent( this.event ); 166 | else if ( this.element.fireEvent ) 167 | this.element.fireEvent( 'on'+this.type, this.event ); 168 | } 169 | }; 170 | 171 | })( jQuery, window ); -------------------------------------------------------------------------------- /event.drag/test/handlers.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Event Handlers"); 4 | 5 | // a simple re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | obj.$div = $('
          ') 9 | .css({ 10 | position: 'absolute', 11 | top: 0, 12 | left: 0, 13 | height: 100, 14 | width: 100 15 | }) 16 | .appendTo( document.body ) 17 | .bind("draginit dragstart drag dragend click", opts || {}, function( event ){ 18 | obj[ event.type ] += 1; 19 | if ( obj.extra[ event.type ] ) 20 | obj.extra[ event.type ].apply( this, arguments ); 21 | return obj.returned[ event.type ]; 22 | }); 23 | 24 | $.extend( obj, { draginit:0, dragstart:0, drag:0, dragend:0, click:0 }); 25 | obj.extra = {}; 26 | obj.returned = {}; 27 | }, 28 | mouse: function(){ 29 | var start = { 30 | pageX: Math.round( Math.random() * 90 ) + 5, 31 | pageY: Math.round( Math.random() * 90 ) + 5 32 | }, 33 | end = { 34 | pageX: Math.round( Math.random() * 90 ) + start.pageX, 35 | pageY: Math.round( Math.random() * 90 ) + start.pageY 36 | }; 37 | // simulate a complete mouse drag 38 | obj.$div 39 | .fire("mousedown", start ) 40 | .fire("mousemove", end ) 41 | .fire("mouseup", end ) 42 | .fire("click", end ); 43 | }, 44 | done: function( ms ){ 45 | obj.$div.remove(); 46 | start(); 47 | } 48 | }; 49 | 50 | // test DRAGINIT FALSE 51 | asyncTest('"draginit" return false',function(){ 52 | expect( 5 ); 53 | // test prep 54 | obj.init(); 55 | obj.returned['draginit'] = false; 56 | // simulate a mouse drag 57 | obj.mouse(); 58 | // check counts 59 | equals( obj.draginit, 1, "draginit fired"); 60 | equals( obj.dragstart, 0, "dragstart did not fire"); 61 | equals( obj.drag, 0, "drag did not fire"); 62 | equals( obj.dragend, 0, "dragend did not fire"); 63 | equals( obj.click, 1, "click fired"); 64 | // continue 65 | obj.done(); 66 | }); 67 | 68 | asyncTest('"dragstart" return false',function(){ 69 | expect( 5 ); 70 | // test prep 71 | obj.init(); 72 | obj.returned['dragstart'] = false; 73 | // simulate a mouse drag 74 | obj.mouse(); 75 | // check counts 76 | equals( obj.draginit, 1, "draginit fired"); 77 | equals( obj.dragstart, 1, "dragstart fired"); 78 | equals( obj.drag, 0, "drag did not fire"); 79 | equals( obj.dragend, 0, "dragend did not fire"); 80 | equals( obj.click, 1, "click fired"); 81 | // continue 82 | obj.done(); 83 | }); 84 | 85 | asyncTest('"drag" return false',function(){ 86 | expect( 5 ); 87 | // test prep 88 | obj.init(); 89 | obj.returned['drag'] = false; 90 | // simulate a mouse drag 91 | obj.mouse(); 92 | // check ocunts 93 | equals( obj.draginit, 1, "draginit fired"); 94 | equals( obj.dragstart, 1, "dragstart fired"); 95 | equals( obj.drag, 1, "drag fired"); 96 | equals( obj.dragend, 1, "dragend fired"); 97 | equals( obj.click, 0, "click did not fire"); 98 | // continue 99 | obj.done(); 100 | }); 101 | 102 | asyncTest('"draginit" return new element',function(){ 103 | expect( 8 ); 104 | // test prep 105 | obj.init(); 106 | var $clone = obj.returned['draginit'] = obj.$div.clone( true ); 107 | obj.extra['dragstart'] = obj.extra['drag'] = obj.extra['dragend'] = function( ev, dd ){ 108 | ok( dd.drag === $clone[0], ev.type +' target element' ); 109 | }; 110 | // simulate a mouse drag 111 | obj.mouse(); 112 | // check counts 113 | equals( obj.draginit, 1, "draginit fired"); 114 | equals( obj.dragstart, 1, "dragstart fired"); 115 | equals( obj.drag, 1, "drag fired"); 116 | equals( obj.dragend, 1, "dragend fired"); 117 | equals( obj.click, 0, "click did not fire"); 118 | // continue 119 | obj.done(); 120 | }); 121 | 122 | asyncTest('"draginit" return multiple elements',function(){ 123 | expect( 5 ); 124 | // test prep 125 | obj.init(); 126 | obj.returned['draginit'] = obj.$div.clone( true ).add( obj.$div ); 127 | // simulate a mouse drag 128 | obj.mouse(); 129 | // check counts 130 | equals( obj.draginit, 1, "draginit fired once"); 131 | equals( obj.dragstart, 2, "dragstart fired twice"); 132 | equals( obj.drag, 2, "drag fired twice"); 133 | equals( obj.dragend, 2, "dragend fired twice"); 134 | equals( obj.click, 0, "click did not fire"); 135 | // continue 136 | obj.done(); 137 | }); 138 | 139 | 140 | asyncTest('"dragstart" return proxy element',function(){ 141 | expect( 7 ); 142 | // test prep 143 | obj.init(); 144 | var $proxy = obj.returned['dragstart'] = obj.$div.clone().addClass('proxy'); 145 | obj.extra['drag'] = obj.extra['dragend'] = function( ev, dd ){ 146 | ok( dd.proxy === $proxy[0], ev.type +' proxy element' ); 147 | }; 148 | // simulate a mouse drag 149 | obj.mouse(); 150 | // check counts 151 | equals( obj.draginit, 1, "draginit"); 152 | equals( obj.dragstart, 1, "dragstart"); 153 | equals( obj.drag, 1, "drag"); 154 | equals( obj.dragend, 1, "dragend"); 155 | equals( obj.click, 0, "click did not fire"); 156 | // continue 157 | obj.done(); 158 | }); 159 | 160 | })(); -------------------------------------------------------------------------------- /event.drop/test/tolerance.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Tolerance Mode"); 4 | 5 | // re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | // the drop element 9 | obj.$drop = $('
          ') 10 | .css({ 11 | position: 'absolute', 12 | top: 200, 13 | left: 200, 14 | height: 100, 15 | width: 100 16 | }) 17 | .appendTo( document.body ) 18 | .bind("dropinit",function( event ){ 19 | if ( obj.multidrop ) 20 | return $( this ) 21 | .clone( true ) 22 | .addClass('clone') 23 | .appendTo( document.body ) 24 | .add( this ); 25 | }) 26 | .bind("drop",function( event ){ 27 | obj.count += 1; 28 | }); 29 | // the drag element 30 | obj.$drag = $('
          ') 31 | .css({ 32 | position: 'absolute', 33 | top: 100, 34 | left: 100, 35 | height: 100, 36 | width: 100 37 | }) 38 | .appendTo( document.body ) 39 | .bind("draginit", function( event ){ 40 | if ( obj.multidrag ) 41 | return $( this ) 42 | .clone( true ) 43 | .addClass('clone') 44 | .appendTo( document.body ) 45 | .add( this ); 46 | }) 47 | .bind("dragstart",function( ev, dd ){ 48 | if ( obj.proxy ) 49 | return $( this ).clone() 50 | .addClass('clone') 51 | .appendTo( document.body ); 52 | }) 53 | .bind("drag",function( ev, dd ){ 54 | if ( obj.move ) 55 | $( dd.proxy ).css({ 56 | top: dd.offsetY, 57 | left: dd.offsetX 58 | }); 59 | }) 60 | .bind("dragend",function( ev, dd ){ 61 | var $div = $( this ).css({ 62 | top: 100, 63 | left: 100 64 | }); 65 | $( document.body ).find('.clone').remove(); 66 | }); 67 | // reset test vars 68 | obj.count = 0; 69 | obj.move = obj.proxy = obj.multidrag = obj.multidrop = null; 70 | }, 71 | done: function(){ 72 | obj.$drag.remove(); 73 | obj.$drop.remove(); 74 | start(); 75 | } 76 | }; 77 | 78 | // async iterator 79 | function asyncEach( obj, func, after ){ 80 | // local refs 81 | var arr = [], i = 0, len; 82 | // translate into a secondary array 83 | $.each( obj, function( index, value ){ 84 | len = arr.push({ that:this, index:index, value:value }); 85 | }); 86 | function next(){ 87 | var data = arr[ i++ ], ret; 88 | if ( i <= len ){ 89 | if ( data ) 90 | ret = func.call( data.that, data.index, data.value, next ); 91 | if ( ret === false ) 92 | done(); 93 | } 94 | else done(); 95 | }; 96 | function done(){ 97 | if ( after ) 98 | after(); 99 | }; 100 | next(); 101 | } 102 | 103 | // test each mode... 104 | $.each({ 105 | 'mouse':{ 106 | 'overlap':[0,0,0,0,0], 107 | 'middle':[0,0,0,0,0], 108 | 'fit':[0,0,0,0,0], 109 | 'mouse':[1,1,1,2,4], 110 | 'away':[0,0,0,0,0] 111 | }, 112 | 'overlap':{ 113 | 'overlap':[0,1,1,2,4], 114 | 'middle':[0,1,1,2,4], 115 | 'fit':[0,1,1,2,4], 116 | 'mouse':[0,0,0,0,0], 117 | 'away':[0,0,0,0,0] 118 | }, 119 | 'middle':{ 120 | 'overlap':[0,0,0,0,0], 121 | 'middle':[0,1,1,2,4], 122 | 'fit':[0,1,1,2,4], 123 | 'mouse':[0,0,0,0,0], 124 | 'away':[0,0,0,0,0] 125 | }, 126 | 'fit':{ 127 | 'overlap':[0,0,0,0,0], 128 | 'middle':[0,0,0,0,0], 129 | 'fit':[0,1,1,2,4], 130 | 'mouse':[0,0,0,0,0], 131 | 'away':[0,0,0,0,0] 132 | }, 133 | 'intersect':{ 134 | 'overlap':[0,1,1,2,4], 135 | 'middle':[0,1,1,2,4], 136 | 'fit':[0,1,1,2,4], 137 | 'mouse':[1,1,1,2,4], 138 | 'away':[0,0,0,0,0] 139 | } 140 | }, function( mode, expected ){ 141 | 142 | // test each mode 143 | asyncTest('"'+ mode +'"',function(){ 144 | 145 | expect( 25 ); 146 | 147 | // test prep 148 | obj.init(); 149 | $.drop({ 150 | mode:mode, 151 | multi:true 152 | }); 153 | // drag to each position 154 | asyncEach({ 155 | 'overlap':{ pageX:33, pageY:33 }, 156 | 'middle':{ pageX:66, pageY:66 }, 157 | 'fit':{ pageX:100, pageY:100 }, 158 | 'mouse':{ pageX:250, pageY:250 }, 159 | 'away':{ pageX:-1, pageY:-1 } 160 | }, function( where, coord, next ){ 161 | // execute interaction variants 162 | asyncEach([ 163 | 'dropped '+ where +' (no motion)', 164 | 'dropped '+ where +' (drag motion)', 165 | 'dropped '+ where +' (proxy motion)', 166 | 'dropped '+ where +' (multi drag)', 167 | 'dropped '+ where +' (multi drop)' 168 | ], function( i, msg, next ){ 169 | // set-up 170 | obj.count = 0; 171 | obj.move = ( i > 0 ); 172 | obj.proxy = ( i > 1 ); 173 | obj.multidrag = ( i > 2 ); 174 | obj.multidrop = ( i > 3 ); 175 | // simulate a partial drag 176 | obj.$drag 177 | .fire("mousedown",{ pageX:0, pageY:0 }) 178 | .fire("mousemove", coord ) 179 | .fire("mouseup", coord ) 180 | .fire("click", coord ); 181 | equals( obj.count, expected[where][i], msg ); 182 | next(); 183 | }, next ); 184 | }, obj.done ); 185 | }); 186 | 187 | }); 188 | 189 | })(); -------------------------------------------------------------------------------- /event.drag/test/interaction.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Mouse Interaction"); 4 | 5 | // a simple re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | obj.$div = $('
          ') 9 | .css({ 10 | position: 'absolute', 11 | top: 0, 12 | left: 0, 13 | height: 100, 14 | width: 100 15 | }) 16 | .append('
          ') 17 | .appendTo( document.body ) 18 | .bind("draginit dragstart drag dragend click", opts || {}, function( event ){ 19 | obj[ event.type ] += 1; 20 | }); 21 | $.extend( obj, { draginit:0, dragstart:0, drag:0, dragend:0, click:0 }); 22 | }, 23 | done: function(){ 24 | obj.$div.remove(); 25 | start(); 26 | } 27 | }; 28 | 29 | asyncTest("default",function(){ 30 | expect( 5 ); 31 | // prep DEFAULT interaction 32 | obj.init(); 33 | // simulate DEFAULT interaction 34 | obj.$div 35 | .fire("mousedown",{ pageX:50, pageY:50 }) 36 | .fire("mousemove",{ pageX:51, pageY:51 }) 37 | .fire("mouseup",{ pageX:51, pageY:51 }) 38 | .fire("click"); 39 | // inspect results 40 | equals( obj.draginit, 1, "draginit"); 41 | equals( obj.dragstart, 1, "dragstart"); 42 | equals( obj.drag, 1, "drag"); 43 | equals( obj.dragend, 1, "dragend"); 44 | equals( obj.click, 0, "click"); 45 | // clean-up interaction 46 | obj.done(); 47 | }); 48 | 49 | asyncTest('"not" option',function(){ 50 | expect( 10 ); 51 | // prep interaction 52 | obj.init({ not:'.child' }); 53 | // simulate NOT interaction 54 | obj.$div.children() 55 | .fire("mousedown",{ pageX:50, pageY:50 }) 56 | .fire("mousemove",{ pageX:51, pageY:51 }) 57 | .fire("mouseup",{ pageX:51, pageY:51 }) 58 | .fire("click"); 59 | // inspect results 60 | equals( obj.draginit, 0, "draginit"); 61 | equals( obj.dragstart, 0, "dragstart"); 62 | equals( obj.drag, 0, "drag"); 63 | equals( obj.dragend, 0, "dragend"); 64 | equals( obj.click, 1, "click"); 65 | // simlate NON NOT interaction 66 | obj.$div 67 | .fire("mousedown",{ pageX:50, pageY:50 }) 68 | .fire("mousemove",{ pageX:51, pageY:51 }) 69 | .fire("mouseup",{ pageX:51, pageY:51 }) 70 | .fire("click"); 71 | // inspect results 72 | equals( obj.draginit, 1, "draginit"); 73 | equals( obj.dragstart, 1, "dragstart"); 74 | equals( obj.drag, 1, "drag"); 75 | equals( obj.dragend, 1, "dragend"); 76 | equals( obj.click, 1, "click"); 77 | // clean-up interaction 78 | obj.done(); 79 | }); 80 | 81 | asyncTest('"handle" option',function(){ 82 | expect( 10 ); 83 | // prep interaction 84 | obj.init({ handle:'.child' }); 85 | // simulate HANDLE interaction 86 | obj.$div.children() 87 | .fire("mousedown",{ pageX:50, pageY:50 }) 88 | .fire("mousemove",{ pageX:51, pageY:51 }) 89 | .fire("mouseup",{ pageX:51, pageY:51 }) 90 | .fire("click"); 91 | // inspect results 92 | equals( obj.draginit, 1, "draginit"); 93 | equals( obj.dragstart, 1, "dragstart"); 94 | equals( obj.drag, 1, "drag"); 95 | equals( obj.dragend, 1, "dragend"); 96 | equals( obj.click, 0, "click"); 97 | // simulate NON HANDLE interaction 98 | obj.$div 99 | .fire("mousedown",{ pageX:50, pageY:50 }) 100 | .fire("mousemove",{ pageX:51, pageY:51 }) 101 | .fire("mouseup",{ pageX:51, pageY:51 }) 102 | .fire("click"); 103 | // inspect results 104 | equals( obj.draginit, 1, "draginit"); 105 | equals( obj.dragstart, 1, "dragstart"); 106 | equals( obj.drag, 1, "drag"); 107 | equals( obj.dragend, 1, "dragend"); 108 | equals( obj.click, 1, "click"); 109 | // clean-up interaction 110 | obj.done(); 111 | }); 112 | 113 | asyncTest('"which" option',function(){ 114 | expect( 10 ); 115 | // prep interaction 116 | obj.init({ which:3 }); 117 | // simulate WHICH interaction 118 | obj.$div 119 | .fire("mousedown",{ pageX:50, pageY:50, button:2 }) 120 | .fire("mousemove",{ pageX:51, pageY:51 }) 121 | .fire("mouseup",{ pageX:51, pageY:51 }) 122 | .fire("click"); 123 | // inspect results 124 | equals( obj.draginit, 1, "draginit"); 125 | equals( obj.dragstart, 1, "dragstart"); 126 | equals( obj.drag, 1, "drag"); 127 | equals( obj.dragend, 1, "dragend"); 128 | equals( obj.click, 0, "click"); 129 | // simulate NON WHICH interaction 130 | obj.$div 131 | .fire("mousedown",{ pageX:50, pageY:50 }) 132 | .fire("mousemove",{ pageX:51, pageY:51 }) 133 | .fire("mouseup",{ pageX:51, pageY:51 }) 134 | .fire("click"); 135 | // inspect results 136 | equals( obj.draginit, 1, "draginit"); 137 | equals( obj.dragstart, 1, "dragstart"); 138 | equals( obj.drag, 1, "drag"); 139 | equals( obj.dragend, 1, "dragend"); 140 | equals( obj.click, 1, "click"); 141 | // clean-up interaction 142 | obj.done(); 143 | }); 144 | 145 | asyncTest('"distance" option',function(){ 146 | expect( 10 ); 147 | // prep interaction 148 | obj.init({ distance:5 }); 149 | // simulate NON DISTANCE interaction 150 | obj.$div 151 | .fire("mousedown",{ pageX:50, pageY:50 }) 152 | .fire("mousemove",{ pageX:51, pageY:51 }) 153 | .fire("mouseup",{ pageX:51, pageY:51 }) 154 | .fire("click"); 155 | // inspect results 156 | equals( obj.draginit, 1, "draginit"); 157 | equals( obj.dragstart, 0, "dragstart"); 158 | equals( obj.drag, 0, "drag"); 159 | equals( obj.dragend, 0, "dragend"); 160 | equals( obj.click, 1, "click"); 161 | // simulate DISTANCE interaction 162 | obj.$div 163 | .fire("mousedown",{ pageX:50, pageY:50 }) 164 | .fire("mousemove",{ pageX:53, pageY:54 }) 165 | .fire("mouseup",{ pageX:53, pageY:54 }) 166 | .fire("click"); 167 | // inspect results 168 | equals( obj.draginit, 2, "draginit"); 169 | equals( obj.dragstart, 1, "dragstart"); 170 | equals( obj.drag, 1, "drag"); 171 | equals( obj.dragend, 1, "dragend"); 172 | equals( obj.click, 1, "click"); 173 | // clean-up interaction 174 | obj.done(); 175 | }); 176 | 177 | 178 | asyncTest('"click" option',function(){ 179 | expect( 5 ); 180 | // prep interaction 181 | obj.init({ click:true }); 182 | // simulate CLICK interaction 183 | obj.$div 184 | .fire("mousedown",{ pageX:50, pageY:50 }) 185 | .fire("mousemove",{ pageX:51, pageY:51 }) 186 | .fire("mouseup",{ pageX:51, pageY:51 }) 187 | .fire("click"); 188 | // inspect results 189 | equals( obj.draginit, 1, "draginit"); 190 | equals( obj.dragstart, 1, "dragstart"); 191 | equals( obj.drag, 1, "drag"); 192 | equals( obj.dragend, 1, "dragend"); 193 | equals( obj.click, 1, "click"); 194 | // clean-up interaction 195 | obj.done(); 196 | }); 197 | 198 | })(); -------------------------------------------------------------------------------- /event.drag/test/touch.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Touch Interaction"); 4 | 5 | if ( !document.createEvent ){ 6 | test("Touch Simulation Not Supported",function(){ 7 | ok( true, 'This browser does not support "document.createEvent" and cannot simulate touch events.'); 8 | }); 9 | return; 10 | } 11 | 12 | // a simple re-usable test harness object 13 | var obj = { 14 | init: function( opts ){ 15 | obj.$div = $('
          ') 16 | .css({ 17 | position: 'absolute', 18 | top: 0, 19 | left: 0, 20 | height: 100, 21 | width: 100 22 | }) 23 | .append('
          ') 24 | .appendTo( document.body ) 25 | .bind("draginit dragstart drag dragend click", opts || {}, function( event ){ 26 | obj[ event.type ] += 1; 27 | }); 28 | $.extend( obj, { draginit:0, dragstart:0, drag:0, dragend:0, click:0 }); 29 | }, 30 | done: function(){ 31 | obj.$div.remove(); 32 | start(); 33 | } 34 | }; 35 | 36 | asyncTest("default",function(){ 37 | expect( 5 ); 38 | // prep DEFAULT interaction 39 | obj.init(); 40 | // simulate DEFAULT interaction 41 | obj.$div 42 | .fire("touchstart",{ pageX:50, pageY:50 }) 43 | .fire("touchmove",{ pageX:51, pageY:51 }) 44 | .fire("touchend",{ pageX:51, pageY:51 }) 45 | .fire("click"); 46 | // inspect results 47 | equals( obj.draginit, 1, "draginit"); 48 | equals( obj.dragstart, 1, "dragstart"); 49 | equals( obj.drag, 1, "drag"); 50 | equals( obj.dragend, 1, "dragend"); 51 | equals( obj.click, 0, "click"); 52 | // clean-up interaction 53 | obj.done(); 54 | }); 55 | 56 | asyncTest('"not" option',function(){ 57 | expect( 10 ); 58 | // prep interaction 59 | obj.init({ not:'.child' }); 60 | // simulate NOT interaction 61 | obj.$div.children() 62 | .fire("touchstart",{ pageX:50, pageY:50 }) 63 | .fire("touchmove",{ pageX:51, pageY:51 }) 64 | .fire("touchend",{ pageX:51, pageY:51 }) 65 | .fire("click"); 66 | // inspect results 67 | equals( obj.draginit, 0, "draginit"); 68 | equals( obj.dragstart, 0, "dragstart"); 69 | equals( obj.drag, 0, "drag"); 70 | equals( obj.dragend, 0, "dragend"); 71 | equals( obj.click, 1, "click"); 72 | // simlate NON NOT interaction 73 | obj.$div 74 | .fire("touchstart",{ pageX:50, pageY:50 }) 75 | .fire("touchmove",{ pageX:51, pageY:51 }) 76 | .fire("touchend",{ pageX:51, pageY:51 }) 77 | .fire("click"); 78 | // inspect results 79 | equals( obj.draginit, 1, "draginit"); 80 | equals( obj.dragstart, 1, "dragstart"); 81 | equals( obj.drag, 1, "drag"); 82 | equals( obj.dragend, 1, "dragend"); 83 | equals( obj.click, 1, "click"); 84 | // clean-up interaction 85 | obj.done(); 86 | }); 87 | 88 | asyncTest('"handle" option',function(){ 89 | expect( 10 ); 90 | // prep interaction 91 | obj.init({ handle:'.child' }); 92 | // simulate HANDLE interaction 93 | obj.$div.children() 94 | .fire("touchstart",{ pageX:50, pageY:50 }) 95 | .fire("touchmove",{ pageX:51, pageY:51 }) 96 | .fire("touchend",{ pageX:51, pageY:51 }) 97 | .fire("click"); 98 | // inspect results 99 | equals( obj.draginit, 1, "draginit"); 100 | equals( obj.dragstart, 1, "dragstart"); 101 | equals( obj.drag, 1, "drag"); 102 | equals( obj.dragend, 1, "dragend"); 103 | equals( obj.click, 0, "click"); 104 | // simulate NON HANDLE interaction 105 | obj.$div 106 | .fire("touchstart",{ pageX:50, pageY:50 }) 107 | .fire("touchmove",{ pageX:51, pageY:51 }) 108 | .fire("touchend",{ pageX:51, pageY:51 }) 109 | .fire("click"); 110 | // inspect results 111 | equals( obj.draginit, 1, "draginit"); 112 | equals( obj.dragstart, 1, "dragstart"); 113 | equals( obj.drag, 1, "drag"); 114 | equals( obj.dragend, 1, "dragend"); 115 | equals( obj.click, 1, "click"); 116 | // clean-up interaction 117 | obj.done(); 118 | }); 119 | 120 | asyncTest('"which" option',function(){ 121 | expect( 11 ); 122 | // prep interaction 123 | obj.init({ which:0 }); 124 | // simulate WHICH interaction 125 | obj.$div 126 | .fire("touchstart",{ pageX:50, pageY:50, button:5 }) 127 | .fire("touchmove",{ pageX:51, pageY:51 }) 128 | .fire("touchend",{ pageX:51, pageY:51 }) 129 | .fire("click"); 130 | // inspect results 131 | equals( obj.draginit, 1, "draginit"); 132 | equals( obj.dragstart, 1, "dragstart"); 133 | equals( obj.drag, 1, "drag"); 134 | equals( obj.dragend, 1, "dragend"); 135 | equals( obj.click, 0, "click"); 136 | ok( true, '"which" not supported with touch events...'); 137 | // simulate NON WHICH interaction 138 | obj.$div 139 | .fire("touchstart",{ pageX:50, pageY:50 }) 140 | .fire("touchmove",{ pageX:51, pageY:51 }) 141 | .fire("touchend",{ pageX:51, pageY:51 }) 142 | .fire("click"); 143 | // inspect results 144 | equals( obj.draginit, 2, "draginit"); 145 | equals( obj.dragstart, 2, "dragstart"); 146 | equals( obj.drag, 2, "drag"); 147 | equals( obj.dragend, 2, "dragend"); 148 | equals( obj.click, 0, "click"); 149 | // clean-up interaction 150 | obj.done(); 151 | }); 152 | 153 | asyncTest('"distance" option',function(){ 154 | expect( 10 ); 155 | // prep interaction 156 | obj.init({ distance:5 }); 157 | // simulate NON DISTANCE interaction 158 | obj.$div 159 | .fire("touchstart",{ pageX:50, pageY:50 }) 160 | .fire("touchmove",{ pageX:51, pageY:51 }) 161 | .fire("touchend",{ pageX:51, pageY:51 }) 162 | .fire("click"); 163 | // inspect results 164 | equals( obj.draginit, 1, "draginit"); 165 | equals( obj.dragstart, 0, "dragstart"); 166 | equals( obj.drag, 0, "drag"); 167 | equals( obj.dragend, 0, "dragend"); 168 | equals( obj.click, 1, "click"); 169 | // simulate DISTANCE interaction 170 | obj.$div 171 | .fire("touchstart",{ pageX:50, pageY:50 }) 172 | .fire("touchmove",{ pageX:53, pageY:54 }) 173 | .fire("touchend",{ pageX:53, pageY:54 }) 174 | .fire("click"); 175 | // inspect results 176 | equals( obj.draginit, 2, "draginit"); 177 | equals( obj.dragstart, 1, "dragstart"); 178 | equals( obj.drag, 1, "drag"); 179 | equals( obj.dragend, 1, "dragend"); 180 | equals( obj.click, 1, "click"); 181 | // clean-up interaction 182 | obj.done(); 183 | }); 184 | 185 | 186 | asyncTest('"click" option',function(){ 187 | expect( 5 ); 188 | // prep interaction 189 | obj.init({ click:true }); 190 | // simulate CLICK interaction 191 | obj.$div 192 | .fire("touchstart",{ pageX:50, pageY:50 }) 193 | .fire("touchmove",{ pageX:51, pageY:51 }) 194 | .fire("touchend",{ pageX:51, pageY:51 }) 195 | .fire("click"); 196 | // inspect results 197 | equals( obj.draginit, 1, "draginit"); 198 | equals( obj.dragstart, 1, "dragstart"); 199 | equals( obj.drag, 1, "drag"); 200 | equals( obj.dragend, 1, "dragend"); 201 | equals( obj.click, 1, "click"); 202 | // clean-up interaction 203 | obj.done(); 204 | }); 205 | 206 | })(); -------------------------------------------------------------------------------- /event.linger/test/interaction.js: -------------------------------------------------------------------------------- 1 | ;(function(){ 2 | 3 | module("Interaction"); 4 | 5 | // a simple re-usable test harness object 6 | var obj = { 7 | init: function( opts ){ 8 | obj.$div = $('
          ') 9 | .css({ 10 | position: 'absolute', 11 | top: 0, 12 | left: 0, 13 | height: 100, 14 | width: 100 15 | }) 16 | .append('
          ') 17 | .appendTo( document.body ) 18 | .bind("lingerstart linger lingerend", opts || {}, function( event ){ 19 | obj.counts[ event.type ] += 1; 20 | }); 21 | obj.counts = { lingerstart:0, linger:0, lingerend:0 }; 22 | }, 23 | done: function(){ 24 | obj.$div.remove(); 25 | start(); 26 | } 27 | }; 28 | 29 | asyncTest("defaults",function(){ 30 | 31 | expect( 3 ); 32 | 33 | // prep interaction 34 | obj.init(); 35 | // simulate interaction 36 | obj.$div 37 | .fire("mouseover",{ pageX:50, pageY:50 }) 38 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 39 | // wait 100 ms (default delay) 40 | setTimeout(function(){ 41 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 42 | // wait 400 ms (default persist) 43 | setTimeout(function(){ 44 | // inspect results 45 | equals( obj.counts.lingerstart, 1, "lingerstart"); 46 | equals( obj.counts.linger, 1, "linger"); 47 | equals( obj.counts.lingerend, 1, "lingerend"); 48 | obj.done(); 49 | }, 400 ); 50 | }, 100 ); 51 | }); 52 | 53 | asyncTest("speed (miss)",function(){ 54 | 55 | expect( 3 ); 56 | 57 | // prep interaction 58 | obj.init({ speed:200 }); 59 | // simulate interaction 60 | obj.$div 61 | .fire("mouseover",{ pageX:50, pageY:50 }) 62 | .fire("mousemove",{ pageX:63, pageY:67 }); // move > 20 pixels (custom speed) 63 | // wait 100 ms (default delay) 64 | setTimeout(function(){ 65 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 66 | // wait 400 ms (default persist) 67 | setTimeout(function(){ 68 | // inspect results 69 | equals( obj.counts.lingerstart, 1, "lingerstart"); 70 | equals( obj.counts.linger, 0, "linger"); 71 | equals( obj.counts.lingerend, 0, "lingerend"); 72 | obj.done(); 73 | }, 400 ); 74 | }, 100 ); 75 | }); 76 | 77 | asyncTest("speed (hit)",function(){ 78 | 79 | expect( 3 ); 80 | 81 | // prep interaction 82 | obj.init({ speed:200 }); 83 | // simulate interaction 84 | obj.$div 85 | .fire("mouseover",{ pageX:50, pageY:50 }) 86 | .fire("mousemove",{ pageX:62, pageY:66 }); // move <= 20 pixels (custom speed) 87 | // wait 100 ms (default delay) 88 | setTimeout(function(){ 89 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 90 | // wait 400 ms (default persist) 91 | setTimeout(function(){ 92 | // inspect results 93 | equals( obj.counts.lingerstart, 1, "lingerstart"); 94 | equals( obj.counts.linger, 1, "linger"); 95 | equals( obj.counts.lingerend, 1, "lingerend"); 96 | obj.done(); 97 | }, 400 ); 98 | }, 100 ); 99 | }); 100 | 101 | asyncTest("delay (miss)",function(){ 102 | 103 | expect( 3 ); 104 | 105 | // prep interaction 106 | obj.init({ delay:200 }); 107 | // simulate interaction 108 | obj.$div 109 | .fire("mouseover",{ pageX:50, pageY:50 }) 110 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 111 | // wait < 200 ms (custom delay) 112 | setTimeout(function(){ 113 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 114 | // wait 400 ms (default persist) 115 | setTimeout(function(){ 116 | // inspect results 117 | equals( obj.counts.lingerstart, 1, "lingerstart"); 118 | equals( obj.counts.linger, 0, "linger"); 119 | equals( obj.counts.lingerend, 0, "lingerend"); 120 | obj.done(); 121 | }, 400 ); 122 | }, 100 ); 123 | }); 124 | 125 | asyncTest("delay (hit)",function(){ 126 | 127 | expect( 3 ); 128 | 129 | // prep interaction 130 | obj.init({ delay:200 }); 131 | // simulate interaction 132 | obj.$div 133 | .fire("mouseover",{ pageX:50, pageY:50 }) 134 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 135 | // wait 200 ms (custom delay) 136 | setTimeout(function(){ 137 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 138 | // wait 400 ms (default persist) 139 | setTimeout(function(){ 140 | // inspect results 141 | equals( obj.counts.lingerstart, 1, "lingerstart"); 142 | equals( obj.counts.linger, 1, "linger"); 143 | equals( obj.counts.lingerend, 1, "lingerend"); 144 | obj.done(); 145 | }, 400 ); 146 | }, 200 ); 147 | }); 148 | 149 | asyncTest("persist (miss)",function(){ 150 | 151 | expect( 3 ); 152 | 153 | // prep interaction 154 | obj.init({ persist:200 }); 155 | // simulate interaction 156 | obj.$div 157 | .fire("mouseover",{ pageX:50, pageY:50 }) 158 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 159 | // wait 100 ms (default delay) 160 | setTimeout(function(){ 161 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 162 | // wait < 200 ms (custom persist) 163 | setTimeout(function(){ 164 | // inspect results 165 | equals( obj.counts.lingerstart, 1, "lingerstart"); 166 | equals( obj.counts.linger, 1, "linger"); 167 | equals( obj.counts.lingerend, 0, "lingerend"); 168 | setTimeout(function(){ 169 | obj.done(); 170 | }, 100 ); 171 | }, 100 ); 172 | }, 100 ); 173 | }); 174 | 175 | asyncTest("persist (hit)",function(){ 176 | 177 | expect( 3 ); 178 | 179 | // prep interaction 180 | obj.init({ persist:200 }); 181 | // simulate interaction 182 | obj.$div 183 | .fire("mouseover",{ pageX:50, pageY:50 }) 184 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 185 | // wait 100 ms (default delay) 186 | setTimeout(function(){ 187 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }); 188 | // wait 200 ms (custom persist) 189 | setTimeout(function(){ 190 | // inspect results 191 | equals( obj.counts.lingerstart, 1, "lingerstart"); 192 | equals( obj.counts.linger, 1, "linger"); 193 | equals( obj.counts.lingerend, 1, "lingerend"); 194 | obj.done(); 195 | }, 200 ); 196 | }, 100 ); 197 | 198 | }); 199 | 200 | asyncTest("persist (re-enter)",function(){ 201 | 202 | expect( 3 ); 203 | 204 | // prep interaction 205 | obj.init({ persist:200 }); 206 | // simulate interaction 207 | obj.$div 208 | .fire("mouseover",{ pageX:50, pageY:50 }) 209 | .fire("mousemove",{ pageX:56, pageY:58 }); // move <= 10 pixels (default speed) 210 | // wait 100 ms (default delay) 211 | setTimeout(function(){ 212 | obj.$div.fire("mouseout",{ pageX:51, pageY:51 }) 213 | // wait < 200 ms (custom persist) 214 | setTimeout(function(){ 215 | // re-enter the element 216 | obj.$div.fire("mouseover",{ pageX:50, pageY:50 }); 217 | // wait 200 ms (custom persist) 218 | setTimeout(function(){ 219 | // inspect results 220 | equals( obj.counts.lingerstart, 1, "lingerstart"); 221 | equals( obj.counts.linger, 1, "linger"); 222 | equals( obj.counts.lingerend, 0, "lingerend"); 223 | obj.done(); 224 | }, 200 ); 225 | }, 100 ); 226 | }, 100 ); 227 | 228 | }); 229 | 230 | })(); 231 | 232 | -------------------------------------------------------------------------------- /event.drop/jquery.event.drop.js: -------------------------------------------------------------------------------- 1 | /*! 2 | * jquery.event.drop - v 2.2 3 | * Copyright (c) 2010 Three Dub Media - http://threedubmedia.com 4 | * Open Source MIT License - http://threedubmedia.com/code/license 5 | */ 6 | // Created: 2008-06-04 7 | // Updated: 2012-05-21 8 | // REQUIRES: jquery 1.7.x, event.drag 2.2 9 | 10 | ;(function($){ // secure $ jQuery alias 11 | 12 | // Events: drop, dropstart, dropend 13 | 14 | // add the jquery instance method 15 | $.fn.drop = function( str, arg, opts ){ 16 | // figure out the event type 17 | var type = typeof str == "string" ? str : "", 18 | // figure out the event handler... 19 | fn = $.isFunction( str ) ? str : $.isFunction( arg ) ? arg : null; 20 | // fix the event type 21 | if ( type.indexOf("drop") !== 0 ) 22 | type = "drop"+ type; 23 | // were options passed 24 | opts = ( str == fn ? arg : opts ) || {}; 25 | // trigger or bind event handler 26 | return fn ? this.bind( type, opts, fn ) : this.trigger( type ); 27 | }; 28 | 29 | // DROP MANAGEMENT UTILITY 30 | // returns filtered drop target elements, caches their positions 31 | $.drop = function( opts ){ 32 | opts = opts || {}; 33 | // safely set new options... 34 | drop.multi = opts.multi === true ? Infinity : 35 | opts.multi === false ? 1 : !isNaN( opts.multi ) ? opts.multi : drop.multi; 36 | drop.delay = opts.delay || drop.delay; 37 | drop.tolerance = $.isFunction( opts.tolerance ) ? opts.tolerance : 38 | opts.tolerance === null ? null : drop.tolerance; 39 | drop.mode = opts.mode || drop.mode || 'intersect'; 40 | }; 41 | 42 | // local refs (increase compression) 43 | var $event = $.event, 44 | $special = $event.special, 45 | // configure the drop special event 46 | drop = $.event.special.drop = { 47 | 48 | // these are the default settings 49 | multi: 1, // allow multiple drop winners per dragged element 50 | delay: 20, // async timeout delay 51 | mode: 'overlap', // drop tolerance mode 52 | 53 | // internal cache 54 | targets: [], 55 | 56 | // the key name for stored drop data 57 | datakey: "dropdata", 58 | 59 | // prevent bubbling for better performance 60 | noBubble: true, 61 | 62 | // count bound related events 63 | add: function( obj ){ 64 | // read the interaction data 65 | var data = $.data( this, drop.datakey ); 66 | // count another realted event 67 | data.related += 1; 68 | }, 69 | 70 | // forget unbound related events 71 | remove: function(){ 72 | $.data( this, drop.datakey ).related -= 1; 73 | }, 74 | 75 | // configure the interactions 76 | setup: function(){ 77 | // check for related events 78 | if ( $.data( this, drop.datakey ) ) 79 | return; 80 | // initialize the drop element data 81 | var data = { 82 | related: 0, 83 | active: [], 84 | anyactive: 0, 85 | winner: 0, 86 | location: {} 87 | }; 88 | // store the drop data on the element 89 | $.data( this, drop.datakey, data ); 90 | // store the drop target in internal cache 91 | drop.targets.push( this ); 92 | }, 93 | 94 | // destroy the configure interaction 95 | teardown: function(){ 96 | var data = $.data( this, drop.datakey ) || {}; 97 | // check for related events 98 | if ( data.related ) 99 | return; 100 | // remove the stored data 101 | $.removeData( this, drop.datakey ); 102 | // reference the targeted element 103 | var element = this; 104 | // remove from the internal cache 105 | drop.targets = $.grep( drop.targets, function( target ){ 106 | return ( target !== element ); 107 | }); 108 | }, 109 | 110 | // shared event handler 111 | handler: function( event, dd ){ 112 | // local vars 113 | var results, $targets; 114 | // make sure the right data is available 115 | if ( !dd ) 116 | return; 117 | // handle various events 118 | switch ( event.type ){ 119 | // draginit, from $.event.special.drag 120 | case 'mousedown': // DROPINIT >> 121 | case 'touchstart': // DROPINIT >> 122 | // collect and assign the drop targets 123 | $targets = $( drop.targets ); 124 | if ( typeof dd.drop == "string" ) 125 | $targets = $targets.filter( dd.drop ); 126 | // reset drop data winner properties 127 | $targets.each(function(){ 128 | var data = $.data( this, drop.datakey ); 129 | data.active = []; 130 | data.anyactive = 0; 131 | data.winner = 0; 132 | }); 133 | // set available target elements 134 | dd.droppable = $targets; 135 | // activate drop targets for the initial element being dragged 136 | $special.drag.hijack( event, "dropinit", dd ); 137 | break; 138 | // drag, from $.event.special.drag 139 | case 'mousemove': // TOLERATE >> 140 | case 'touchmove': // TOLERATE >> 141 | drop.event = event; // store the mousemove event 142 | if ( !drop.timer ) 143 | // monitor drop targets 144 | drop.tolerate( dd ); 145 | break; 146 | // dragend, from $.event.special.drag 147 | case 'mouseup': // DROP >> DROPEND >> 148 | case 'touchend': // DROP >> DROPEND >> 149 | drop.timer = clearTimeout( drop.timer ); // delete timer 150 | if ( dd.propagates ){ 151 | $special.drag.hijack( event, "drop", dd ); 152 | $special.drag.hijack( event, "dropend", dd ); 153 | } 154 | break; 155 | 156 | } 157 | }, 158 | 159 | // returns the location positions of an element 160 | locate: function( elem, index ){ 161 | var data = $.data( elem, drop.datakey ), 162 | $elem = $( elem ), 163 | posi = $elem.offset() || {}, 164 | height = $elem.outerHeight(), 165 | width = $elem.outerWidth(), 166 | location = { 167 | elem: elem, 168 | width: width, 169 | height: height, 170 | top: posi.top, 171 | left: posi.left, 172 | right: posi.left + width, 173 | bottom: posi.top + height 174 | }; 175 | // drag elements might not have dropdata 176 | if ( data ){ 177 | data.location = location; 178 | data.index = index; 179 | data.elem = elem; 180 | } 181 | return location; 182 | }, 183 | 184 | // test the location positions of an element against another OR an X,Y coord 185 | contains: function( target, test ){ // target { location } contains test [x,y] or { location } 186 | return ( ( test[0] || test.left ) >= target.left && ( test[0] || test.right ) <= target.right 187 | && ( test[1] || test.top ) >= target.top && ( test[1] || test.bottom ) <= target.bottom ); 188 | }, 189 | 190 | // stored tolerance modes 191 | modes: { // fn scope: "$.event.special.drop" object 192 | // target with mouse wins, else target with most overlap wins 193 | 'intersect': function( event, proxy, target ){ 194 | return this.contains( target, [ event.pageX, event.pageY ] ) ? // check cursor 195 | 1e9 : this.modes.overlap.apply( this, arguments ); // check overlap 196 | }, 197 | // target with most overlap wins 198 | 'overlap': function( event, proxy, target ){ 199 | // calculate the area of overlap... 200 | return Math.max( 0, Math.min( target.bottom, proxy.bottom ) - Math.max( target.top, proxy.top ) ) 201 | * Math.max( 0, Math.min( target.right, proxy.right ) - Math.max( target.left, proxy.left ) ); 202 | }, 203 | // proxy is completely contained within target bounds 204 | 'fit': function( event, proxy, target ){ 205 | return this.contains( target, proxy ) ? 1 : 0; 206 | }, 207 | // center of the proxy is contained within target bounds 208 | 'middle': function( event, proxy, target ){ 209 | return this.contains( target, [ proxy.left + proxy.width * .5, proxy.top + proxy.height * .5 ] ) ? 1 : 0; 210 | } 211 | }, 212 | 213 | // sort drop target cache by by winner (dsc), then index (asc) 214 | sort: function( a, b ){ 215 | return ( b.winner - a.winner ) || ( a.index - b.index ); 216 | }, 217 | 218 | // async, recursive tolerance execution 219 | tolerate: function( dd ){ 220 | // declare local refs 221 | var i, drp, drg, data, arr, len, elem, 222 | // interaction iteration variables 223 | x = 0, ia, end = dd.interactions.length, 224 | // determine the mouse coords 225 | xy = [ drop.event.pageX, drop.event.pageY ], 226 | // custom or stored tolerance fn 227 | tolerance = drop.tolerance || drop.modes[ drop.mode ]; 228 | // go through each passed interaction... 229 | do if ( ia = dd.interactions[x] ){ 230 | // check valid interaction 231 | if ( !ia ) 232 | return; 233 | // initialize or clear the drop data 234 | ia.drop = []; 235 | // holds the drop elements 236 | arr = []; 237 | len = ia.droppable.length; 238 | // determine the proxy location, if needed 239 | if ( tolerance ) 240 | drg = drop.locate( ia.proxy ); 241 | // reset the loop 242 | i = 0; 243 | // loop each stored drop target 244 | do if ( elem = ia.droppable[i] ){ 245 | data = $.data( elem, drop.datakey ); 246 | drp = data.location; 247 | if ( !drp ) continue; 248 | // find a winner: tolerance function is defined, call it 249 | data.winner = tolerance ? tolerance.call( drop, drop.event, drg, drp ) 250 | // mouse position is always the fallback 251 | : drop.contains( drp, xy ) ? 1 : 0; 252 | arr.push( data ); 253 | } while ( ++i < len ); // loop 254 | // sort the drop targets 255 | arr.sort( drop.sort ); 256 | // reset the loop 257 | i = 0; 258 | // loop through all of the targets again 259 | do if ( data = arr[ i ] ){ 260 | // winners... 261 | if ( data.winner && ia.drop.length < drop.multi ){ 262 | // new winner... dropstart 263 | if ( !data.active[x] && !data.anyactive ){ 264 | // check to make sure that this is not prevented 265 | if ( $special.drag.hijack( drop.event, "dropstart", dd, x, data.elem )[0] !== false ){ 266 | data.active[x] = 1; 267 | data.anyactive += 1; 268 | } 269 | // if false, it is not a winner 270 | else 271 | data.winner = 0; 272 | } 273 | // if it is still a winner 274 | if ( data.winner ) 275 | ia.drop.push( data.elem ); 276 | } 277 | // losers... 278 | else if ( data.active[x] && data.anyactive == 1 ){ 279 | // former winner... dropend 280 | $special.drag.hijack( drop.event, "dropend", dd, x, data.elem ); 281 | data.active[x] = 0; 282 | data.anyactive -= 1; 283 | } 284 | } while ( ++i < len ); // loop 285 | } while ( ++x < end ) // loop 286 | // check if the mouse is still moving or is idle 287 | if ( drop.last && xy[0] == drop.last.pageX && xy[1] == drop.last.pageY ) 288 | delete drop.timer; // idle, don't recurse 289 | else // recurse 290 | drop.timer = setTimeout(function(){ 291 | drop.tolerate( dd ); 292 | }, drop.delay ); 293 | // remember event, to compare idleness 294 | drop.last = drop.event; 295 | } 296 | 297 | }; 298 | 299 | // share the same special event configuration with related events... 300 | $special.dropinit = $special.dropstart = $special.dropend = drop; 301 | 302 | })(jQuery); // confine scope --------------------------------------------------------------------------------