Merge lp:~gordallott/nux/keynav-fixes-11-03-10 into lp:nux

[Gord Allott]

Bunch of key-nav fixes for unity key-nav - paired with lp:~gordallott/unity/keynav-fixes-11-03-10

[Jay Taoko (jaytaoko)]

Approved

review: Approve

=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2011-02-28 17:37:41 +0000
+++ Nux/Area.cpp	2011-03-10 13:09:13 +0000
@@ -827,7 +827,7 @@
       return;
 
     _is_focused = focused;
-    FocusChanged (this);
+    FocusChanged.emit (this);
   }
 
   bool Area::DoCanFocus ()
@@ -838,6 +838,7 @@
   /* override me! */
   void Area::DoActivateFocus ()
   {
+    FocusActivated.emit (this);
   }
 
   void Area::QueueRelayout ()
@@ -845,9 +846,4 @@
     nux::GetWindowThread ()->QueueObjectLayout (this);
   }
 
-//   bool Area::AddSecondaryChild (Area *child)
-//   {
-//     NUX_RETURN_IF_NULL (child, false);
-//
-//   }
 }

=== modified file 'Nux/Area.h'
--- Nux/Area.h	2011-03-01 04:25:39 +0000
+++ Nux/Area.h	2011-03-10 13:09:13 +0000
@@ -296,7 +296,8 @@
     virtual void DoSetFocused (bool focused);
     virtual bool DoCanFocus ();
     virtual void DoActivateFocus ();
-
+    
+    sigc::signal <void, Area *> FocusActivated;
     sigc::signal <void, Area *> FocusChanged;
     //! Queue a relayout
     /*!

=== modified file 'Nux/Focusable.cpp'
--- Nux/Focusable.cpp	2011-02-28 17:32:57 +0000
+++ Nux/Focusable.cpp	2011-03-10 13:09:13 +0000
@@ -54,22 +54,27 @@
       {
         case NUX_VK_ENTER:
           type = FOCUS_EVENT_ACTIVATE;
+          //g_debug ("focus key activated");
           break;
         case NUX_KP_UP:
           type = FOCUS_EVENT_DIRECTION;
           *direction = FOCUS_DIRECTION_UP;
+          //g_debug ("direction up");
           break;
         case NUX_KP_DOWN:
           type = FOCUS_EVENT_DIRECTION;
           *direction = FOCUS_DIRECTION_DOWN;
+          //g_debug ("direction down");
           break;
         case NUX_KP_LEFT:
           type = FOCUS_EVENT_DIRECTION;
           *direction = FOCUS_DIRECTION_LEFT;
+          //g_debug ("direction left");
           break;
         case NUX_KP_RIGHT:
           type = FOCUS_EVENT_DIRECTION;
           *direction = FOCUS_DIRECTION_RIGHT;
+          //g_debug ("direction right");
           break;
         case NUX_VK_TAB:
           type = FOCUS_EVENT_DIRECTION;
@@ -77,6 +82,11 @@
           if (keysym & NUX_STATE_SHIFT)
           {
             *direction = FOCUS_DIRECTION_PREV;
+            //g_debug ("direction_prev");
+          }
+          else
+          {
+            //g_debug ("direction next");
           }
           break;
         default:
@@ -100,6 +110,7 @@
 
   bool Focusable::DoCanFocus ()
   {
+    g_debug ("Focusable DoCanFocus");
     return false;
   }
 

=== modified file 'Nux/GridHLayout.cpp'
--- Nux/GridHLayout.cpp	2011-02-27 00:34:59 +0000
+++ Nux/GridHLayout.cpp	2011-03-10 13:09:13 +0000
@@ -61,6 +61,99 @@
 
   }
 
+  int GridHLayout::GetChildPos (Area *child)
+  {
+    int position = 0;
+    std::list<Area *>::const_iterator it;
+    for (it = GetChildren ().begin(); it != GetChildren ().end(); it++)
+    {
+      if ((*it) == child)
+        break;
+      
+      if ((*it)->CanFocus ())
+      {
+        position++;
+      }
+    }
+
+    return position;
+  }
+
+  Area* GridHLayout::GetChildAtPosition (int pos)
+  {
+    int position = 0;
+    std::list<Area *>::const_iterator it;
+    for (it = GetChildren ().begin(); it != GetChildren ().end(); it++)
+    {
+      if (position == pos)
+        return (*it);
+      
+      if ((*it)->CanFocus ())
+      {
+        position++;
+      }
+    }   
+
+    return NULL;
+  }
+
+  //up and down should pass event to parent
+  long GridHLayout::DoFocusUp (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area* focused_child = GetFocusedChild ();
+    int position = GetChildPos (focused_child);
+    
+    if (focused_child == NULL || position < GetNumColumn ())
+    {
+      Area *parent = GetParentObject ();
+      if (parent != NULL)
+        return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+
+    }
+    else
+    {
+      // so hacky, but its cheap!
+      // just focus the child position - numcolumns
+      focused_child->SetFocused (false);
+      focused_child = GetChildAtPosition (position - GetNumColumn ());
+      if (focused_child)
+        focused_child->SetFocused (true);
+    }
+
+    return TraverseInfo;
+  }
+  long GridHLayout::DoFocusDown (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area* focused_child = GetFocusedChild ();
+    int position = GetChildPos (focused_child);
+    
+    if (focused_child == NULL || position > GetNumColumn () * (GetNumRow () - 1))
+    {
+      Area *parent = GetParentObject ();
+      if (parent != NULL)
+      {
+        return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+      }
+    }
+    else
+    {
+      // so hacky, but its cheap!
+      // just focus the child position - numcolumns
+      focused_child->SetFocused (false);
+      focused_child = GetChildAtPosition (position + GetNumColumn ());
+      if (focused_child)
+      {
+        focused_child->SetFocused (true);
+      }
+      else
+      {
+        FocusLastChild ();
+      }
+    }
+
+    return TraverseInfo;
+  }
+
   void GridHLayout::EnablePartialVisibility (bool partial_visibility)
   {
     _partial_visibility = partial_visibility;

=== modified file 'Nux/GridHLayout.h'
--- Nux/GridHLayout.h	2011-02-23 14:14:29 +0000
+++ Nux/GridHLayout.h	2011-03-10 13:09:13 +0000
@@ -104,6 +104,14 @@
     */
     virtual void ProcessDraw (GraphicsEngine &GfxContext, bool force_draw);
 
