Merge lp:~3v1n0/nux/emit-mouse-leave-on-new-over-area into lp:nux

[Marco Trevisan (Treviño)]

WindowCompositor: emit mouse_leave signal when releasing mouse over a new area

When the mouse button is released we update the mouse over area, but we also need
to signal the old mouse over area that mouse is not hovering it anymore.
Otherwise IsMouseInside will still be true for that (sicne it caches this value).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:872
http://jenkins.qa.ubuntu.com/job/nux-ci/124/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/nux-wily-amd64-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/nux-wily-armhf-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/nux-wily-i386-ci/6

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/nux-ci/124/rebuild

review: Approve (continuous-integration)

[Andrea Azzarone (azzar1)]

LGTM

review: Approve

[lp:~3v1n0/nux/emit-mouse-leave-on-new-over-area]

873. By Marco Trevisan (Treviño) on 2015-09-17

WindowCompositor: ensure that we don't access to an invalid area

=== modified file 'Nux/WindowCompositor.cpp'
--- Nux/WindowCompositor.cpp	2014-10-03 22:52:46 +0000
+++ Nux/WindowCompositor.cpp	2015-09-17 18:03:27 +0000
@@ -245,9 +245,13 @@
     if (mouse_owner_area_ == area)
       return;
 
+    auto* old_owner = mouse_owner_area_.GetPointer();
     mouse_owner_area_ = area;
     dnd_safety_x_ = 0;
     dnd_safety_y_ = 0;
+
+    if (old_owner)
+      old_owner->EmitMouseCancelSignal();
   }
 
   ObjectWeakPtr<InputArea> const& WindowCompositor::GetMouseOwnerArea() const
@@ -520,7 +524,26 @@
       }
       else if (event.type == NUX_MOUSE_RELEASED)
       {
-        mouse_over_area_ = new_area_under_mouse;
+        if (new_area_under_mouse != mouse_over_area_)
+        {
+          if (mouse_over_area_ == mouse_owner_area_)
+          {
+            mouse_owner_area_->EmitMouseLeaveSignal(mouse_owner_x, mouse_owner_y,
+                                                    event.GetMouseState(),
+                                                    event.GetKeyState());
+          }
+
+          mouse_over_area_ = new_area_under_mouse;
+
+          if (mouse_over_area_.IsValid())
+          {
+            auto const& over_geo = mouse_over_area_->GetAbsoluteGeometry();
+            mouse_over_area_->EmitMouseEnterSignal(event.x - over_geo.x,
+                                                   event.y - over_geo.y,
+                                                   event.GetMouseState(),
+                                                   event.GetKeyState());
+          }
+        }
       }
     }
 
@@ -614,20 +637,21 @@
         Geometry const& mouse_owner_geo = mouse_owner_area_->GetAbsoluteGeometry();
         int mouse_owner_x = event.x - mouse_owner_geo.x;
         int mouse_owner_y = event.y - mouse_owner_geo.y;
-
-        mouse_owner_area_->EmitMouseUpSignal(mouse_owner_x, mouse_owner_y,
-                                             event.GetMouseState(),
-                                             event.GetKeyState());
-
-        if (mouse_owner_area_.IsValid() && mouse_over_area_ == mouse_owner_area_ &&
-           (!mouse_over_area_->DoubleClickEnabled() || (event.mouse_state & NUX_STATE_FIRST_EVENT) != 0))
-        {
-          mouse_owner_area_->EmitMouseClickSignal(mouse_owner_x, mouse_owner_y,
-                                                  event.GetMouseState(),
-                                                  event.GetKeyState());
-        }
+        auto* old_mouse_owner_area = mouse_owner_area_.GetPointer();
 
         SetMouseOwnerArea(NULL);
+
+        old_mouse_owner_area->EmitMouseUpSignal(mouse_owner_x, mouse_owner_y,
+                                                event.GetMouseState(),
+                                                event.GetKeyState());
+
+        if (mouse_over_area_ == old_mouse_owner_area &&
+            (!mouse_over_area_->DoubleClickEnabled() || (event.mouse_state & NUX_STATE_FIRST_EVENT) != 0))
+        {
+          old_mouse_owner_area->EmitMouseClickSignal(mouse_owner_x, mouse_owner_y,
+                                                     event.GetMouseState(),
+                                                     event.GetKeyState());
+        }
       }
     }
   }

=== modified file 'tests/gtest-nux-windowcompositor.cpp'
--- tests/gtest-nux-windowcompositor.cpp	2013-10-31 01:10:43 +0000
+++ tests/gtest-nux-windowcompositor.cpp	2015-09-17 18:03:27 +0000
@@ -686,6 +686,111 @@
   EXPECT_EQ(area.GetPointer(), nullptr);
 }
 
