Merge lp:~njpatel/nux/weak-ptrs-on-window-compostor-3.0 into lp:nux/3.0

[Neil J. Patel]

WindowCompostior: use ObjectWeakPtr to handle focus and mouse areas

So they get automatically nullified when the handled objects are destroyed,
also Make Area to unset the key-focus paths on destroy.

It can happen that during the WindowCompostitor::MenuEventCycle or KeyboardEventCycle computation the AreaUnderMouse is deleted, this can lead to a crash such as bug #1045059 (since when we use the area that we found, its location is no more valid). We can fix this issue using ObjectWeakPtr as they will be notified of their deletion.

At this point I've also moved the existing Area* references that were using the destroyed signal to ObjectWeakPtr's.

[Marco Trevisan (Treviño) (3v1n0)]

Everything goes as expected ;)

review: Approve

[Unity Merger (unity-merger)]

No proposals found for merge of lp:~njpatel/nux/input-area-ungrab-on-destroy-3.0 into lp:nux/3.0.

=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2012-05-31 21:50:05 +0000
+++ Nux/Area.cpp	2012-09-18 18:30:40 +0000
@@ -68,6 +68,8 @@
 
   Area::~Area()
   {
+    ResetDownwardPathToKeyFocusArea();
+    ResetUpwardPathToKeyFocusArea();
   }
 
   const NString &Area::GetBaseString() const
 
=== modified file 'Nux/WindowCompositor.cpp'
--- Nux/WindowCompositor.cpp	2012-08-02 17:46:47 +0000
+++ Nux/WindowCompositor.cpp	2012-09-18 18:30:40 +0000
@@ -58,7 +58,6 @@
     m_CurrentWindow             = NULL;
     m_MenuWindow                = NULL;
     _mouse_over_area            = NULL;
-    key_focus_area_             = NULL;
     _always_on_front_window     = NULL;
     inside_event_cycle_         = false;
     inside_rendering_cycle_     = false;
@@ -67,11 +66,8 @@
     _pending_exclusive_input_mode_action = false;
 
     _dnd_area                   = NULL;
-    mouse_over_area_            = NULL;
-    mouse_owner_area_           = NULL;
     _mouse_over_menu_page       = NULL;
     _mouse_owner_menu_page      = NULL;
-    mouse_owner_base_window_    = NULL;
     _starting_menu_event_cycle  = false;
     _menu_is_active             = false;
     _enable_nux_new_event_architecture   = true;
@@ -99,12 +95,7 @@
 
   void WindowCompositor::BeforeDestructor()
   {
-    if (key_focus_area_)
-    {
-      key_focus_area_->ResetDownwardPathToKeyFocusArea();
-      key_focus_area_->ResetUpwardPathToKeyFocusArea();
-      key_focus_area_ = NULL;
-    }
+    key_focus_area_ = NULL;
   }
 
   WindowCompositor::~WindowCompositor()
@@ -186,17 +177,12 @@
     {
       _view_window_list.erase(it);
 
-      if (_view_window_list.size())
+      if (!_view_window_list.empty())
         m_SelectedWindow = _view_window_list.front();
     }
     _window_to_texture_map.erase(window.GetPointer());
   }
 
-  Area* WindowCompositor::GetMouseOwnerArea()
-  {
-    return mouse_owner_area_;
-  }
-
   //! Get Mouse position relative to the top left corner of the window.
   Point WindowCompositor::GetMousePosition()
   {
@@ -213,24 +199,24 @@
 
   void WindowCompositor::GetAreaUnderMouse(const Point& mouse_position,
                                            NuxEventType event_type,
-                                           InputArea** area_under_mouse_pointer,
-                                           BaseWindow** window)
+                                           ObjectWeakPtr<InputArea>& area_under_mouse_pointer,
+                                           ObjectWeakPtr<BaseWindow>& window)
   {
-    *area_under_mouse_pointer = NULL;
+    window = NULL;
+    area_under_mouse_pointer = NULL;
 
     // Go through the list of BaseWindo and find the first area over which the
     // mouse pointer is.
     WindowList::iterator window_it;
-
     for (window_it = _view_window_list.begin(); window_it != _view_window_list.end(); ++window_it)
     {
       if ((*window_it).IsValid() && (*window_it)->IsVisible())
       {
-        InputArea* area = static_cast<InputArea*>((*window_it)->FindAreaUnderMouse(mouse_position, event_type));
+        Area* area = (*window_it)->FindAreaUnderMouse(mouse_position, event_type);
         if (area)
         {
-          *area_under_mouse_pointer = area;
-          *window = (*window_it).GetPointer();
+          area_under_mouse_pointer = static_cast<InputArea*>(area);
+          window = *window_it;
           return;
         }
       }
@@ -238,91 +224,55 @@
 
     // If area_under_mouse_pointer is NULL, then the mouse pointer is not over
     // any of the BaseWindow. Try the main window layout.
-    if (*area_under_mouse_pointer == NULL)
+    if (!area_under_mouse_pointer.IsValid())
     {
       Layout* main_window_layout = window_thread_->GetLayout();
       if (main_window_layout)
-        *area_under_mouse_pointer = static_cast<InputArea*>(main_window_layout->FindAreaUnderMouse(mouse_position, event_type));
-    }
-  }
-
-  void WindowCompositor::OnMouseOverViewDestroyed(Object* object)
-  {
-    if (mouse_over_area_ == object)
-    {
-      mouse_over_area_ = NULL;
-    }
-  }
-
-  void WindowCompositor::SetMouseOverArea(Area* area)
-  {
-    mouse_over_area_ = static_cast<InputArea*>(area);
-
-    mouse_over_view_connection_.disconnect();
-
-    if (mouse_over_area_)
-    {
-      mouse_over_view_connection_ = mouse_over_area_->object_destroyed.connect(sigc::mem_fun(this, &WindowCompositor::OnMouseOverViewDestroyed));
-    }
-  }
-
-  void WindowCompositor::OnMouseOwnerViewDestroyed(Object* object)
-  {
-    if (mouse_owner_area_ == object)
-    {
-      mouse_owner_area_ = NULL;
-    }
-  }
-
-  void WindowCompositor::SetMouseOwnerArea(Area* area)
+        area_under_mouse_pointer = static_cast<InputArea*>(main_window_layout->FindAreaUnderMouse(mouse_position, event_type));
+    }
+  }
+
+  void WindowCompositor::SetMouseOverArea(InputArea* area)
+  {
+    if (mouse_over_area_ == area)
+      return;
+
+    mouse_over_area_ = area;
+  }
+
+  void WindowCompositor::SetMouseOwnerArea(InputArea* area)
   {
     if (mouse_owner_area_ == area)
       return;
 
-    mouse_owner_area_ = static_cast<InputArea*>(area);
+    mouse_owner_area_ = area;
     dnd_safety_x_ = 0;
     dnd_safety_y_ = 0;
-
-    mouse_owner_view_connection_.disconnect();
-
-    if (mouse_owner_area_)
-    {
-      mouse_owner_view_connection_ = mouse_owner_area_->object_destroyed.connect(sigc::mem_fun(this, &WindowCompositor::OnMouseOwnerViewDestroyed));
-    }
   }
 