+  protected:
+    int GetChildPos (Area *child);
+    Area* GetChildAtPosition (int pos);
+    virtual long DoFocusUp  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusDown (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    //virtual long DoFocusLeft  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    //virtual long DoFocusRight (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    
   private:
     Size _children_size;
     bool _dynamic_column;

=== modified file 'Nux/HLayout.cpp'
--- Nux/HLayout.cpp	2011-02-23 14:14:29 +0000
+++ Nux/HLayout.cpp	2011-03-10 13:09:13 +0000
@@ -64,6 +64,28 @@
   {
   }
 
+  //up and down should pass event to parent
+  long HLayout::DoFocusUp (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area *parent = GetParentObject ();
+    if (parent != NULL)
+      return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+    else
+      FocusFirstChild ();
+
+    return TraverseInfo;
+  }
+  long HLayout::DoFocusDown (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    
+    Area *parent = GetParentObject ();
+    if (parent != NULL)
+      return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+    else
+      FocusFirstChild ();
+    return TraverseInfo;
+  }
+
   void HLayout::GetCompositeList (std::list<Area *> *ViewList)
   {
     std::list<Area *>::iterator it;

=== modified file 'Nux/HLayout.h'
--- Nux/HLayout.h	2011-02-17 06:49:43 +0000
+++ Nux/HLayout.h	2011-03-10 13:09:13 +0000
@@ -50,6 +50,10 @@
         @param element_margin   The margin between elements.
     */
     void ComputeStacking (t_s32 remaining_width, t_s32 &offset_space, t_s32 &element_margin);
+
+  protected:
+    virtual long DoFocusUp  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusDown (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
   };
 }
 

=== modified file 'Nux/InputArea.cpp'
--- Nux/InputArea.cpp	2011-03-09 13:04:39 +0000
+++ Nux/InputArea.cpp	2011-03-10 13:09:13 +0000
@@ -814,7 +814,6 @@
   void InputArea::DoSetFocused (bool focused)
   {
     Area::DoSetFocused (focused);
-    CaptureMouseDownAnyWhereElse (focused);
     SetKeyboardFocus (focused);
   }
 

=== modified file 'Nux/LayeredLayout.cpp'
--- Nux/LayeredLayout.cpp	2011-02-28 16:24:11 +0000
+++ Nux/LayeredLayout.cpp	2011-03-10 13:09:13 +0000
@@ -82,6 +82,37 @@
   {
   }
 
+  long LayeredLayout::DoFocusPrev (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    if (GetInputMode () == INPUT_MODE_ACTIVE)
+    {
+      Area *parent = GetParentObject ();
+      if (parent != NULL)
+        return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+    }
+    else
+    {
+      return Layout::DoFocusPrev (ievent, TraverseInfo, ProcessEventInfo);
+    }
+
+    return TraverseInfo;
+  }
+
+  long LayeredLayout::DoFocusNext (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    if (GetInputMode () == INPUT_MODE_ACTIVE)
+    {
+      Area *parent = GetParentObject ();
+      if (parent != NULL)
+        return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+    }
+    else
+    {
+      return Layout::DoFocusNext (ievent, TraverseInfo, ProcessEventInfo);
+    }
+    
+    return TraverseInfo;
+  }
   void LayeredLayout::GetCompositeList (std::list<Area *> *ViewList)
   {
     std::list<Area *>::iterator it;
@@ -392,21 +423,25 @@
 
     m_active_index = index_;
     m_active_area = NULL;
+    bool is_focused = GetFocused ();
 
     // first unset focused on all elements
-    for (it = _layout_element_list.begin (); it != eit; ++it)
+    if (is_focused)
     {
-      if ((*it)->GetFocused ())
+      for (it = _layout_element_list.begin (); it != eit; ++it)
       {
-        if ((*it)->IsView ())
-          static_cast<View *> (*it)->SetFocused (false);
-        else if ((*it)->IsLayout ())
-          static_cast<Layout *> (*it)->SetFocused (false);
-        else
-         (*it)->SetFocused (false);
+        if ((*it)->GetFocused ())
+        {
+          if ((*it)->IsView ())
+            static_cast<View *> (*it)->SetFocused (false);
+          else if ((*it)->IsLayout ())
+            static_cast<Layout *> (*it)->SetFocused (false);
+          else
+          (*it)->SetFocused (false);
+        }
       }
     }
-
+    
     for (it = _layout_element_list.begin (); it != eit; ++it)
     {
       if (i == m_active_index && !m_active_area)
@@ -417,12 +452,14 @@
       if ((*it)->IsView ())
       {
         static_cast<View *> (*it)->QueueDraw ();
-        static_cast<View *> (*it)->SetFocused (true);
-      }
+        if (is_focused)
+          static_cast<View *> (*it)->SetFocused (true);
+      } 
       else if ((*it)->IsLayout ())
       {
         static_cast<Layout *> (*it)->QueueDraw ();
-        static_cast<Layout *> (*it)->SetFocused (true);
+        if (is_focused);
+          static_cast<Layout *> (*it)->SetFocused (true);
       }
 
       i++;
@@ -595,4 +632,26 @@
     _layout_element_list.erase (area_it);
     _layout_element_list.insert (_layout_element_list.begin (), area);
   }
+
+  bool LayeredLayout::FocusFirstChild ()
+  {
+    if (m_input_mode == INPUT_MODE_ACTIVE)
+    {
+      m_active_area->SetFocused (true);
+      return true;
+    }
+    else
+      return Layout::FocusFirstChild ();
+  }
+ 
+  bool LayeredLayout::FocusLastChild ()
+  {
+    if (m_input_mode == INPUT_MODE_ACTIVE)
+    {
+      m_active_area->SetFocused (true);
+      return true;
+    }
+    else
+      return Layout::FocusLastChild ();
+  }
 }