+TEST_F(TestWindowCompositor, UpdateInputAreaMouseInsideOnRelease)
+{
+  Event ev;
+  ObjectPtr<TestBaseWindow> ia1(new TestBaseWindow());
+
+  ev.type = EVENT_MOUSE_DOWN;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+
+  ASSERT_TRUE(ia1->input_area->IsMouseInside());
+  ASSERT_TRUE(ia1->input_area->IsMouseOwner());
+
+  ObjectPtr<TestBaseWindow> ia2(new TestBaseWindow());
+  ev.type = EVENT_MOUSE_UP;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+
+  EXPECT_FALSE(ia1->input_area->IsMouseOwner());
+  EXPECT_FALSE(ia1->input_area->IsMouseInside());
+  EXPECT_NE(GetMouseOverArea(), ia1->input_area.GetPointer());
+}
+
+TEST_F(TestWindowCompositor, UpdateNewInputAreaMouseInsideOnRelease)
+{
+  Event ev;
+  ObjectPtr<TestBaseWindow> ia1(new TestBaseWindow());
+
+  ev.type = EVENT_MOUSE_DOWN;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+
+  ASSERT_TRUE(ia1->input_area->IsMouseInside());
+  ASSERT_TRUE(ia1->input_area->IsMouseOwner());
+
+  ObjectPtr<TestBaseWindow> ia2(new TestBaseWindow());
+  ev.type = EVENT_MOUSE_UP;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+
+  EXPECT_FALSE(ia2->input_area->IsMouseOwner());
+  EXPECT_TRUE(ia2->input_area->IsMouseInside());
+  EXPECT_EQ(GetMouseOverArea(), ia2->input_area.GetPointer());
+}
+
+TEST_F(TestWindowCompositor, UpdateNewInputAreaMouseOwnerBeforeSignalEmission)
+{
+  Event ev;
+  ObjectPtr<TestBaseWindow> ia1(new TestBaseWindow());
+
+  ev.type = EVENT_MOUSE_DOWN;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+  ASSERT_TRUE(ia1->input_area->IsMouseInside());
+  ASSERT_TRUE(ia1->input_area->IsMouseOwner());
+
+  bool got_cb = false;
+  ia1->input_area->mouse_up.connect([this, &ia1, &got_cb] (int, int, unsigned long, unsigned long) {
+    got_cb = true;
+    EXPECT_TRUE(ia1->input_area->IsMouseInside());
+    EXPECT_FALSE(ia1->input_area->IsMouseOwner());
+  });
+
+  ev.type = EVENT_MOUSE_UP;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+
+  ASSERT_TRUE(got_cb);
+  EXPECT_TRUE(ia1->input_area->IsMouseInside());
+  EXPECT_FALSE(ia1->input_area->IsMouseOwner());
+  EXPECT_EQ(GetMouseOverArea(), ia1->input_area.GetPointer());
+}
+
+TEST_F(TestWindowCompositor, InvalidMouseOverAreaOnReleaseDontCrash)
+{
+  Event ev;
+  ObjectPtr<TestBaseWindow> ia1(new TestBaseWindow());
+
+  ev.type = EVENT_MOUSE_DOWN;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+  ASSERT_TRUE(ia1->input_area->IsMouseInside());
+  ASSERT_TRUE(ia1->input_area->IsMouseOwner());
+
+  // We save a copy of the input area, so that WC still things it's alive but
+  // the test window won't return it as the target area for events.
+  auto old_mouse_owner_area = ia1->input_area; (void)old_mouse_owner_area;
+  ia1->input_area.Release();
+
+  ev.type = EVENT_MOUSE_UP;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+}
+
+TEST_F(TestWindowCompositor, EmitMouseCancelOnReleasedMouseOwner)
+{
+  Event ev;
+  ObjectPtr<TestBaseWindow> ia1(new TestBaseWindow());
+
+  ev.type = EVENT_MOUSE_DOWN;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+  ASSERT_TRUE(ia1->input_area->IsMouseOwner());
+
+  bool mouse_cancel_called = false;
+  ia1->input_area->mouse_cancel.connect([this, &mouse_cancel_called] {
+    mouse_cancel_called = true;
+  });
+
+  ev.type = EVENT_MOUSE_UP;
+  nux::GetWindowCompositor().ProcessEvent(ev);
+
+  EXPECT_TRUE(mouse_cancel_called);
+}
+
 class DraggedWindow : public nux::BaseWindow
 {
  public:
@@ -770,17 +875,17 @@
     bool wants_mouse_ownership;
 
   protected:
-    virtual void EmitMouseUpSignal(int x, int y,
-                                   unsigned long mouse_button_state,
-                                   unsigned long special_keys_state)
+    virtual void EmitMouseUpSignal(int, int,
+                                   unsigned long,
+                                   unsigned long)
     {
       ++mouse_up_emission_count;
     }
 
-    virtual void EmitMouseDragSignal(int x, int y,
+    virtual void EmitMouseDragSignal(int, int,
                                      int dx, int dy,
-                                     unsigned long mouse_button_state,
-                                     unsigned long special_keys_state)
+                                     unsigned long,
+                                     unsigned long)
     {
       ++mouse_drag_emission_count;
       mouse_drag_dx = dx;
@@ -804,24 +909,24 @@
     {}
 
   protected:
-    virtual void EmitMouseDownSignal(int x, int y,
-                                     unsigned long mouse_button_state,
-                                     unsigned long special_keys_state)
+    virtual void EmitMouseDownSignal(int, int,
+                                     unsigned long,
+                                     unsigned long)
     {
       ++mouse_down_emission_count;
     }
 
-    virtual void EmitMouseUpSignal(int x, int y,
-                                   unsigned long mouse_button_state,
-                                   unsigned long special_keys_state)
+    virtual void EmitMouseUpSignal(int, int,
+                                   unsigned long,
+                                   unsigned long)
     {
       ++mouse_up_emission_count;
     }
 
-    virtual void EmitMouseDragSignal(int x, int y,
-                                     int dx, int dy,
-                                     unsigned long mouse_button_state,
-                                     unsigned long special_keys_state)
+    virtual void EmitMouseDragSignal(int, int,
+                                     int, int,
+                                     unsigned long,
+                                     unsigned long)
     {
       ++mouse_drag_emission_count;
     }