-  void WindowCompositor::OnMouseOwnerBaseWindowDestroyed(Object* object)
+  ObjectWeakPtr<InputArea> const& WindowCompositor::GetMouseOwnerArea() const
   {
-    if (mouse_owner_base_window_ == object)
-    {
-      mouse_owner_base_window_ = NULL;
-    }
+    return mouse_owner_area_;
   }
 
   void WindowCompositor::SetMouseOwnerBaseWindow(BaseWindow* base_window)
   {
-    mouse_owner_base_window_ = base_window;
-
-    mouse_owner_basewindow_connection_.disconnect();
-
-    if (mouse_owner_base_window_)
-    {
-      mouse_owner_basewindow_connection_ = mouse_owner_base_window_->object_destroyed.connect(sigc::mem_fun(this, &WindowCompositor::OnMouseOwnerBaseWindowDestroyed));
-    }
+    if (mouse_owner_base_window_ != base_window)
+      mouse_owner_base_window_ = base_window;
   }
 
   void WindowCompositor::DndEventCycle(Event& event)
   {
     if (event.type == NUX_DND_MOVE)
     {
-      InputArea* hit_area = NULL;
-      BaseWindow* hit_base_window = NULL;
-
-      GetAreaUnderMouse(Point(event.x, event.y), event.type, &hit_area, &hit_base_window);
-
-      if (hit_area)
+      ObjectWeakPtr<InputArea> hit_area;
+      ObjectWeakPtr<BaseWindow> hit_base_window;
+
+      GetAreaUnderMouse(Point(event.x, event.y), event.type, hit_area, hit_base_window);
+
+      if (hit_area.IsValid())
       {
-        SetDnDArea(hit_area);
+        SetDnDArea(hit_area.GetPointer());
         hit_area->HandleDndMove(event);
       }
       else
@@ -356,7 +306,7 @@
 
     _mouse_position = Point(event.x, event.y);
 
-    if (mouse_owner_area_ == NULL)
+    if (!mouse_owner_area_.IsValid())
     {
       // Context: The left mouse button is not down over an area.
       // We look for the area where the mouse pointer is located.
@@ -370,8 +320,8 @@
         (event.type == NUX_WINDOW_MOUSELEAVE) ||
         (event.type == NUX_MOUSE_RELEASED))
       {
-        InputArea* hit_view = NULL;         // The view under the mouse
-        BaseWindow* hit_base_window = NULL; // The BaseWindow below the mouse pointer.
+        ObjectWeakPtr<InputArea> hit_view; // The view under the mouse
+        ObjectWeakPtr<BaseWindow> hit_base_window; // The BaseWindow below the mouse pointer.
 
         // Look for the area below the mouse pointer in the BaseWindow.
         Area* pointer_grab_area = GetPointerGrabArea();
@@ -379,7 +329,7 @@
         {
           // If there is a pending mouse pointer grab, test that area only
           hit_view = NUX_STATIC_CAST(InputArea*, pointer_grab_area->FindAreaUnderMouse(Point(event.x, event.y), event.type));
-          if ((hit_view == NULL) && (event.type == NUX_MOUSE_PRESSED))
+          if (!hit_view.IsValid() && event.type == NUX_MOUSE_PRESSED)
           {
             Geometry geo = pointer_grab_area->GetAbsoluteGeometry();
             int x = event.x - geo.x;
@@ -390,15 +340,15 @@
         }
         else
         {
-          GetAreaUnderMouse(Point(event.x, event.y), event.type, &hit_view, &hit_base_window);
-          SetMouseOwnerBaseWindow(hit_base_window);
+          GetAreaUnderMouse(Point(event.x, event.y), event.type, hit_view, hit_base_window);
+          SetMouseOwnerBaseWindow(hit_base_window.GetPointer());
         }
 
         Geometry hit_view_geo;
         int hit_view_x = 0;
         int hit_view_y = 0;
 
-        if (hit_view)
+        if (hit_view.IsValid())
         {
           hit_view_geo = hit_view->GetAbsoluteGeometry();
           hit_view_x = event.x - hit_view_geo.x;
@@ -407,11 +357,11 @@
 
         if (event.type == NUX_WINDOW_MOUSELEAVE)
         {
-          if (mouse_over_area_ != NULL)
+          if (mouse_over_area_.IsValid())
           {
             // The area where the mouse was in the previous cycle and the area returned by GetAreaUnderMouse are different.
             // The area from the previous cycle receive a "mouse leave signal".
-            Geometry geo = mouse_over_area_->GetAbsoluteGeometry();
+            Geometry const& geo = mouse_over_area_->GetAbsoluteGeometry();
             int x = event.x - geo.x;
             int y = event.y - geo.y;
 
@@ -419,28 +369,28 @@
             SetMouseOverArea(NULL);
           }
         }
-        else if (hit_view && (event.type == NUX_MOUSE_MOVE))
+        else if (hit_view.IsValid() && event.type == NUX_MOUSE_MOVE)
         {
           bool emit_delta = true;
           if (hit_view != mouse_over_area_)
           {
-            if (mouse_over_area_ != NULL)
+            if (mouse_over_area_.IsValid())
             {
               // The area where the mouse was in the previous cycle and the area returned by GetAreaUnderMouse are different.
               // The area from the previous cycle receive a "mouse leave signal".
-              Geometry geo = mouse_over_area_->GetAbsoluteGeometry();
+              Geometry const& geo = mouse_over_area_->GetAbsoluteGeometry();
               int x = event.x - geo.x;
               int y = event.y - geo.y;
 
               mouse_over_area_->EmitMouseLeaveSignal(x, y, event.GetMouseState(), event.GetKeyState());
             }
             // The area we found under the mouse pointer receives a "mouse enter signal".
-            SetMouseOverArea(hit_view);
+            SetMouseOverArea(hit_view.GetPointer());
 
-            if (mouse_over_area_ != GetKeyFocusArea() &&
-                mouse_over_area_ && mouse_over_area_->AcceptKeyNavFocusOnMouseEnter())
+            if (mouse_over_area_.IsValid() && mouse_over_area_ != GetKeyFocusArea() &&
+                mouse_over_area_->AcceptKeyNavFocusOnMouseEnter())
             {
-              SetKeyFocusArea(mouse_over_area_);
+              SetKeyFocusArea(mouse_over_area_.GetPointer());
             }
           
           
@@ -451,16 +401,16 @@
           // Send a "mouse mouse signal".
           mouse_over_area_->EmitMouseMoveSignal(hit_view_x, hit_view_y, emit_delta ? dx : 0, emit_delta ? dy : 0, event.GetMouseState(), event.GetKeyState());
         }
-        else if (hit_view && ((event.type == NUX_MOUSE_PRESSED) || (event.type == NUX_MOUSE_DOUBLECLICK)))
+        else if (hit_view.IsValid() && (event.type == NUX_MOUSE_PRESSED || event.type == NUX_MOUSE_DOUBLECLICK))
         {
-          if ((event.type == NUX_MOUSE_DOUBLECLICK) && (!hit_view->DoubleClickEnabled()))
+          if (event.type == NUX_MOUSE_DOUBLECLICK && !hit_view->DoubleClickEnabled())
           {
             // If the area does not accept double click events, transform the event into a mouse pressed.
             event.type = NUX_MOUSE_PRESSED;
           }
 
           bool emit_double_click_signal = false;
-          if (mouse_over_area_ && (hit_view != mouse_over_area_))
+          if (mouse_over_area_.IsValid() && hit_view != mouse_over_area_)
           {
             // The area where the mouse was in the previous cycle and the area returned by GetAreaUnderMouse are different.
             // The area from the previous cycle receive a "mouse leave signal".
@@ -473,29 +423,29 @@
 
             mouse_over_area_->EmitMouseLeaveSignal(x, y, event.GetMouseState(), event.GetKeyState());
           }
-          else if (mouse_over_area_ && (hit_view == mouse_over_area_) && (event.type == NUX_MOUSE_DOUBLECLICK))
+          else if (mouse_over_area_.IsValid() && hit_view == mouse_over_area_ && event.type == NUX_MOUSE_DOUBLECLICK)
           {
             // Double click is emitted, if the second click happened on the same area as the first click.
             // This means mouse_over_area_ is not null and is equal to hit_view.
             emit_double_click_signal = true;
           }
 
-          SetMouseOverArea(hit_view);
-          SetMouseOwnerArea(hit_view);
+          SetMouseOverArea(hit_view.GetPointer());
+          SetMouseOwnerArea(hit_view.GetPointer());
           _mouse_position_on_owner = Point(hit_view_x, hit_view_y);
 
           // In the case of a mouse down event, if there is currently a keyboard event receiver and it is different
           // from the area returned by GetAreaUnderMouse, then stop that receiver from receiving anymore keyboard events and switch
           // make mouse_over_area_ the new receiver(if it accept keyboard events).
-          if (mouse_over_area_ != GetKeyFocusArea() && 
-              mouse_over_area_ && mouse_over_area_->AcceptKeyNavFocusOnMouseDown())
+          if (mouse_over_area_.IsValid() && mouse_over_area_ != GetKeyFocusArea() &&
+              mouse_over_area_->AcceptKeyNavFocusOnMouseDown())
           {
             InputArea* grab_area = GetKeyboardGrabArea();
             if (grab_area)
             {
               if (mouse_over_area_->IsChildOf(grab_area) /*&& mouse_over_area_->AcceptKeyboardEvent()*/)
               {
-                SetKeyFocusArea(mouse_over_area_);
+                SetKeyFocusArea(mouse_over_area_.GetPointer());
               }
               else
               {
@@ -504,7 +454,7 @@
             }
             else
             {
-              SetKeyFocusArea(mouse_over_area_);
+              SetKeyFocusArea(mouse_over_area_.GetPointer());
             }
           }
 
@@ -517,11 +467,11 @@
             mouse_over_area_->EmitMouseDownSignal(hit_view_x, hit_view_y, event.GetMouseState(), event.GetKeyState());
           }
         }
-        else if (hit_view && (event.type == NUX_MOUSE_WHEEL))
+        else if (hit_view.IsValid() && (event.type == NUX_MOUSE_WHEEL))
         {
           hit_view->EmitMouseWheelSignal(hit_view_x, hit_view_y, event.wheel_delta, event.GetMouseState(), event.GetKeyState());
         }
-        else if (hit_view && (event.type == NUX_MOUSE_RELEASED))
+        else if (hit_view.IsValid() && (event.type == NUX_MOUSE_RELEASED))
         {
           // We only get a NUX_MOUSE_RELEASED event when the mouse was pressed
           // over another area and released here. There are a few situations that can cause 
@@ -533,11 +483,11 @@
 
           hit_view->EmitMouseUpSignal(hit_view_x, hit_view_y, event.GetMouseState(), event.GetKeyState());
         }
-        else if (hit_view == NULL)
+        else if (!hit_view.IsValid())
         {
-          if (mouse_over_area_)
+          if (mouse_over_area_.IsValid())
           {
-            Geometry geo = mouse_over_area_->GetAbsoluteGeometry();
+            Geometry const& geo = mouse_over_area_->GetAbsoluteGeometry();
             int x = event.x - geo.x;
             int y = event.y - geo.y;
 
@@ -570,13 +520,12 @@
     {
       // Context: The left mouse button down over an area. All events goes to that area.
       // But we still need to know where the mouse is.
-
-      InputArea* hit_view = NULL;         // The view under the mouse
-      BaseWindow* hit_base_window = NULL; // The BaseWindow below the mouse pointer.
-
-      GetAreaUnderMouse(Point(event.x, event.y), event.type, &hit_view, &hit_base_window);
-
-      Geometry mouse_owner_geo = mouse_owner_area_->GetAbsoluteGeometry();
+      ObjectWeakPtr<InputArea> hit_view; // The view under the mouse
+      ObjectWeakPtr<BaseWindow> hit_base_window; // The BaseWindow below the mouse pointer.
+
+      GetAreaUnderMouse(Point(event.x, event.y), event.type, hit_view, hit_base_window);
+
+      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;
 
@@ -605,15 +554,15 @@
           mouse_owner_area_->EmitMouseDragSignal(mouse_owner_x, mouse_owner_y, dx, dy, event.GetMouseState(), event.GetKeyState());
         }
 
-        if ((mouse_over_area_ == mouse_owner_area_) && (hit_view != mouse_owner_area_))
+        if (mouse_over_area_ == mouse_owner_area_ && hit_view != mouse_owner_area_)
         {
           mouse_owner_area_->EmitMouseLeaveSignal(mouse_owner_x, mouse_owner_y, event.GetMouseState(), event.GetKeyState());
-          SetMouseOverArea(hit_view);
+          SetMouseOverArea(hit_view.GetPointer());
         }
-        else if ((mouse_over_area_ != mouse_owner_area_) && (hit_view == mouse_owner_area_))
+        else if (mouse_over_area_ != mouse_owner_area_ && hit_view == mouse_owner_area_)
         {
           mouse_owner_area_->EmitMouseEnterSignal(mouse_owner_x, mouse_owner_y, event.GetMouseState(), event.GetKeyState());
-          SetMouseOverArea(mouse_owner_area_);
+          SetMouseOverArea(mouse_owner_area_.GetPointer());
         }
 
         _mouse_position_on_owner = Point(mouse_owner_x, mouse_owner_y);
@@ -625,11 +574,11 @@
         if (hit_view == mouse_owner_area_)
         {
           mouse_owner_area_->EmitMouseClickSignal(mouse_owner_x, mouse_owner_y, event.GetMouseState(), event.GetKeyState());
-          SetMouseOverArea(mouse_owner_area_);
+          SetMouseOverArea(mouse_owner_area_.GetPointer());
         }
         else
         {
-          SetMouseOverArea(hit_view);
+          SetMouseOverArea(hit_view.GetPointer());
         }
 
         SetMouseOwnerArea(NULL);
@@ -823,36 +772,36 @@
   void WindowCompositor::FindKeyFocusArea(NuxEventType event_type,
     unsigned int key_symbol,
     unsigned int special_keys_state,
-    InputArea** key_focus_area,
-    BaseWindow** window)
+    ObjectWeakPtr<InputArea>& key_focus_area,
+    ObjectWeakPtr<BaseWindow>& window)
   {
-    *key_focus_area = NULL;
-    *window = NULL;
+    key_focus_area = NULL;
+    window = NULL;
 
     // Go through the list of BaseWindos and find the first area over which the mouse pointer is.
     WindowList::iterator window_it;
     window_it = _view_window_list.begin();
-    while ((*key_focus_area == NULL) && (window_it != _view_window_list.end()))
+    while (!key_focus_area.IsValid() && window_it != _view_window_list.end())
     {
       if ((*window_it).IsValid() && (*window_it)->IsVisible())
       {
-        *key_focus_area = NUX_STATIC_CAST(InputArea*, (*window_it)->FindKeyFocusArea(event_type, key_symbol, special_keys_state));
-        if (key_focus_area)
+        key_focus_area = NUX_STATIC_CAST(InputArea*, (*window_it)->FindKeyFocusArea(event_type, key_symbol, special_keys_state));
+        if (key_focus_area.IsValid())
         {
           // We have found an area. We are going to exit the while loop.
-          *window = (*window_it).GetPointer();
+          window = *window_it;
         }
       }
       ++window_it;
     }
 
     // If key_focus_area is NULL, then try the main window layout.
-    if (*key_focus_area == NULL)
+    if (!key_focus_area.IsValid())
     {
       Layout* main_window_layout = window_thread_->GetLayout();
       if (main_window_layout)
       {
-        *key_focus_area = NUX_STATIC_CAST(InputArea*, main_window_layout->FindKeyFocusArea(event_type, key_symbol, special_keys_state));
+        key_focus_area = NUX_STATIC_CAST(InputArea*, main_window_layout->FindKeyFocusArea(event_type, key_symbol, special_keys_state));
       }
     }
   }
@@ -861,21 +810,21 @@
     unsigned int key_symbol,
     unsigned int special_keys_state,
     InputArea* root_search_area,
-    InputArea** key_focus_area,
-    BaseWindow** window)
+    ObjectWeakPtr<InputArea>& key_focus_area,
+    ObjectWeakPtr<BaseWindow>& window)
   {
-    *key_focus_area = NULL;
-    *window = NULL;
+    key_focus_area = NULL;
+    window = NULL;
 
     if (root_search_area == NULL)
     {
       return;
     }
 
-    *key_focus_area = NUX_STATIC_CAST(InputArea*, root_search_area->FindKeyFocusArea(event_type, key_symbol, special_keys_state));
-    if (key_focus_area)
+    key_focus_area = NUX_STATIC_CAST(InputArea*, root_search_area->FindKeyFocusArea(event_type, key_symbol, special_keys_state));
+    if (key_focus_area.IsValid())
     {
-      *window = NUX_STATIC_CAST(BaseWindow*, root_search_area->GetTopLevelViewWindow());
+      window = NUX_STATIC_CAST(BaseWindow*, root_search_area->GetTopLevelViewWindow());
     }
   }
 
@@ -908,25 +857,21 @@
   {
     InputArea* keyboard_event_grab_view = GetKeyboardGrabArea();
 
-    InputArea* focus_area = NULL;   // The view under the mouse
-    BaseWindow* base_window = NULL; // The BaseWindow below the mouse pointer.
+    ObjectWeakPtr<InputArea> focus_area;   // The view under the mouse
+    ObjectWeakPtr<BaseWindow> base_window; // The BaseWindow below the mouse pointer.
 
     if (keyboard_event_grab_view)
     {
       // There is a keyboard grab.
       // Find the key focus area, under the keyboard grab area. That is to say, the key focus area is in the widget tree 
       // whose root is the keyboard grab area. This phase is known as the capture phase.
-      
       FindKeyFocusAreaFrom(event.type, event.GetKeySym(), event.GetKeyState(),
-        keyboard_event_grab_view,
-        &focus_area,
-        &base_window);
+                           keyboard_event_grab_view, focus_area, base_window);
     }
     else
     {
       FindKeyFocusArea(event.type, event.GetKeySym(), event.GetKeyState(),
-        &focus_area,
-        &base_window);
+                       focus_area, base_window);
     }
 
     KeyNavDirection direction = KEY_NAV_NONE;
@@ -964,20 +909,20 @@
       }
     }
 
-    if (focus_area)
+    if (focus_area.IsValid())
     {
-      SetKeyFocusArea(focus_area, direction);
+      SetKeyFocusArea(focus_area.GetPointer(), direction);
     }
     else
     {
       SetKeyFocusArea(NULL, KEY_NAV_NONE);
     }
 
-    if (key_focus_area_)
+    if (key_focus_area_.IsValid())
     {
       if (key_focus_area_->InspectKeyEvent(event.type, event.GetKeySym(), event.GetText()))
       {
-        SendKeyEvent(key_focus_area_,
+        SendKeyEvent(key_focus_area_.GetPointer(),
                     event.type,
                     event.GetKeySym(),
 #if defined(NUX_OS_WINDOWS)
@@ -1014,25 +959,25 @@
         }
       }
       else if (event.type == NUX_KEYDOWN)
-      {        
+      {
         if (direction == KEY_NAV_ENTER)
         {
-          if (key_focus_area_ && key_focus_area_->Type().IsDerivedFromType(InputArea::StaticObjectType))
+          if (key_focus_area_.IsValid() && key_focus_area_->Type().IsDerivedFromType(InputArea::StaticObjectType))
           {
             // Signal emitted from the WindowCompositor.
-            key_nav_focus_activate.emit(key_focus_area_);
+            key_nav_focus_activate.emit(key_focus_area_.GetPointer());
             // Signal emitted from the area itsel.
-            static_cast<InputArea*>(key_focus_area_)->key_nav_focus_activate.emit(key_focus_area_);
+            key_focus_area_->key_nav_focus_activate.emit(key_focus_area_.GetPointer());
           }
         }
         else
         {
           InputArea* key_nav_focus = NULL;
           Area* parent = key_focus_area_->GetParentObject();
-          
+
           if (parent)
             key_nav_focus = NUX_STATIC_CAST(InputArea*, parent->KeyNavIteration(direction));
-          
+
           while (key_nav_focus == NULL && parent != NULL)
           {
             parent = parent->GetParentObject();
@@ -1589,10 +1534,10 @@
       // End 2D Drawing
     }
 
-    if (key_focus_area_)
+    if (key_focus_area_.IsValid())
     {
       // key focus test
-      Geometry geo= key_focus_area_->GetRootGeometry();
+      Geometry const& geo = key_focus_area_->GetRootGeometry();
       //GetGraphicsDisplay()->GetGraphicsEngine()->QRP_Color(geo.x, geo.y, geo.width, geo.height, color::Blue);
     }
 
@@ -1851,17 +1796,6 @@
     return true;
   }
 
-  void WindowCompositor::OnKeyNavFocusDestroyed(Object* area)
-  {
-    if (key_focus_area_ == area)
-    {
-      key_focus_area_->ResetDownwardPathToKeyFocusArea();
-      key_focus_area_->ResetUpwardPathToKeyFocusArea();
-
-      key_focus_area_ = NULL;
-    }
-  }
-  
   bool WindowCompositor::SetKeyFocusArea(InputArea* area, KeyNavDirection direction)
   {
     InputArea* keyboard_grab_area = GetKeyboardGrabArea();
@@ -1886,7 +1820,7 @@
       return false;
     }
 
-    if (key_focus_area_)
+    if (key_focus_area_.IsValid())
     {
       // This is the area that has the keyboard focus. Emit the signal 'end_key_focus'.
       key_focus_area_->end_key_focus.emit();
@@ -1898,9 +1832,9 @@
       if (key_focus_area_->Type().IsDerivedFromType(InputArea::StaticObjectType))
       {
         // Signal emitted from the WindowCompositor.
-        key_nav_focus_change.emit(key_focus_area_, false, direction);
+        key_nav_focus_change.emit(key_focus_area_.GetPointer(), false, direction);
         // Signal emitted from the area itself.
-        static_cast<InputArea*>(key_focus_area_)->key_nav_focus_change.emit(key_focus_area_, false, direction);
+        key_focus_area_->key_nav_focus_change.emit(key_focus_area_.GetPointer(), false, direction);
         // nuxDebugMsg("[WindowCompositor::SetKeyFocusArea] Area type '%s' named '%s': Lost key nav focus.",
         //   key_focus_area_->Type().name,
         //   key_focus_area_->GetBaseString().GetTCharPtr());
@@ -1908,7 +1842,7 @@
 
       if (key_focus_area_->Type().IsDerivedFromType(View::StaticObjectType))
       {
-        static_cast<View*>(key_focus_area_)->QueueDraw();
+        static_cast<View*>(key_focus_area_.GetPointer())->QueueDraw();
       }
     }
 
@@ -1926,9 +1860,9 @@
       if (key_focus_area_->Type().IsDerivedFromType(InputArea::StaticObjectType))
       {
         // Signal emitted from the WindowCompositor.
-        key_nav_focus_change.emit(key_focus_area_, true, direction);
+        key_nav_focus_change.emit(key_focus_area_.GetPointer(), true, direction);
         // Signal emitted from the area itself.
-        static_cast<InputArea*>(key_focus_area_)->key_nav_focus_change.emit(key_focus_area_, true, direction);
+        key_focus_area_->key_nav_focus_change.emit(key_focus_area_.GetPointer(), true, direction);
         // nuxDebugMsg("[WindowCompositor::SetKeyFocusArea] Area type '%s' named '%s': Has key nav focus.",
         //   key_focus_area_->Type().name,
         //   key_focus_area_->GetBaseString().GetTCharPtr());
@@ -1936,10 +1870,10 @@
 
       if (key_focus_area_->Type().IsDerivedFromType(View::StaticObjectType))
       {
-        static_cast<View*>(key_focus_area_)->QueueDraw();
+        static_cast<View*>(key_focus_area_.GetPointer())->QueueDraw();
       }
 
-      key_focus_area_->ChildFocusChanged.emit(key_focus_area_);
+      key_focus_area_->ChildFocusChanged.emit(key_focus_area_.GetPointer());
 
     }
     else
@@ -1947,24 +1881,12 @@
       key_focus_area_ = NULL;
     }
 
-    key_focus_area_connection_.disconnect();
-
-    if (area)
-    {
-      key_focus_area_connection_ = area->object_destroyed.connect(sigc::mem_fun(this, &WindowCompositor::OnKeyNavFocusDestroyed));
-    }
-
-    if (key_focus_area_ == NULL)
-    {
-      return false;
-    }
-
-    return true;
+    return key_focus_area_.IsValid() ? true : false;
   }
 
   InputArea* WindowCompositor::GetKeyFocusArea()
   {
-    return key_focus_area_;
+    return key_focus_area_.GetPointer();
   }
 
   void WindowCompositor::SetBackgroundPaintLayer(AbstractPaintLayer* bkg)
@@ -2220,7 +2142,7 @@
       keyboard_grab_stack_.push_front(area);
       
       // If there is any area with the key focus, cancel it.
-      if (key_focus_area_)
+      if (key_focus_area_.IsValid())
       {
         key_focus_area_->end_key_focus.emit();
         key_focus_area_->ResetUpwardPathToKeyFocusArea();
@@ -2228,9 +2150,9 @@
         if (key_focus_area_->Type().IsDerivedFromType(InputArea::StaticObjectType))
         {
           // Signal emitted from the WindowCompositor.
-          key_nav_focus_change.emit(key_focus_area_, false, KEY_NAV_NONE);
+          key_nav_focus_change.emit(key_focus_area_.GetPointer(), false, KEY_NAV_NONE);
           // Signal emitted from the area itself.
-          static_cast<InputArea*>(key_focus_area_)->key_nav_focus_change.emit(key_focus_area_, false, KEY_NAV_NONE);
+          key_focus_area_->key_nav_focus_change.emit(key_focus_area_.GetPointer(), false, KEY_NAV_NONE);
           // nuxDebugMsg("[WindowCompositor::GrabKeyboardAdd] Area type '%s' named '%s': Lost key nav focus.",
           //   key_focus_area_->Type().name,
           //   key_focus_area_->GetBaseString().GetTCharPtr());
@@ -2239,7 +2161,7 @@
 
         if (key_focus_area_->Type().IsDerivedFromType(View::StaticObjectType))
         {
-          static_cast<View*>(key_focus_area_)->QueueDraw();
+          static_cast<View*>(key_focus_area_.GetPointer())->QueueDraw();
         }
         key_focus_area_ = NULL;
       }
@@ -2295,7 +2217,7 @@
     else
     {
       // If there is any area with the key focus, cancel it.
-      if (key_focus_area_)
+      if (key_focus_area_.IsValid())
       {
         key_focus_area_->end_key_focus.emit();
         key_focus_area_->ResetUpwardPathToKeyFocusArea();
@@ -2303,9 +2225,9 @@
         if (key_focus_area_->Type().IsDerivedFromType(InputArea::StaticObjectType))
         {
           // Signal emitted from the WindowCompositor.
-          key_nav_focus_change.emit(key_focus_area_, false, KEY_NAV_NONE);
+          key_nav_focus_change.emit(key_focus_area_.GetPointer(), false, KEY_NAV_NONE);
           // Signal emitted from the area itself.
-          static_cast<InputArea*>(key_focus_area_)->key_nav_focus_change.emit(key_focus_area_, false, KEY_NAV_NONE);
+          key_focus_area_->key_nav_focus_change.emit(key_focus_area_.GetPointer(), false, KEY_NAV_NONE);
           // nuxDebugMsg("[WindowCompositor::GrabKeyboardRemove] Area type '%s' named '%s': Lost key nav focus.",
           //   key_focus_area_->Type().name,
           //   key_focus_area_->GetBaseString().GetTCharPtr());          
@@ -2313,7 +2235,7 @@
 
         if (key_focus_area_->Type().IsDerivedFromType(View::StaticObjectType))
         {
-          static_cast<View*>(key_focus_area_)->QueueDraw();
+          static_cast<View*>(key_focus_area_.GetPointer())->QueueDraw();
         }
         key_focus_area_ = NULL;
       }
 
=== modified file 'Nux/WindowCompositor.h'
--- Nux/WindowCompositor.h	2012-06-26 13:38:50 +0000
+++ Nux/WindowCompositor.h	2012-09-18 18:30:40 +0000
@@ -127,50 +127,38 @@
     //! Traverse the widget tree and found the area that is right below the mouse pointer.
     void GetAreaUnderMouse(const Point& mouse_position,
                            NuxEventType event_type,
-                           InputArea** area_under_mouse_pointer,
-                           BaseWindow** window);
+                           ObjectWeakPtr<InputArea>& area_under_mouse_pointer,
+                           ObjectWeakPtr<BaseWindow>& window);
 
     //! Traverse the widget tree and found the area has the key focus.
     void FindKeyFocusArea(NuxEventType event_type,
                           unsigned int key_symbol,
                           unsigned int special_keys_state,
-                          InputArea** key_focus_area,
-                          BaseWindow** window);
-    
+                          ObjectWeakPtr<InputArea>& key_focus_area,
+                          ObjectWeakPtr<BaseWindow>& window);
+
     //! Traverse the widget tree and found the area has the key focus, but start from a specified widget.
     void FindKeyFocusAreaFrom(NuxEventType event_type,
       unsigned int key_symbol,
       unsigned int special_keys_state,
       InputArea* root_search_area,
-      InputArea** key_focus_area,
-      BaseWindow** window);
+      ObjectWeakPtr<InputArea>& key_focus_area,
+      ObjectWeakPtr<BaseWindow>& window);
 
     void ResetMousePointerAreas();
 
     //! Get the area upon which the mouse button is currently down.
-    Area* GetMouseOwnerArea();
+    ObjectWeakPtr<InputArea> const& GetMouseOwnerArea() const;
 
     //! Set the area upon which the mouse button is currently down.
-    void SetMouseOwnerArea(Area* area);
+    void SetMouseOwnerArea(InputArea* area);
 
     //! Set the area that is right below the mouse pointer.
-    void SetMouseOverArea(Area* area);
-    
+    void SetMouseOverArea(InputArea* area);
+
     //! Set The BaseWindow of the area that is the mouse owner.
     void SetMouseOwnerBaseWindow(BaseWindow* base_window);
 
-    //! Callback: called when mouse_over_area_ is destroyed.
-    void OnMouseOverViewDestroyed(Object* area);
-    
-    //! Callback: called when mouse_owner_area_ is destroyed.
-    void OnMouseOwnerViewDestroyed(Object* area);
-
-    //! Callback: called when key_focus_area_ is destroyed.
-    void OnKeyNavFocusDestroyed(Object* area);
-
-    //! Callback: called when mouse_owner_basewindow_connection_ is destroyed.
-    void OnMouseOwnerBaseWindowDestroyed(Object* area);
-
     void SendKeyEvent(InputArea* input_area, NuxEventType event_type,
       unsigned int key_sym,
       unsigned long x11_key_code,
@@ -184,19 +172,14 @@
         The InputArea that has the mouse focus also has the keyboard focus. That is if _mouse_focus_area is not Null
         then _mouse_focus_area is equal to _mouse_focus_area;
     */
-    InputArea* key_focus_area_;
-    InputArea* mouse_owner_area_;
-    InputArea* mouse_over_area_;
-    BaseWindow* mouse_owner_base_window_;
+    ObjectWeakPtr<InputArea> key_focus_area_;
+    ObjectWeakPtr<InputArea> mouse_owner_area_;
+    ObjectWeakPtr<InputArea> mouse_over_area_;
+    ObjectWeakPtr<BaseWindow> mouse_owner_base_window_;
 
     int dnd_safety_x_;
     int dnd_safety_y_;
 
-    sigc::connection mouse_over_view_connection_;
-    sigc::connection mouse_owner_view_connection_;
-    sigc::connection mouse_owner_basewindow_connection_;
-    sigc::connection key_focus_area_connection_;
-
     /*!
         This signal is similar to Area::key_nav_focus_change. It is emitted from the WindowCompositor.
         The user only needs to listen to this signal to find out the area that has received the keyboard focus.\n
@@ -682,6 +665,7 @@
     friend class VSplitter;
     friend class TableCtrl;
     friend class View;
+    friend class TestWindowCompositor;
   };
 
 #ifdef NUX_GESTURES_SUPPORT
 
=== modified file 'configure.ac'
--- configure.ac	2012-08-30 10:57:51 +0000
+++ configure.ac	2012-09-18 18:30:40 +0000
@@ -22,7 +22,7 @@
 # The number format is : year/month/day
 # e.g.: december 5th, 2011 is: 20111205
 # To make more than one API change in a day, add a number to the date. Like 20111205.xx
-m4_define([nux_abi_version], [20120813.01])
+m4_define([nux_abi_version], [20120914.02])
 
 m4_define([nux_version],
           [nux_major_version.nux_minor_version.nux_micro_version])
 
=== modified file 'tests/gtest-nux-area.cpp'
--- tests/gtest-nux-area.cpp	2012-03-02 02:48:48 +0000
+++ tests/gtest-nux-area.cpp	2012-09-18 18:30:40 +0000
@@ -1,11 +1,26 @@
-#include <string>
-#include <fstream>
+/*
+ * Copyright 2010 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3, as
+ * published by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
+ */
 
-#include <iostream>
 #include <gmock/gmock.h>
-#include <boost/filesystem.hpp>
-#include <glib.h>
-
+#include <boost/shared_ptr.hpp>
 #include "Nux/Nux.h"
 #include "Nux/HLayout.h"
 #include "Nux/StaticText.h"
@@ -16,14 +31,39 @@
 
 namespace {
 
-TEST(TestArea, TestAreaSize)
-{
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Area Test", 300, 200,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-
-  nux::TestView* test_view = new nux::TestView("");
-
+struct MockTestView : nux::TestView
+{
+  MockTestView()
+    : nux::TestView("MockTestView")
+  {}
+
+  void SetNextObjectToKeyFocusArea(nux::Area* area)
+  {
+    TestView::SetNextObjectToKeyFocusArea(area);
+  }
+
+  nux::Area* GetNextObjectToKeyFocusArea()
+  {
+    return TestView::GetNextObjectToKeyFocusArea();
+  }
+};
+
+struct TestArea : public testing::Test
+{
+  void SetUp()
+  {
+    nux::NuxInitialize(0);
+    wnd_thread.reset(nux::CreateNuxWindow("Area Test", 300, 200, nux::WINDOWSTYLE_NORMAL,
+                                          NULL, false, NULL, NULL));
+    test_view = new MockTestView();
+  }
+
+  boost::shared_ptr<nux::WindowThread> wnd_thread;
+  nux::ObjectPtr<MockTestView> test_view;
+};
+
+TEST_F(TestArea, TestAreaSize)
+{
   EXPECT_EQ(test_view->GetMinimumWidth(), nux::AREA_MIN_WIDTH);
   EXPECT_EQ(test_view->GetMaximumWidth(), nux::AREA_MAX_WIDTH);
   EXPECT_EQ(test_view->GetMinimumHeight(), nux::AREA_MIN_HEIGHT);
@@ -48,29 +88,16 @@
   EXPECT_EQ(test_view->GetMaximumWidth(), 4321);
   EXPECT_EQ(test_view->GetMinimumHeight(), 432);
   EXPECT_EQ(test_view->GetMaximumHeight(), 1234);
-
-  test_view->UnReference();
-  delete wnd_thread;
 }
 
-TEST(TestArea, TestAreaGeometry)
+TEST_F(TestArea, TestAreaGeometry)
 {
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Area Test", 300, 200,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-
-  nux::TestView* test_view = new nux::TestView("");
-
-  static_cast<nux::Area*>(test_view)->SetGeometry(0, 0, 100, 100);
+  static_cast<nux::Area*>(test_view.GetPointer())->SetGeometry(0, 0, 100, 100);
 
   EXPECT_EQ(test_view->GetBaseX(), 0);
   EXPECT_EQ(test_view->GetBaseX(), 0);
   EXPECT_EQ(test_view->GetBaseWidth(), 100);
   EXPECT_EQ(test_view->GetBaseHeight(), 100);
-
-
-  test_view->UnReference();
-  delete wnd_thread;
 }
 
 static bool object_destroyed = false;
@@ -79,31 +106,53 @@
   object_destroyed = true;
 }
 
-TEST(TestArea, TestUnParentKeyFocus)
+TEST_F(TestArea, TestUnParentKeyFocus)
 {
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Area Test", 300, 200,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-
+  nux::TestView* test_view1 = new nux::TestView("");
   nux::HLayout* layout = new nux::HLayout();
-  nux::TestView* test_view = new nux::TestView("");
-  test_view->object_destroyed.connect(sigc::ptr_fun(&OnObjectDestroyed));
+  test_view1->object_destroyed.connect(sigc::ptr_fun(&OnObjectDestroyed));
 
-  test_view->Reference();
-  
-  layout->AddView(test_view, 1);
+  test_view1->Reference();
+  layout->AddView(test_view1, 1);
 
   wnd_thread->SetLayout(layout);
 
-  EXPECT_EQ(test_view->HasKeyFocus(), false);
-  nux::GetWindowThread()->GetWindowCompositor().SetKeyFocusArea(test_view);
-  EXPECT_EQ(test_view->HasKeyFocus(), true);
-  layout->RemoveChildObject(test_view);
-  EXPECT_EQ(test_view->HasKeyFocus(), false);
-  test_view->UnReference();
+  EXPECT_EQ(test_view1->HasKeyFocus(), false);
+  nux::GetWindowThread()->GetWindowCompositor().SetKeyFocusArea(test_view1);
+  EXPECT_EQ(test_view1->HasKeyFocus(), true);
+  layout->RemoveChildObject(test_view1);
+  EXPECT_EQ(test_view1->HasKeyFocus(), false);
+  test_view1->UnReference();
   EXPECT_EQ(object_destroyed, true);
-
-  delete wnd_thread;
+}
+
+TEST_F(TestArea, NextObjectToKeyFocusSetReset)
+{
+  MockTestView* parent = new MockTestView();
+  MockTestView* brother = new MockTestView();
+  MockTestView* child1 = new MockTestView();
+  MockTestView* child2 = new MockTestView();
+  MockTestView* child3 = new MockTestView();
+
+  parent->SetNextObjectToKeyFocusArea(brother);
+  ASSERT_EQ(parent->GetNextObjectToKeyFocusArea(), brother);
+
+  child1->SetParentObject(parent);
+  child1->SetNextObjectToKeyFocusArea(child2);
+  ASSERT_EQ(child1->GetNextObjectToKeyFocusArea(), child2);
+
+  child2->SetParentObject(parent);
+  child2->SetNextObjectToKeyFocusArea(child3);
+  ASSERT_EQ(child2->GetNextObjectToKeyFocusArea(), child3);
+
+  child3->SetParentObject(parent);
+  ASSERT_EQ(child3->GetNextObjectToKeyFocusArea(), nullptr);
+
+  child1->UnReference();
+  EXPECT_EQ(child2->GetNextObjectToKeyFocusArea(), nullptr);
+  EXPECT_EQ(parent->GetNextObjectToKeyFocusArea(), nullptr);
+
+  parent->UnReference();
 }
 
 }
 
=== modified file 'tests/gtest-nux-input-area.cpp'
--- tests/gtest-nux-input-area.cpp	2012-09-18 18:30:40 +0000
+++ tests/gtest-nux-input-area.cpp	2012-09-18 18:30:40 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 Canonical Ltd.
+ * Copyright 2010 Inalogic® Inc.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License version 3, as
 
=== modified file 'tests/gtest-nux-windowcompositor.cpp'
--- tests/gtest-nux-windowcompositor.cpp	2012-06-26 13:38:50 +0000
+++ tests/gtest-nux-windowcompositor.cpp	2012-09-18 18:30:40 +0000
@@ -47,17 +47,109 @@
 };
 #endif
 
-TEST(TestWindowCompositor, TestSetKeyFocusArea)
-{
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Nux Window", 300, 200,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-
+struct TestBaseWindow : public nux::BaseWindow
+{
+  TestBaseWindow() : input_area(new nux::InputArea())
+  {
+    ShowWindow(true);
+  }
+
+  nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
+  {
+    return input_area.GetPointer();
+  }
+
+  Area* FindKeyFocusArea(unsigned int key_symbol, unsigned long x11_key_code, unsigned long special_keys_state)
+  {
+    return input_area.GetPointer();
+  }
+
+  nux::ObjectPtr<nux::InputArea> input_area;
+};
+
+struct TestHLayout : public nux::HLayout
+{
+  TestHLayout() : input_area(new nux::InputArea()) {}
+
+  nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
+  {
+    return input_area.GetPointer();
+  }
+
+  Area* FindKeyFocusArea(unsigned int key_symbol, unsigned long x11_key_code, unsigned long special_keys_state)
+  {
+    return input_area.GetPointer();
+  }
+
+  nux::ObjectPtr<nux::InputArea> input_area;
+};
+
+}
+
+namespace nux
+{
+struct TestWindowCompositor : public testing::Test
+{
+  TestWindowCompositor()
+  {}
+
+  void SetUp()
+  {
+    nux::NuxInitialize(0);
+    wnd_thread.reset(nux::CreateNuxWindow("WindowCompositor Test", 300, 200, nux::WINDOWSTYLE_NORMAL,
+                                          NULL, false, NULL, NULL));
+  }
+
+  void ForceSetKeyFocusArea(nux::InputArea* area)
+  {
+    nux::GetWindowCompositor().key_focus_area_ = area;
+  }
+
+  ObjectWeakPtr<InputArea> const& GetMouseOwnerArea() const
+  {
+    return nux::GetWindowCompositor().GetMouseOwnerArea();
+  }
+
+  void SetMouseOwnerArea(InputArea* area)
+  {
+    nux::GetWindowCompositor().mouse_owner_area_ = area;
+  }
+
+  InputArea* GetMouseOverArea()
+  {
+    return nux::GetWindowCompositor().mouse_over_area_.GetPointer();
+  }
+
+  void SetMouseOverArea(InputArea* area)
+  {
+    nux::GetWindowCompositor().mouse_over_area_ = area;
+  }
+
+  void GetAreaUnderMouse(const Point& mouse_position, NuxEventType event_type,
+                         ObjectWeakPtr<InputArea>& area,
+                         ObjectWeakPtr<BaseWindow>& window)
+  {
+    return nux::GetWindowCompositor().GetAreaUnderMouse(mouse_position, event_type, area, window);
+  }
+
+  void FindKeyFocusArea(NuxEventType event_type, unsigned int key_symbol,
+                        unsigned int state,
+                        ObjectWeakPtr<InputArea>& key_focus_area,
+                        ObjectWeakPtr<BaseWindow>& window)
+  {
+    return nux::GetWindowCompositor().FindKeyFocusArea(event_type, key_symbol, state, key_focus_area, window);
+  }
+
+  boost::shared_ptr<nux::WindowThread> wnd_thread;
+};
+
+TEST_F(TestWindowCompositor, TestSetKeyFocusArea)
+{
   nux::TestView* test_view0 = new nux::TestView();
   nux::TestView* test_view1 = new nux::TestView();
 
   nux::HLayout* layout = new nux::HLayout();
-  
+
   layout->AddView(test_view0, 1);
   layout->AddView(test_view1, 1);
 
@@ -89,8 +181,6 @@
     EXPECT_EQ(test_view1->registered_begin_keynav_focus_, true);
     EXPECT_EQ(test_view1->registered_end_keynav_focus_, false);
   }
-
-  delete wnd_thread;
 }
 
 #ifdef NUX_GESTURES_SUPPORT
@@ -104,11 +194,8 @@
   Check that the gesture got accepted, that window A got the gesture
   events and that window B didn't get anything.
  */
-TEST(TestWindowCompositor, GestureEventsDelivery_1)
+TEST_F(TestWindowCompositor, GestureEventsDelivery_1)
 {
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Nux Window", 500, 500,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
   nux::WindowCompositor &wnd_compositor = wnd_thread->GetWindowCompositor();
   nux::FakeGestureEvent fake_event;
 
@@ -159,7 +246,6 @@
 
   target_window->Dispose();
   innocent_window->Dispose();
-  delete wnd_thread;
 }
 
 /*
@@ -171,13 +257,10 @@
   Check that the gesture got rejected and that no window got
   any gesture event.
 */
-TEST(TestWindowCompositor, GestureEventsDelivery_2)
+TEST_F(TestWindowCompositor, GestureEventsDelivery_2)
 {
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Nux Window", 500, 500,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-  nux::WindowCompositor &wnd_compositor = wnd_thread->GetWindowCompositor();
   nux::FakeGestureEvent fake_event;
+  nux::WindowCompositor& wnd_compositor = nux::GetWindowCompositor();
 
   TestWindow *subscribed_window = new TestWindow;
   subscribed_window->SetBaseXY(10, 10);
@@ -212,7 +295,6 @@
 
   subscribed_window->Dispose();
   innocent_window->Dispose();
-  delete wnd_thread;
 }
 
 /*
@@ -225,13 +307,10 @@
   Check that the gesture gets accepted and that only the input area behind that
   window gets the gesture events.
  */
-TEST(TestWindowCompositor, GestureEventsDelivery_3)
+TEST_F(TestWindowCompositor, GestureEventsDelivery_3)
 {
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Nux Window", 500, 500,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-  nux::WindowCompositor &wnd_compositor = wnd_thread->GetWindowCompositor();
   nux::FakeGestureEvent fake_event;
+  nux::WindowCompositor& wnd_compositor = nux::GetWindowCompositor();
 
   TestWindow *window = new TestWindow;
   window->SetBaseXY(10, 10);
@@ -287,20 +366,16 @@
   ASSERT_EQ(0, other_input_area->gesture_events_received.size());
 
   window->Dispose();
-  delete wnd_thread;
 }
 
 /*
   Check that if a gesture gets its construction finished only on its end event,
   it still gets accepted and delivered.
  */
-TEST(TestWindowCompositor, GestureEventsDelivery_4)
+TEST_F(TestWindowCompositor, GestureEventsDelivery_4)
 {
-  nux::NuxInitialize(0);
-  nux::WindowThread *wnd_thread = nux::CreateNuxWindow("Nux Window", 500, 500,
-    nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL);
-  nux::WindowCompositor &wnd_compositor = wnd_thread->GetWindowCompositor();
   nux::FakeGestureEvent fake_event;
+  nux::WindowCompositor& wnd_compositor = nux::GetWindowCompositor();
 
   TestWindow *window = new TestWindow;
   window->SetBaseXY(10, 10);
@@ -356,7 +431,110 @@
   ASSERT_EQ(0, other_input_area->gesture_events_received.size());
 
   window->Dispose();
-  delete wnd_thread;
+}
+
+TEST_F(TestWindowCompositor, KeyFocusAreaAutomaticallyUnsets)
+{
+  nux::WindowCompositor& wnd_compositor = nux::GetWindowCompositor();
+  nux::InputArea* test_area = new TestInputArea();
+
+  ForceSetKeyFocusArea(test_area);
+  ASSERT_EQ(wnd_compositor.GetKeyFocusArea(), test_area);
+
+  test_area->UnReference();
+  EXPECT_EQ(wnd_compositor.GetKeyFocusArea(), nullptr);
+}
+
+TEST_F(TestWindowCompositor, MouseOverAreaAutomaticallyUnsets)
+{
+  nux::InputArea* test_area = new TestInputArea();
+
+  SetMouseOverArea(test_area);
+  ASSERT_EQ(GetMouseOverArea(), test_area);
+
+  test_area->UnReference();
+  EXPECT_EQ(GetMouseOverArea(), nullptr);
+}
+
+TEST_F(TestWindowCompositor, MouseOwnerAreaAutomaticallyUnsets)
+{
+  nux::InputArea* test_area = new TestInputArea();
+
+  SetMouseOwnerArea(test_area);
+  ASSERT_EQ(GetMouseOwnerArea(), test_area);
+
+  test_area->UnReference();
+  EXPECT_EQ(GetMouseOwnerArea(), nullptr);
+}
+
+TEST_F(TestWindowCompositor, GetAreaUnderMouse)
+{
+  ObjectWeakPtr<InputArea> area;
+  ObjectWeakPtr<BaseWindow> window;
+
+  TestBaseWindow* test_win = new TestBaseWindow();
+
+  GetAreaUnderMouse(Point(1, 2), NUX_MOUSE_MOVE, area, window);
+
+  EXPECT_EQ(area.GetPointer(), test_win->input_area.GetPointer());
+  EXPECT_EQ(window.GetPointer(), test_win);
+
+  test_win->UnReference();
+  EXPECT_EQ(area.GetPointer(), nullptr);
+  EXPECT_EQ(window.GetPointer(), nullptr);
+}
+
+TEST_F(TestWindowCompositor, GetAreaUnderMouseFallback)
+{
+  ObjectWeakPtr<InputArea> area;
+  ObjectWeakPtr<BaseWindow> window;
+
+  TestHLayout* layout = new TestHLayout();
+  wnd_thread->SetLayout(layout);
+
+  GetAreaUnderMouse(Point(1, 2), NUX_MOUSE_MOVE, area, window);
+
+  EXPECT_EQ(area.GetPointer(), layout->input_area.GetPointer());
+  EXPECT_EQ(window.GetPointer(), nullptr);
+
+  wnd_thread->SetLayout(nullptr);
+  layout->UnReference();
+  EXPECT_EQ(area.GetPointer(), nullptr);
+}
+
+TEST_F(TestWindowCompositor, GetFocusedArea)
+{
+  ObjectWeakPtr<InputArea> area;
+  ObjectWeakPtr<BaseWindow> window;
+
+  TestBaseWindow* test_win = new TestBaseWindow();
+
+  FindKeyFocusArea(NUX_KEYUP, 0, 0, area, window);
+
+  EXPECT_EQ(area.GetPointer(), test_win->input_area.GetPointer());
+  EXPECT_EQ(window.GetPointer(), test_win);
+
+  test_win->UnReference();
+  EXPECT_EQ(area.GetPointer(), nullptr);
+  EXPECT_EQ(window.GetPointer(), nullptr);
+}
+
+TEST_F(TestWindowCompositor, GetFocusedAreaFallback)
+{
+  ObjectWeakPtr<InputArea> area;
+  ObjectWeakPtr<BaseWindow> window;
+
+  TestHLayout* layout = new TestHLayout();
+  wnd_thread->SetLayout(layout);
+
+  FindKeyFocusArea(NUX_KEYUP, 0, 0, area, window);
+
+  EXPECT_EQ(area.GetPointer(), layout->input_area.GetPointer());
+  EXPECT_EQ(window.GetPointer(), nullptr);
+
+  wnd_thread->SetLayout(nullptr);
+  layout->UnReference();
+  EXPECT_EQ(area.GetPointer(), nullptr);
 }
 
 #endif // NUX_GESTURES_SUPPORT