=== modified file 'Nux/LayeredLayout.h'
--- Nux/LayeredLayout.h	2011-02-07 10:05:22 +0000
+++ Nux/LayeredLayout.h	2011-03-10 13:09:13 +0000
@@ -198,6 +198,12 @@
     void RemoveChildObject (Area *area);
     void Clear ();
 
+  protected:
+    virtual long DoFocusPrev  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusNext (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual bool FocusFirstChild ();
+    virtual bool FocusLastChild ();
+    
   private:
     void PaintOne (Area *area, GraphicsEngine &GfxContext, bool force_draw);
     long ProcessOne (Area *_area, IEvent &ievent, long traverse_info, long process_event_info);

=== modified file 'Nux/Layout.cpp'
--- Nux/Layout.cpp	2011-02-28 17:32:57 +0000
+++ Nux/Layout.cpp	2011-03-10 13:09:13 +0000
@@ -40,6 +40,7 @@
     m_ContentStacking   = eStackExpand;
     _has_focus_control  = false;
     _queued_draw        = false;
+    _ignore_focus       = false;
 
     SetMinimumSize(1, 1);
   }
@@ -421,6 +422,22 @@
     return false;
   }
 
+  bool Layout::FocusLastChild ()
+  {
+    std::list<Area *>::reverse_iterator it;
+    for (it = _layout_element_list.rbegin(); it != _layout_element_list.rend(); it++)
+    {
+      if ((*it)->CanFocus ())
+      {
+        (*it)->SetFocused (true);
+        ChildFocusChanged (this, (*it));
+        return true;
+      }
+    }
+
+    return false;
+  }
+
 
   bool Layout::FocusNextChild (Area *child)
   {
@@ -491,7 +508,9 @@
   {
     // if parent is null return, thats a valid usecase so no warnings.
     if (area == NULL)
+    {
       return 0;
+    }
 
 
     long ret = 0;
@@ -511,10 +530,80 @@
     return ret;
   }
 
+  Area* Layout::GetFocusedChild ()
+  {
+    std::list<Area *>::iterator it;
+    for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+    {
+      if ((*it)->GetFocused ())
+      {
+        return (*it);
+      }
+    }
+
+    return NULL;
+  }
+
+  long Layout::DoFocusPrev (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area *focused_child = GetFocusedChild ();
+    if (focused_child == NULL) return ProcessEventInfo;
+    bool success = FocusPreviousChild (focused_child);
+    focused_child->SetFocused (false);
+    
+    if (success == false)
+    {
+      Area *parent = GetParentObject ();
+      if (parent != NULL)
+        return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+      else
+        FocusFirstChild ();
+    }
+
+    return ProcessEventInfo;
+  }
+  
+  long Layout::DoFocusNext (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area *focused_child = GetFocusedChild ();
+    if (focused_child == NULL) return ProcessEventInfo;
+    bool success = FocusNextChild(focused_child);
+    focused_child->SetFocused (false);
+
+    if (success == false)
+    {
+      Area *parent = GetParentObject ();
+      if (parent != NULL)
+        return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+      else
+        FocusFirstChild ();
+    }
+
+    return ProcessEventInfo;
+  }
+  
+  long Layout::DoFocusUp (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    return DoFocusPrev (ievent, TraverseInfo, ProcessEventInfo);
+  }
+  long Layout::DoFocusDown (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    return DoFocusNext (ievent, TraverseInfo, ProcessEventInfo);
+  }
+  long Layout::DoFocusLeft (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    return DoFocusPrev (ievent, TraverseInfo, ProcessEventInfo);
+  }
+  long Layout::DoFocusRight (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    return DoFocusNext (ievent, TraverseInfo, ProcessEventInfo);
+  }
+
+
   long Layout::ProcessFocusEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
   {
     long ret = TraverseInfo;
-    std::list<Area *>::iterator it;
+   
 
     if (GetFocused () && ievent.e_event == NUX_KEYDOWN)
     {
@@ -532,15 +621,8 @@
 
       if (type == FOCUS_EVENT_DIRECTION && direction != FOCUS_DIRECTION_NONE)
       {
-        for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
-        {
-          if ((*it)->GetFocused ())
-          {
-            focused_child = (*it);
-            break;
-          }
-        }
-
+        focused_child = GetFocusedChild ();
+  
         /* if nothing is focused, focus the first child else send the event to the parent */
 
         if (focused_child == NULL)
@@ -566,7 +648,16 @@
           {
             if (focused_child == _layout_element_list.front ())
             {
-              ret |= SendEventToArea (parent, ievent, ret, ProcessEventInfo);
+              if (parent != NULL)
+              {
+                ret |= SendEventToArea (parent, ievent, ret, ProcessEventInfo);
+              }
+              else
+              {
+                bool success = FocusLastChild ();
+                if (success)
+                  focused_child->SetFocused (false);
+              }
               return ret;
             }
           }
@@ -574,40 +665,70 @@
           {
             if (focused_child == _layout_element_list.back ())
             {
-              ret |= SendEventToArea (parent, ievent, ret, ProcessEventInfo);
-              return ret;
-            }
-          }
-
-          if (direction == FOCUS_DIRECTION_NEXT // we don't support RTL yet, for shame!
-            || direction == FOCUS_DIRECTION_RIGHT
-            || direction == FOCUS_DIRECTION_DOWN)
-          {
-            bool success = FocusNextChild(focused_child);
-
-            if (success)
-            {
-              focused_child->SetFocused (false);
-              return ret;
-            }
-
-            //~ if (success == false)
-              //~ // no next focused, thats weird. lets propagate up
-              //~ return SendEventToArea (parent, ievent, ret, ProcessEventInfo);
-          }
-
-          if (direction == FOCUS_DIRECTION_PREV // we don't support RTL yet, for shame!
-            || direction == FOCUS_DIRECTION_LEFT
-            || direction == FOCUS_DIRECTION_UP)
-          {
-            bool success = FocusPreviousChild(focused_child);
-
-            if (success)
-            {
-              focused_child->SetFocused (false);
-              return ret;
-            }
-          }
+              if (parent != NULL)
+              {
+                ret |= SendEventToArea (parent, ievent, ret, ProcessEventInfo);
+              }
+              else
+              {
+                bool success = FocusFirstChild ();
+                if (success)
+                  focused_child->SetFocused (false);
+              }
+              return ret;
+            }
+          }
+
+          switch (direction)
+          {
+            case FOCUS_DIRECTION_NEXT:
+              ret |= DoFocusNext (ievent, ret, ProcessEventInfo);
+              break;
+            case FOCUS_DIRECTION_PREV:
+              ret |= DoFocusPrev (ievent, ret, ProcessEventInfo);
+              break;
+            case FOCUS_DIRECTION_UP:
+              ret |= DoFocusUp (ievent, ret, ProcessEventInfo);
+              break;
+            case FOCUS_DIRECTION_DOWN:
+              ret |= DoFocusDown (ievent, ret, ProcessEventInfo);
+              break;
+            case FOCUS_DIRECTION_LEFT:
+              ret |= DoFocusLeft (ievent, ret, ProcessEventInfo);
+              break;
+            case FOCUS_DIRECTION_RIGHT:
+              ret |= DoFocusRight (ievent, ret, ProcessEventInfo);
+              break;
+            default:
+              break;
+          }
+
+          return ret;
+          
+
+//           if (direction == FOCUS_DIRECTION_NEXT // we don't support RTL yet, for shame!
+//             || direction == FOCUS_DIRECTION_RIGHT
+//             || direction == FOCUS_DIRECTION_DOWN)
+//           {
+// 
+// 
+//             //~ if (success == false)
+//               //~ // no next focused, thats weird. lets propagate up
+//               //~ return SendEventToArea (parent, ievent, ret, ProcessEventInfo);
+//           }
+// 
+//           if (direction == FOCUS_DIRECTION_PREV // we don't support RTL yet, for shame!
+//             || direction == FOCUS_DIRECTION_LEFT
+//             || direction == FOCUS_DIRECTION_UP)
+//           {
+//             bool success = FocusPreviousChild(focused_child);
+// 
+//             if (success)
+//             {
+//               focused_child->SetFocused (false);
+//               return ret;
+//             }
+//           }
 
         }
       }
