Sortable: fire "over" and "out" even when a connectWith hasn't changed

Fixes #9335

diff --git a/tests/unit/sortable/sortable.html b/tests/unit/sortable/sortable.html
index 85126d62d259c3a250a226f306c8212f8ab93ff7..8fe07ede12204e5c85dcfa9311f97fd702d285e5 100644 (file)
--- a/tests/unit/sortable/sortable.html
+++ b/tests/unit/sortable/sortable.html
@@ -16,7 +16,8 @@
                        "ui/core.js",
                        "ui/widget.js",
                        "ui/mouse.js",
-                       "ui/sortable.js"
+                       "ui/sortable.js",
+                       "ui/draggable.js"
                ]
        });
        </script>

diff --git a/tests/unit/sortable/sortable_events.js b/tests/unit/sortable/sortable_events.js
index 8333b8bd470b4f94ae4129412cbf38733c665ad1..1bf72cc6a8ca65e972622a59e0cbad12a34e4390 100644 (file)
--- a/tests/unit/sortable/sortable_events.js
+++ b/tests/unit/sortable/sortable_events.js
@@ -258,11 +258,114 @@ test( "over", function() {
        equal( overCount, 1, "over fires only once" );
 });
 
+// http://bugs.jqueryui.com/ticket/9335
+// Sortable: over & out events does not consistently fire
+test( "over, fires with draggable connected to sortable", function() {
+       expect( 3 );
+
+       var hash,
+               overCount = 0,
+               item = $( "<div></div>" ).text( "6" ).insertAfter( "#sortable" );
+
+       item.draggable({
+               connectToSortable: "#sortable"
+       });
+       $( ".connectWith" ).sortable({
+               connectWith: ".connectWith",
+               over: function( event, ui ) {
+                       hash = ui;
+                       overCount++;
+               }
+       });
+
+       item.simulate( "drag", {
+               dy: -20
+       });
+
+       ok( hash, "over event triggered" );
+       ok( !hash.sender, "UI should not include: sender" );
+       equal( overCount, 1, "over fires only once" );
+});
+
+test( "over, with connected sortable", function() {
+       expect( 3 );
+
+       var hash,
+               overCount = 0;
+
+       $( ".connectWith" ).sortable({
+               connectWith: ".connectWith"
+       });
+       $( "#sortable2" ).on( "sortover", function( event, ui ) {
+               hash = ui;
+               overCount++;
+       });
+       $( "#sortable" ).find( "li:eq(0)" ).simulate( "drag", {
+               dy: 102
+       });
+
+       ok( hash, "over event triggered" );
+       equal( hash.sender[ 0 ], $(" #sortable" )[ 0 ], "UI includes: sender" );
+       equal( overCount, 1, "over fires only once" );
+});
+
 /*
 test("out", function() {
        ok(false, "missing test - untested code is broken code.");
 });
+*/
+
+test( "out, with connected sortable", function() {
+       expect( 2 );
+
+       var hash,
+               outCount = 0;
+
+       $( ".connectWith" ).sortable({
+               connectWith: ".connectWith"
+       });
+       $( "#sortable" ).on( "sortout", function( event, ui ) {
+               hash = ui;
+               outCount++;
+       });
+       $( "#sortable" ).find( "li:last" ).simulate( "drag", {
+               dy: 40
+       });
+
+       ok( hash, "out event triggered" );
+       equal( outCount, 1, "out fires only once" );
+});
+
+test( "repeated out & over between connected sortables", function() {
+       expect( 2 );
 
+       var outCount = 0,
+               overCount = 0;
+
+       $( ".connectWith" ).sortable({
+               connectWith: ".connectWith",
+               over: function() {
+                       overCount++;
+               },
+               out: function( event, ui ) {
+                       // Ignore events that trigger when an item has dropped
+                       // checking for the presence of the helper.
+                       if ( !ui.helper ) {
+                               outCount++;
+                       }
+               }
+       });
+       $( "#sortable" ).find( "li:last" ).simulate( "drag", {
+               dy: 40
+       }).simulate( "drag", {
+               dy: -40
+       });
+
+       equal( outCount, 2, "out fires twice" );
+       equal( overCount, 4, "over fires four times" );
+});
+
+/*
 test("activate", function() {
        ok(false, "missing test - untested code is broken code.");
 });

diff --git a/ui/sortable.js b/ui/sortable.js
index c7edd3d1fd6211a3a975c5cba83ce62faccb06a7..da4d13117120bafbf4866d7586614faa340cd856 100644 (file)
--- a/ui/sortable.js
+++ b/ui/sortable.js
@@ -911,6 +911,10 @@ return $.widget("ui.sortable", $.ui.mouse, {
                        }
 
                        if(this.currentContainer === this.containers[innermostIndex]) {
+                               if ( !this.currentContainer.containerCache.over ) {
+                                       this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
+                                       this.currentContainer.containerCache.over = 1;
+                               }
                                return;
                        }