@@ -650,8 +771,14 @@
     }
 
     /* must do focus processing after sending events to children */
-    if (ievent.e_event == NUX_KEYDOWN && HasFocusControl ())
-        ret |= ProcessFocusEvent (ievent, ret, ProcessEventInfo);
+    if (ievent.e_event == NUX_KEYDOWN && HasFocusControl () && _ignore_focus == false)
+    {
+      ret |= ProcessFocusEvent (ievent, ret, ProcessEventInfo);
+    }
+
+    if (_ignore_focus)
+      _ignore_focus = false;
+
     return ret;
   }
 
@@ -815,7 +942,21 @@
     else
     {
       SetFocusControl (true);
-      FocusFirstChild ();
+      bool has_focused_child = false;
+      std::list<Area *>::iterator it;
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      {
+        if ((*it)->GetFocused ())
+          has_focused_child = true;
+      }
+
+      if (has_focused_child == false)
+      {
+        FocusFirstChild ();
+        _ignore_focus = true;
+      }
+
+      // we need to chain up
       Area *_parent = GetParentObject();
       if (_parent == NULL)
         return;
@@ -823,15 +964,22 @@
       if (_parent->IsView ())
       {
         View *parent = (View*)_parent;
+        if (parent->GetFocused () == false)
+        {
+          parent->SetFocused (true);
+        }
         parent->SetFocusControl (false);
       }
       else if (_parent->IsLayout ())
       {
         Layout *parent = (Layout *)_parent;
+        if (parent->GetFocused () == false)
+        {
+          parent->SetFocused (true);
+        }
         parent->SetFocusControl (false);
       }
 
-
     }
   }
 

=== modified file 'Nux/Layout.h'
--- Nux/Layout.h	2011-03-01 04:25:39 +0000
+++ Nux/Layout.h	2011-03-10 13:09:13 +0000
@@ -229,10 +229,6 @@
     virtual bool DoCanFocus ();
     virtual void DoActivateFocus ();
 
-    bool FocusFirstChild ();
-    bool FocusNextChild (Area *child);
-    bool FocusPreviousChild (Area *child);
-
     bool HasFocusableEntries ();
 
     sigc::signal <void, Layout *, Area*> ChildFocusChanged;
@@ -242,8 +238,23 @@
     bool _has_focus_control;
     void SetFocusControl (bool focus_control);
     bool HasFocusControl ();
+    bool _ignore_focus;
 
   protected:
+    Area*GetFocusedChild ();
+    virtual long DoFocusPrev  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusNext  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusUp    (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusDown  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusLeft  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusRight (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual bool FocusFirstChild ();
+    virtual bool FocusLastChild ();
+    virtual bool FocusNextChild (Area *child);
+    virtual bool FocusPreviousChild (Area *child);
+    
+    
+    
     bool _queued_draw; //<! The rendering of the layout needs to be refreshed.
 
     Size m_ContentSize;

=== modified file 'Nux/TextEntry.cpp'
--- Nux/TextEntry.cpp	2011-03-08 15:48:35 +0000
+++ Nux/TextEntry.cpp	2011-03-10 13:09:13 +0000
@@ -200,13 +200,91 @@
     return result;
   }
 
+  void TextEntry::DoSetFocused (bool focused)
+  {
+   
+    View::DoSetFocused (focused);
+    if (focused == true)
+    {
+      SetCursor(0);
+      QueueRefresh(false, true);
+      
+      Area *_parent = GetParentObject();
+      if (_parent == NULL)
+        return;
+
+      if (_parent->IsView ())
+      {
+        View *parent = (View*)_parent;
+        parent->SetFocusControl (false);
+      }
+      else if (_parent->IsLayout ())
+      {
+        Layout *parent = (Layout *)_parent;
+        parent->SetFocusControl (false);
+      }
+    }
+  }
+
   long TextEntry::ProcessEvent (IEvent& event,
     long    traverseInfo,
     long    processEventInfo)
   {
     long ret = traverseInfo;
-
-    ret = PostProcessEvent2 (event, ret, processEventInfo);
+    /* must do focus processing after sending events to children */
+    if (event.e_event == NUX_KEYDOWN && GetFocused ())
+    {
+      FocusDirection direction;
+      FocusEventType type;
+      
+      direction = FOCUS_DIRECTION_NONE;
+      
+      type = Focusable::GetFocusableEventType (event.e_event,
+                                               event.GetKeySym(),
+                                               event.GetText(),
+                                               &direction);
+      if (type == FOCUS_EVENT_DIRECTION)
+      {
+        if (direction == FOCUS_DIRECTION_PREV || direction == FOCUS_DIRECTION_NEXT ||
+            direction == FOCUS_DIRECTION_UP || direction == FOCUS_DIRECTION_DOWN)
+        {
+          Area *area = GetParentObject ();
+          // if parent is null return, thats a valid usecase so no warnings.
+          if (area)
+          {
+            long ret = 0;
+            if ( area->IsView() )
+            {
+              View *ic = NUX_STATIC_CAST (View *, area );
+              ret = ic->ProcessFocusEvent (event, ret, processEventInfo);
+            }
+            else if ( area->IsLayout() )
+            {
+              Layout *layout = NUX_STATIC_CAST (Layout *, area );
+              layout->SetFocusControl (true);   
+              ret = layout->ProcessFocusEvent (event, ret, processEventInfo);
+            }
+          }
+        }
+        else
+        {
+          OnKeyEvent.emit (GetWindowThread ()->GetGraphicsEngine(),
+                           event.e_event, event.GetKeySym(),
+                           event.GetKeyState(), event.GetText(),
+                           event.GetKeyRepeatCount());
+          //ret = PostProcessEvent2 (event, ret, processEventInfo);
+        }
+      }
+      else
+      {
+        OnKeyEvent.emit (GetWindowThread ()->GetGraphicsEngine(),
+                         event.e_event, event.GetKeySym(),
+                         event.GetKeyState(), event.GetText(),
+                         event.GetKeyRepeatCount());
+      }
+    }
+
+
     return ret;
   }
 
@@ -522,6 +600,7 @@
     if (_text_color != text_color)
     {
       _text_color = text_color;
+      QueueRefresh(true, true);
     }
   }
 
@@ -1301,6 +1380,7 @@
     if (end > str)
     {
       size_t len = end - str;
+
       _text.insert(cursor_, str, len);
       cursor_ += static_cast<int>(len);
       selection_bound_ += static_cast<int>(len);

=== modified file 'Nux/TextEntry.h'
--- Nux/TextEntry.h	2011-03-08 14:22:45 +0000
+++ Nux/TextEntry.h	2011-03-10 13:09:13 +0000
@@ -173,6 +173,9 @@
     CairoGraphics::Alignment GetAlign() const;
     void SetAlign(CairoGraphics::Alignment align);
 
+    protected:
+    virtual void DoSetFocused (bool focused);
+    
     private:
     /**
      * Enum used to specify different motion types.

=== modified file 'Nux/VLayout.cpp'
--- Nux/VLayout.cpp	2011-02-23 14:14:29 +0000
+++ Nux/VLayout.cpp	2011-03-10 13:09:13 +0000
@@ -65,6 +65,27 @@
   {
   }
 
+  //left and right in a vlayout should pass event to parent
+  long VLayout::DoFocusLeft (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area *parent = GetParentObject ();
+    if (parent != NULL)
+      return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+    else
+      FocusFirstChild ();
+    
+    return TraverseInfo;
+  }
+  long VLayout::DoFocusRight (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
+  {
+    Area *parent = GetParentObject ();
+    if (parent != NULL)
+      return SendEventToArea (parent, ievent, TraverseInfo, ProcessEventInfo);
+    else
+      FocusLastChild ();
+    return TraverseInfo;
+  }
+
   void VLayout::GetCompositeList (std::list<Area *> *ViewList)
   {
     std::list<Area *>::iterator it;

=== modified file 'Nux/VLayout.h'
--- Nux/VLayout.h	2011-02-17 06:49:43 +0000
+++ Nux/VLayout.h	2011-03-10 13:09:13 +0000
@@ -50,6 +50,10 @@
         @param element_margin   The margin between elements.
     */
     void ComputeStacking (t_s32 length, t_s32 &offset_space, t_s32 &element_margin);
+
+  protected:
+    virtual long DoFocusLeft  (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
+    virtual long DoFocusRight (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
   };
 }
 

=== modified file 'Nux/View.cpp'
--- Nux/View.cpp	2011-02-28 17:32:57 +0000
+++ Nux/View.cpp	2011-03-10 13:09:13 +0000
@@ -40,6 +40,7 @@
     m_UseStyleDrawing   = true;
     m_TextColor         = Color (1.0f, 1.0f, 1.0f, 1.0f);
     _can_pass_focus_to_composite_layout = true;
+    _can_focus          = true;
 
     // Set widget default size;
     SetMinimumSize (DEFAULT_WIDGET_WIDTH, PRACTICAL_WIDGET_HEIGHT);
@@ -261,6 +262,17 @@
       }
     }
 
+//     if (GetFocused () && _can_pass_focus_to_composite_layout == false)
+//     {
+//       GetPainter ().Paint2DQuadColor (GfxContext, GetGeometry (), nux::Color (0.2, 1.0, 0.2, 1.0));
+//     }
+
+//     if (GetFocused () && _can_pass_focus_to_composite_layout == true)
+//     {
+//       GetPainter ().Paint2DQuadColor (GfxContext, GetGeometry (), nux::Color (1.0, 0.2, 0.2, 1.0));
+//     }
+
+
     GfxContext.PopModelViewMatrix ();
 
     _need_redraw = false;
@@ -269,7 +281,7 @@
 
   void View::DrawContent (GraphicsEngine &GfxContext, bool force_draw)
   {
-
+    
   }
 
   void View::PostDraw (GraphicsEngine &GfxContext, bool force_draw)
@@ -462,6 +474,7 @@
 
   void View::DoSetFocused (bool focused)
   {
+    QueueDraw ();
     if (_can_pass_focus_to_composite_layout)
     {
       Layout *layout = GetLayout ();
@@ -473,6 +486,7 @@
       }
       else
       {
+        InputArea::DoSetFocused (focused);
       }
     }
     else
@@ -494,20 +508,38 @@
         SetFocusControl (false);
 
     }
+    else
+    {
+      InputArea::DoSetFocused (focused);
+    }
   }
 
   bool View::DoCanFocus ()
   {
+    if (IsVisible () == false)
+      return false;
+    
+    if (_can_focus == false)
+      return false;
+    
     if (_can_pass_focus_to_composite_layout)
     {
       if (GetLayout () != NULL)
       {
         return GetLayout ()->CanFocus ();
       }
-      return true;
-    }
-
-    return true;
+    }
+
+    return _can_focus;
+  }
+
+  void View::SetCanFocus (bool can_focus)
+  {
+    _can_focus = can_focus;
+    if (_can_focus == False && GetFocused ())
+    {
+      SetFocused (false);
+    }
   }
 
   void View::SetFocusControl (bool focus_control)

=== modified file 'Nux/View.h'
--- Nux/View.h	2011-03-01 04:25:39 +0000
+++ Nux/View.h	2011-03-10 13:09:13 +0000
@@ -176,10 +176,12 @@
     virtual long ProcessFocusEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
     virtual void DoSetFocused (bool focused);
     virtual bool DoCanFocus ();
+    void SetCanFocus (bool can_focus);
     void SetFocusControl (bool focus_control);
     bool HasFocusControl ();
 
   protected:
+    bool _can_focus;
 
     virtual long ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo) = 0;
     virtual void Draw (GraphicsEngine &GfxContext, bool force_draw) = 0;

=== modified file 'examples/focus.cpp'
--- examples/focus.cpp	2011-02-28 11:14:50 +0000
+++ examples/focus.cpp	2011-03-10 13:09:13 +0000
@@ -23,21 +23,28 @@
 #include "Nux/WindowThread.h"
 #include "NuxGraphics/GraphicsEngine.h"
 #include "Nux/TextureArea.h"
+#include "Nux/TextEntry.h"
 
 #include "Nux/VLayout.h"
 #include "Nux/HLayout.h"
+#include "Nux/GridHLayout.h"
 #include "Nux/ScrollView.h"
 #include "Nux/PushButton.h"
 #include "Nux/TextureArea.h"
 
+float frand ()
+{
+  return ((float)rand ()) / RAND_MAX;
+}
+
 static void OnFocusChildChanged (nux::Layout *layout, nux::Area *view)
 {
-  g_debug ("focus has changed, woo");
+  g_debug ("focus has changed, woo %i", rand ());
 }
 
 static void OnFocusChanged (nux::Area *view)
 {
-  g_debug ("focus on a specific child has changed");
+  g_debug ("focus on a specific child has changed %i", rand ());
   nux::TextureArea *texarea = (nux::TextureArea *)view;
 
   if (view->GetFocused ())
@@ -47,7 +54,7 @@
   }
   else
   {
-    nux::ColorLayer color (nux::Color (1.0, 0.2, 0.2, 1.0));
+    nux::ColorLayer color (nux::Color (0.6, 0.+ frand ()*0.3, 0.2+ frand ()*0.3, 1.0));
     texarea->SetPaintLayer (&color);
   }
 
@@ -57,66 +64,117 @@
 void UserInterfaceInitialization(nux::NThread* thread, void* init_data)
 {
   // Create a vertical Layout
-  nux::VLayout* layout = new nux::VLayout(NUX_TRACKER_LOCATION);
-  nux::HLayout* layout_top = new nux::HLayout(NUX_TRACKER_LOCATION);
-
-  nux::ScrollView *layout_scroll = new nux::ScrollView (NUX_TRACKER_LOCATION);
-  nux::HLayout* layout_bottom = new nux::HLayout(NUX_TRACKER_LOCATION);
-  layout->AddLayout (layout_top, 0, nux::MINOR_POSITION_TOP);
-
-  layout_scroll->SetLayout (layout_bottom);
-  layout->AddView (layout_scroll, 0, nux::MINOR_POSITION_TOP);
+  nux::HLayout* layout = new nux::HLayout(NUX_TRACKER_LOCATION);
+  nux::VLayout* layout_left = new nux::VLayout (NUX_TRACKER_LOCATION);
+  nux::HLayout* content_layout = new nux::HLayout (NUX_TRACKER_LOCATION);
+  nux::VLayout* layout_right = new nux::VLayout (NUX_TRACKER_LOCATION);
+  
+  //nux::HLayout* layout_top = new nux::HLayout(NUX_TRACKER_LOCATION);
+  nux::TextEntry* text_entry = new nux::TextEntry ("This is some text", NUX_TRACKER_LOCATION);
+  text_entry->SetTextColor (nux::Color (1.0, 1.0, 1.0, 1.0));
+
+  //nux::ScrollView *layout_scroll = new nux::ScrollView (NUX_TRACKER_LOCATION);
+  nux::VLayout* layout_scroll_container = new nux::VLayout (NUX_TRACKER_LOCATION);
+  
+  nux::VLayout* layout_scroll_1  = new nux::VLayout(NUX_TRACKER_LOCATION);
+  nux::HLayout* layout_scroll_11 = new nux::HLayout(NUX_TRACKER_LOCATION);
+  nux::GridHLayout* layout_scroll_12 = new nux::GridHLayout (NUX_TRACKER_LOCATION);
+
+  layout_scroll_1->AddLayout (layout_scroll_11, 0, nux::MINOR_POSITION_TOP);
+  layout_scroll_1->AddLayout (layout_scroll_12, 1, nux::MINOR_POSITION_TOP);
+  
+  nux::VLayout* layout_scroll_2  = new nux::VLayout(NUX_TRACKER_LOCATION);
+  nux::HLayout* layout_scroll_21 = new nux::HLayout(NUX_TRACKER_LOCATION);
+  nux::GridHLayout* layout_scroll_22 = new nux::GridHLayout (NUX_TRACKER_LOCATION);
+
+  layout_scroll_2->AddLayout (layout_scroll_21, 0, nux::MINOR_POSITION_TOP);
+  layout_scroll_2->AddLayout (layout_scroll_22, 1, nux::MINOR_POSITION_TOP);
+  
+  layout_scroll_container->AddView (text_entry, 0, nux::MINOR_POSITION_TOP);
+
+  //layout_scroll->SetLayout (layout_scroll_container);
+  layout_scroll_container->AddLayout (layout_scroll_1, 1, nux::MINOR_POSITION_TOP);
+  layout_scroll_container->AddLayout (layout_scroll_2, 1, nux::MINOR_POSITION_TOP);
+  
+  content_layout->AddLayout (layout_scroll_container, 1, nux::MINOR_POSITION_TOP);
+  layout->AddLayout (layout_left, 0);
+  layout->AddLayout (content_layout, 1);
+  layout->AddLayout (layout_right, 0);
+  
   layout->ChildFocusChanged.connect (sigc::ptr_fun(&OnFocusChildChanged));
 
-  //~ //Create a button of type PushButton
-  //~ nux::PushButton* button = new nux::PushButton (TEXT ("Hello World!"), NUX_TRACKER_LOCATION);
-//~
-  //~ // Set the button maximum width/height
-  //~ button->SetMaximumWidth (80);
-  //~ button->SetMaximumHeight (40);
-//~
-  //~ // Add the button to the layout
-  //~ layout->AddView (button, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
-//~
-  //~ //Create a button of type PushButton
-  //~ button = new nux::PushButton (TEXT ("Button2"), NUX_TRACKER_LOCATION);
-//~
-  //~ // Set the button maximum width/height
-  //~ button->SetMaximumWidth (80);
-  //~ button->SetMaximumHeight (40);
-//~
-  //~ // Add the button to the layout
-  //~ layout->AddView (button, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
-//~
-  //~ //Create a button of type PushButton
-  //~ button = new nux::PushButton( TEXT ("Button 3"), NUX_TRACKER_LOCATION);
-//~
-  //~ // Set the button maximum width/height
-  //~ button->SetMaximumWidth (80);
-  //~ button->SetMaximumHeight (40);
-//~
-  //~ // Add the button to the layout
-  //~ layout->AddView (button, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+
+//   for (int i = 0; i < 6; i++)
+//   {
+//     nux::ColorLayer color (nux::Color (0.2, 0.2, 0.2+ frand ()*0.3, 1.0));
+//     nux::TextureArea* texture_area = new nux::TextureArea ();
+//     texture_area->SetPaintLayer (&color);
+//     texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
+// 
+//     layout_top->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+//   }
 
   for (int i = 0; i < 6; i++)
   {
-    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.2, 1.0));
-    nux::TextureArea* texture_area = new nux::TextureArea ();
-    texture_area->SetPaintLayer (&color);
-    texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
-
-    layout_top->AddView (texture_area, 1, nux::eLeft, nux::eFull);
-  }
-
-  for (int i = 0; i < 3; i++)
-  {
-    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4, 1.0));
+    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4+ frand ()*0.3, 1.0));
     nux::TextureArea* texture_area = new nux::TextureArea ();
     texture_area->SetPaintLayer (&color);
     texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
   //~ //~
-    layout_bottom->AddView (texture_area, 1, nux::eLeft, nux::eFull);
-  }
+    layout_scroll_11->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+  }
+
+  for (int i = 0; i < 16; i++)
+  {
+    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4+ frand ()*0.3, 1.0));
+    nux::TextureArea* texture_area = new nux::TextureArea ();
+    texture_area->SetPaintLayer (&color);
+    texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
+    //~ //~
+    layout_scroll_12->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+  }
+
+  for (int i = 0; i < 6; i++)
+  {
+    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4+ frand ()*0.3, 1.0));
+    nux::TextureArea* texture_area = new nux::TextureArea ();
+    texture_area->SetPaintLayer (&color);
+    texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
+    //~ //~
+    layout_scroll_21->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+  }
+
+  for (int i = 0; i < 16; i++)
+  {
+    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4+ frand ()*0.3, 1.0));
+    nux::TextureArea* texture_area = new nux::TextureArea ();
+    texture_area->SetPaintLayer (&color);
+    texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
+    //~ //~
+    layout_scroll_22->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+  }
+
+
+  for (int i = 0; i < 16; i++)
+  {
+    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4+ frand ()*0.3, 1.0));
+    nux::TextureArea* texture_area = new nux::TextureArea ();
+    texture_area->SetPaintLayer (&color);
+    texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
+    //~ //~
+    layout_left->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+  }
+
+  for (int i = 0; i < 16; i++)
+  {
+    nux::ColorLayer color (nux::Color (0.2, 0.2, 0.4+ frand ()*0.3, 1.0));
+    nux::TextureArea* texture_area = new nux::TextureArea ();
+    texture_area->SetPaintLayer (&color);
+    texture_area->FocusChanged.connect (sigc::ptr_fun (&OnFocusChanged));
+    //~ //~
+    layout_right->AddView (texture_area, 1, nux::eLeft, nux::eFull);
+  }
+
 
 
   // Control the position of elements inside the layout
@@ -140,8 +198,8 @@
   // Create a Window thread
   nux::WindowThread* wt = nux::CreateGUIThread(
     TEXT("Push Button"),
-    500,
-    500,
+    800,
+    600,
     0,
     &UserInterfaceInitialization,
     0);