Merge lp:~haggai-eran/nux/rtl-logical-packing into lp:nux

[Didier Roche-Tolomelli]

Hi,

I've implemented the mirroring for right-to-left locales in this branch, in a way that is different from lp:~haggai-eran/nux/rtl-rebased. I believe this implementation is simpler, requires less changes, and works better with existing widgets.

I've also added a test to make sure the HLayout mirroring is working properly, as a part of the gtest-nux-core test suite.

I'm not sure if I should delete the merge proposal for the rtl-rebased branch, since launchpad says this will also delete all comments. Perhaps it can be archived somehow.

Regards,
Haggai

[Tim Penhey (thumper)]

Just a few minor style things from me:
 * member variables should have trailing not leading underscore
  (parts being updated as we get to them)
 * no space before function call parenthesis
 * please use C++ style enum definitions (not typedef)

   enum Direction
   {
      // values...
   };

I'll let Jay do the actual functionality bits.

review: Needs Fixing

[Haggai Eran (haggai-eran)]

Hi,

It's been 3 months since I posted this request, and except for the coding style comment I haven't gotten any feedback to this patch. Could you tell me if you need any more information or any more work to be done on it?

[Shahar Or (mightyiam)]

Dear Unity/Nux developers,

This is really important for us, RTL users. And It is precious and rare that we have such a willing and able contributor in the RTL community.

So please give this merge even more love! :)

We appreciate it!

Thanks and Blessings,
Shahar
In service of Ubuntu RTL users

[Jay Taoko (jaytaoko)]

It hasn't been easy to come to a decision regarding the proposal of this branch. Supporting Right-to-Left languages is very important and it as do be done right. With regard to Unity which is the main focus, the team hasn't finalised the design for Right-to-Left language support. And how it would impact Unity. That is why I can't approve the branch at this stage.

There are also other technical considerations with the branch. Activating the Right-to-Left mode will not make every widget correct. Some widgets have to be specifically designed with Right-to-Left language support in mind and we can't do it just yet.

[Haggai Eran (haggai-eran)]

Hi Jay,
Thanks for your reply. I understand it is important for the Unity team to make a complete design for right-to-left language support, before accepting any changes. I'm interested in helping advancing this issue, and I would like to take part in this discussion, if that's okay. Can you tell me where is it taking place?

Regarding the branch itself, it is true that I haven't tested all the widgets, as I was focused on what was needed to make the most prominent features of unity mirrored, and hoping to continue to improve it later on.

Finally, since it doesn't seem that Unity will have right-to-left support soon, while Unity2D has right-to-left support since Oneiric (using Qt's excellent mirroring support), I'd like to offer that users of right-to-left languages will have their default desktop set to Unity2D. I wrote about it in the unity-design mailing list [1], and proposed a patch to do so at lp:~haggai-eran/nux/rtl-fallback-to-unity-2d. Would you consider implementing such workaround for Precise?

Best regards,
Haggai

[1] https://lists.launchpad.net/unity-design/msg08745.html

Unmerged revisions

536. By Haggai Eran on 2012-04-18

Right-to-left mirroring support for VSplitter.

535. By Haggai Eran on 2012-04-17

Support right-to-left mirroring in HScrollBar and ScrollView.

534. By Haggai Eran on 2012-04-17

RangeValue right-to-left mirroring support.

533. By Haggai Eran on 2012-04-17

Merge version 2.10.0 from trunk.

532. By Haggai Eran on 2011-12-19

Fix several coding style issues.

531. By Haggai Eran on 2011-12-13

Add simple HLayout test, testing both left-to-right and right-to-left modes.

Moved the run_test wrapper from test_cairo_wrapper.cpp to Helpers.cpp so that it can be reused.

530. By Haggai Eran on 2011-12-06

HLayout right-to-left support.

529. By Haggai Eran on 2011-12-03

Basic right-to-left directionality support.

=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2012-03-12 21:45:30 +0000
+++ Nux/Area.cpp	2012-04-27 07:24:03 +0000
@@ -39,6 +39,7 @@
     ,   geometry_(0, 0, DEFAULT_WIDGET_WIDTH, DEFAULT_WIDGET_HEIGHT)
     ,   min_size_(AREA_MIN_WIDTH, AREA_MIN_HEIGHT)
     ,   max_size_(AREA_MAX_WIDTH, AREA_MAX_HEIGHT)
+    ,   direction_(GetDefaultDirection())
   {
     window_thread_ = GetWindowThread();
     visible_ = true;
@@ -336,9 +337,13 @@
 
   void Area::SetGeometry(int x, int y, int w, int h)
   {
+    const int original_width = w;
     h = nux::Clamp<int> (h, min_size_.height, max_size_.height);
     w = nux::Clamp<int> (w, min_size_.width, max_size_.width);
 
+    if (GetDirection() == RightToLeft)
+      x = x + original_width - w;
+
     nux::Geometry geometry(x, y, w, h);
     if (geometry_ == geometry)
       return;
@@ -1035,5 +1040,15 @@
 
     return false;
   }
+
+  Direction Area::GetDirection() const
+  {
+    return direction_;
+  }
+
+  void Area::SetDirection(Direction direction)
+  {
+    direction_ = direction;
+  }
 }
 
 
=== modified file 'Nux/Area.h'
--- Nux/Area.h	2012-03-12 21:45:30 +0000
+++ Nux/Area.h	2012-04-27 07:24:03 +0000
@@ -140,6 +140,12 @@
     KEY_NAV_ENTER,
   };
 
+  enum Direction
+  {
+    LeftToRight,
+    RightToLeft
+  };
+
   class Layout;
   class View;
   class Area;
@@ -572,6 +578,14 @@
     */
     bool AcceptMouseWheelEvent() const;
 
+    //! Return the direction of the area.
+    Direction GetDirection() const;
+    //! Sets the direction of the area.
+    /*!
+        @param direction Either nux::LeftToRight or nux::RightToLeft
+    */
+    void SetDirection(Direction direction);
+
   protected:
     /*
         This function is reimplemented in Layout as it need to perform some special operations.
@@ -668,6 +682,8 @@
 
     WindowThread*           window_thread_;
 
+    Direction               direction_;
+
     friend class Layout;
     friend class View;
     friend class WindowThread;
 
=== modified file 'Nux/HLayout.cpp'
--- Nux/HLayout.cpp	2011-12-10 06:39:14 +0000
+++ Nux/HLayout.cpp	2012-04-27 07:24:03 +0000
@@ -172,6 +172,9 @@
 
   long HLayout::ComputeContentSize()
   {
+    const bool ltr = GetDirection() == LeftToRight;
+    const int ltr_factor = ltr ? 1 : -1;
+
     if (_layout_element_list.size() == 0)
     {
       return eCompliantHeight | eCompliantWidth;
@@ -240,22 +243,26 @@
       HLayoutManagement(width, height);
 
       // Objects have been resized, now position them.
-      int current_x = GetBaseX() + left_padding_;
+      int current_x;
+      if (ltr)
+          current_x = GetBaseX() + left_padding_;
+      else
+          current_x = GetBaseX() + GetBaseWidth() - right_padding_;
       int current_y = GetBaseY() + top_padding_;
 
       int offset_space = 0;
       int space_after_element = 0;
       ComputeStacking(width, offset_space, space_after_element);
-      current_x += offset_space;
+      current_x += ltr_factor * offset_space;
 
       for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
       {
         if (!(*it)->IsVisible())
           continue;
 
-        current_x += space_after_element;
+        current_x += ltr_factor * space_after_element;
 
-        (*it)->SetBaseX(current_x);
+        (*it)->SetBaseX(current_x - (!ltr ? (*it)->GetBaseWidth() : 0));
         (*it)->SetBaseY(current_y);
 
         MinorDimensionSize extend = (*it)->GetExtend();
@@ -330,7 +337,7 @@
           }
         }
 
-        current_x += (*it)->GetBaseWidth() + space_after_element + space_between_children_;
+        current_x += ltr_factor * ((*it)->GetBaseWidth() + space_after_element + space_between_children_);
       }
 
       // Manage child layout
@@ -756,6 +763,9 @@
 
   void HLayout::ComputeContentPosition(float offsetX, float offsetY)
   {
+    const bool ltr = GetDirection() == LeftToRight;
+    const int ltr_factor = ltr ? 1 : -1;
+
     std::list<Area *>::iterator it;
     {
       unsigned int num_element = 0;
@@ -773,22 +783,26 @@
       height -= (top_padding_ + bottom_padding_);
 
       // Objects have been resized, now position them.
-      int current_x = GetBaseX() + left_padding_ + offsetX; // add base offset in X(used for scrolling)
+      int current_x;
+      if (ltr)
+          current_x = GetBaseX() + left_padding_ + offsetX; // add base offset in X(used for scrolling)
+      else
+          current_x = GetBaseX() + GetBaseWidth() - right_padding_ + offsetX;
       int current_y = GetBaseY() + top_padding_ + offsetY; // add base offset in Y(used for scrolling)
 
       int offset_space = 0;
       int element_margin = 0;
       ComputeStacking(width, offset_space, element_margin);
-      current_x += offset_space;
+      current_x += ltr_factor * offset_space;
 
       for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
       {
         if (!(*it)->IsVisible())
           continue;
 
-        current_x += element_margin;
+        current_x += ltr_factor * element_margin;
 
-        (*it)->SetBaseX(current_x);
+        (*it)->SetBaseX(current_x - (!ltr ? (*it)->GetBaseWidth() : 0));
         (*it)->SetBaseY(current_y);
 
         MinorDimensionPosition positioning = (*it)->GetPositioning();
@@ -826,7 +840,7 @@
           }
         }
 
-        current_x += (*it)->GetBaseWidth() + element_margin + space_between_children_;
+        current_x += ltr_factor * ((*it)->GetBaseWidth() + element_margin + space_between_children_);
       }
     }
 
 
=== modified file 'Nux/HScrollBar.cpp'
--- Nux/HScrollBar.cpp	2011-10-17 20:57:35 +0000
+++ Nux/HScrollBar.cpp	2012-04-27 07:24:03 +0000
@@ -52,6 +52,7 @@
     m_RightTimerHandler = 0;
 
     hlayout = new HLayout(NUX_TRACKER_LOCATION);
+    hlayout->SetDirection(LeftToRight);
     _scroll_left_button = new InputArea(NUX_TRACKER_LOCATION);
     _track = new InputArea(NUX_TRACKER_LOCATION);
     _scroll_right_button = new InputArea(NUX_TRACKER_LOCATION);
@@ -302,6 +303,9 @@
 
   void HScrollBar::SetContentSize(int x, int y, int w, int h)
   {
+    if (GetDirection() == RightToLeft)
+      content_offset_x_ = w - container_width_ + content_offset_x_;
+
     // x and y are not needed
     content_width_ = w;
     content_height_ = h;
 
=== modified file 'Nux/Nux.cpp'
--- Nux/Nux.cpp	2011-12-29 18:06:53 +0000
+++ Nux/Nux.cpp	2012-04-27 07:24:03 +0000
@@ -379,4 +379,17 @@
     NThread *thread = GetWindowThread();
     return NUX_STATIC_CAST(WindowThread *, thread)->GetTimerHandler();
   }
+
+  static Direction defaultDirection = LeftToRight;
+
+  Direction GetDefaultDirection()
+  {
+    return defaultDirection;
+  }
+
+  void SetDefaultDirection(Direction direction)
+  {
+    defaultDirection = direction;
+  }
+
 }
 
=== modified file 'Nux/Nux.h'
--- Nux/Nux.h	2012-02-19 00:02:14 +0000
+++ Nux/Nux.h	2012-04-27 07:24:03 +0000
@@ -235,6 +235,9 @@
 
   inlDeclareThreadLocalStorage(NThread *, 0, ThreadLocal_InalogicAppImpl);
 
+  Direction GetDefaultDirection();
+  void SetDefaultDirection(Direction direction);
+
 }
 
 #endif // NUX_H
 
=== modified file 'Nux/RangeValue.cpp'
--- Nux/RangeValue.cpp	2012-01-17 04:34:19 +0000
+++ Nux/RangeValue.cpp	2012-04-27 07:24:03 +0000
@@ -92,11 +92,15 @@
   void RangeValue::DrawMarker(GraphicsEngine &graphics_engine)
   {
     int marker_position_x;
+    int relative_position_x;
     int marker_position_y;
 
     graphics_engine.PushClippingRectangle(m_Percentage->GetGeometry());
 
-    marker_position_x = m_Percentage->GetBaseX() + (m_Value - m_min) * m_Percentage->GetBaseWidth() * 1 / (m_max - m_min);
+    relative_position_x = (m_Value - m_min) * m_Percentage->GetBaseWidth() * 1 / (m_max - m_min);
+    if (GetDirection() == RightToLeft)
+      relative_position_x = m_Percentage->GetBaseWidth() - relative_position_x;
+    marker_position_x = m_Percentage->GetBaseX() + relative_position_x;
     marker_position_y = m_Percentage->GetBaseY() + m_Percentage->GetBaseHeight();
     GetPainter().Draw2DTriangleColor(graphics_engine, marker_position_x - 5, marker_position_y,
                                   marker_position_x, marker_position_y - 5,
@@ -121,6 +125,8 @@
     if (m_EnableDrawProgress)
     {
       P.SetWidth((m_Value - m_min) * (float) P.GetWidth() / (m_max - m_min));
+      if (GetDirection() == RightToLeft)
+        P.OffsetPosition(m_Percentage->GetBaseWidth() - P.GetWidth(), 0);
       GetPainter().Paint2DQuadColor(graphics_engine, P, m_ProgressColor);
     }
 
@@ -186,6 +192,9 @@
 ////////////////
   void RangeValue::OnReceiveMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
+    if (GetDirection() == RightToLeft)
+      x = m_Percentage->GetBaseWidth() - x;
+
     if (x < 0)
       m_Value = m_min;
     else if (x > m_Percentage->GetBaseWidth())
@@ -203,6 +212,8 @@
 
   void RangeValue::OnReceiveMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
+    if (GetDirection() == RightToLeft)
+      x = m_Percentage->GetBaseWidth() - x;
 
     if (x < 0)
       m_Value = m_min;
@@ -221,6 +232,9 @@
 
   void RangeValue::OnReceiveMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
   {
+    if (GetDirection() == RightToLeft)
+      x = m_Percentage->GetBaseWidth() - x;
+
     if (x < 0)
       m_Value = m_min;
     else if (x > m_Percentage->GetBaseWidth())
 
=== modified file 'Nux/ScrollView.cpp'
--- Nux/ScrollView.cpp	2011-12-13 08:20:18 +0000
+++ Nux/ScrollView.cpp	2012-04-27 07:24:03 +0000
@@ -316,6 +316,8 @@
   {
     // Give the managed layout the same size and position as the Control.
 
+    bool ltr = GetDirection() == LeftToRight;
+
     Geometry geo = GetGeometry();
     int ScrollBarWidth = _vscrollbar->GetBaseWidth();
     int ScrollBarHeight = _hscrollbar->GetBaseHeight();
@@ -324,6 +326,8 @@
     nuxAssertMsg(ScrollBarHeight > 0, "[ScrollView::PreLayoutManagement] Invalid scrollbar height: %d", ScrollBarHeight);
 
     m_ViewX = GetBaseX() + m_border + m_ViewContentLeftMargin;
+    if (!ltr)
+      m_ViewX += ScrollBarWidth;
     m_ViewY = GetBaseY() + m_top_border + m_ViewContentTopMargin;
 
     if (m_vertical_scrollbar_enable == false)
@@ -383,7 +387,10 @@
       else
         _hscrollbar->SetBaseWidth(GetBaseWidth() - ScrollBarWidth - 2 * m_border);
 
-      _hscrollbar->SetBaseX(geo.x + m_border);
+      if (ltr || !m_vertical_scrollbar_enable)
+        _hscrollbar->SetBaseX(geo.x + m_border);
+      else
+        _hscrollbar->SetBaseX(geo.x + m_border + ScrollBarWidth);
       _hscrollbar->SetBaseY(geo.y + geo.GetHeight() - _hscrollbar->GetBaseHeight() - m_border);
       _hscrollbar->ComputeContentSize();
     }
@@ -391,7 +398,10 @@
     {
       // The horizontal scrollbar won't be visible but give it a proper size anyway.
       _hscrollbar->SetBaseWidth(GetBaseWidth() - ScrollBarWidth - 2 * m_border);
-      _hscrollbar->SetBaseX(geo.x + m_border);
+      if (ltr)
+        _hscrollbar->SetBaseX(geo.x + m_border);
+      else
+        _hscrollbar->SetBaseX(geo.x + m_border + ScrollBarWidth);
       _hscrollbar->SetBaseY(geo.y + geo.GetHeight() - _hscrollbar->GetBaseHeight() - m_border);
       _hscrollbar->ComputeContentSize();
     }
@@ -408,7 +418,10 @@
       else
         _vscrollbar->SetBaseHeight(GetBaseHeight() - ScrollBarHeight - m_top_border - m_border);
 
-      _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollBarWidth - m_border);
+      if (ltr)
+        _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollBarWidth - m_border);
+      else
+        _vscrollbar->SetBaseX(geo.x + m_border);
       _vscrollbar->SetBaseY(geo.y + m_top_border);
       _vscrollbar->ComputeContentSize();
     }
@@ -416,7 +429,11 @@
     {
       // The vertical scrollbar won't be visible but give it a proper size anyway.
       _vscrollbar->SetBaseHeight(GetBaseHeight() - ScrollBarHeight - m_top_border - m_border);
-      _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollBarWidth - m_border);
+      if (ltr)
+        _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollBarWidth - m_border);
+      else
+        _vscrollbar->SetBaseX(geo.x + m_border);
+
       _vscrollbar->SetBaseY(geo.y + m_top_border);
       _vscrollbar->ComputeContentSize();
     }
@@ -510,6 +527,7 @@
   long ScrollView::PostLayoutManagement2(long LayoutResult)
   {
     // In case IsSizeMatchContent returns True, The scroll view is resized to match its content.
+    bool ltr = GetDirection() == LeftToRight;
     int ScrollbarWidth = 0;
     int ScrollbarHeight = 0;
 
@@ -564,7 +582,10 @@
       else
         _hscrollbar->SetBaseWidth(GetBaseWidth() - ScrollbarWidth - 2 * m_border);
 
-      _hscrollbar->SetBaseX(geo.x + m_border);
+      if (ltr || !m_vertical_scrollbar_enable)
+        _hscrollbar->SetBaseX(geo.x + m_border);
+      else
+        _hscrollbar->SetBaseX(geo.x + m_border + ScrollbarWidth);
       _hscrollbar->SetBaseY(geo.y + geo.GetHeight() - _hscrollbar->GetBaseHeight() - m_border);
       _hscrollbar->ComputeContentSize();
 
@@ -590,7 +611,10 @@
     else
     {
       _hscrollbar->SetBaseWidth(GetBaseWidth() - ScrollbarWidth - 2 * m_border);
-      _hscrollbar->SetBaseX(geo.x + m_border);
+      if (ltr)
+        _hscrollbar->SetBaseX(geo.x + m_border);
+      else
+        _hscrollbar->SetBaseX(geo.x + m_border + ScrollbarWidth);
       _hscrollbar->SetBaseY(geo.y + geo.GetHeight() - _hscrollbar->GetBaseHeight() - m_border);
       _hscrollbar->ComputeContentSize();
 
@@ -613,7 +637,10 @@
       else
         _vscrollbar->SetBaseHeight(GetBaseHeight() - ScrollbarHeight - m_top_border - m_border);
 
-      _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollbarWidth - m_border);
+      if (ltr)
+        _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollbarWidth - m_border);
+      else
+        _vscrollbar->SetBaseX(geo.x + m_border);
       _vscrollbar->SetBaseY(geo.y + m_top_border);
       _vscrollbar->ComputeContentSize();
 
@@ -639,7 +666,10 @@
     else
     {
       _vscrollbar->SetBaseHeight(GetBaseHeight() - ScrollbarHeight - m_top_border - m_border);
-      _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollbarWidth - m_border);
+      if (ltr)
+        _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - ScrollbarWidth - m_border);
+      else
+        _vscrollbar->SetBaseX(geo.x + m_border);
       _vscrollbar->SetBaseY(geo.y + m_top_border);
       _vscrollbar->ComputeContentSize();
 
@@ -667,6 +697,7 @@
 // This function is called when the ScrollView is embedded within a Layout.
   void ScrollView::ComputeContentPosition(float offsetX, float offsetY)
   {
+    bool ltr = GetDirection() == LeftToRight;
     Geometry geo = GetGeometry();
     int w = 0;
     int h = 0;
@@ -675,6 +706,8 @@
     h = _hscrollbar->GetBaseHeight();
 
     m_ViewX = GetBaseX() + m_border + m_ViewContentLeftMargin;
+    if (!ltr)
+      m_ViewX += w;
     m_ViewY = GetBaseY() + m_top_border + m_ViewContentTopMargin;
 
     if (m_vertical_scrollbar_enable == false)
@@ -712,7 +745,10 @@
       else
         _hscrollbar->SetBaseWidth(GetBaseWidth() - w - 2 * m_border);
 
-      _hscrollbar->SetBaseX(geo.x + m_border);
+      if (ltr || !m_vertical_scrollbar_enable)
+        _hscrollbar->SetBaseX(geo.x + m_border);
+      else
+        _hscrollbar->SetBaseX(geo.x + m_border + w);
       _hscrollbar->SetBaseY(geo.y + geo.GetHeight() - _hscrollbar->GetBaseHeight() - m_border);
       _hscrollbar->ComputeContentSize();
     }
@@ -725,7 +761,10 @@
       else
         _vscrollbar->SetBaseHeight(GetBaseHeight() - h - m_top_border - m_border);
 
-      _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - w - m_border);
+      if (ltr)
+        _vscrollbar->SetBaseX(geo.x + geo.GetWidth() - w - m_border);
+      else
+        _vscrollbar->SetBaseX(geo.x + m_border);
       _vscrollbar->SetBaseY(geo.y + m_top_border);
       _vscrollbar->ComputeContentSize();
     }
 
=== modified file 'Nux/VSplitter.cpp'
--- Nux/VSplitter.cpp	2011-12-06 16:29:06 +0000
+++ Nux/VSplitter.cpp	2012-04-27 07:24:03 +0000
@@ -118,6 +118,7 @@
     graphics_engine.PushClippingRectangle(GetGeometry());
     Geometry base = GetGeometry();
     bool need_redraw = IsRedrawNeeded();
+    bool ltr = GetDirection() == LeftToRight;
 
     std::vector<MySplitter *>::iterator it_splitter;
     std::vector<Area *>::iterator it;
@@ -127,10 +128,17 @@
          it++, it_splitter++)
     {
       Geometry sgeo = (*it_splitter)->GetGeometry();
-      graphics_engine.PushClippingRectangle(Rect(
-                                          base.x, base.y, sgeo.x - base.x, base.GetHeight()));
+      Rect clip;
+      if (ltr)
+        clip = Rect(base.x, base.y, sgeo.x - base.x, base.GetHeight());
+      else
+        clip = Rect(sgeo.x + sgeo.GetWidth(), base.y, base.x + base.GetWidth() - sgeo.x - sgeo.GetWidth(), base.GetHeight());
+      graphics_engine.PushClippingRectangle(clip);
 
-      base.SetX(sgeo.x + sgeo.GetWidth());
+      if (ltr)
+        base.SetX(sgeo.x + sgeo.GetWidth());
+      else
+        base.SetWidth(sgeo.x - base.x);
 
       if (force_draw || need_redraw)
       {
@@ -193,6 +201,7 @@
   void VSplitter::OverlayDrawing(GraphicsEngine &graphics_engine)
   {
     unsigned int num_element = (unsigned int) m_SplitterObject.size();
+    bool ltr = GetDirection() == LeftToRight;
 
     Geometry base = GetGeometry();
 
@@ -203,27 +212,33 @@
 
       if (m_focus_splitter_index == 0 && num_element > 1)
       {
-        if (geo.x < base.x)
+        if (( ltr && geo.x < base.x) ||
+            (!ltr && geo.x > base.x + base.GetWidth() - VSPLITTERWIDTH))
         {
-          geo.SetX(base.x);
+          geo.SetX(base.x + (ltr ? 0 : (base.GetWidth() - VSPLITTERWIDTH)));
         }
 
-        if (geo.x  + VSPLITTERWIDTH > m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x)
+        if (( ltr && geo.x + VSPLITTERWIDTH > m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x) ||
+            (!ltr && geo.x - VSPLITTERWIDTH < m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x))
         {
-          geo.SetX(m_SplitterObject[m_focus_splitter_index+1]->GetGeometry().x - VSPLITTERWIDTH);
+          geo.SetX(m_SplitterObject[m_focus_splitter_index+1]->GetGeometry().x + (ltr ? - VSPLITTERWIDTH : + VSPLITTERWIDTH));
         }
       }
 
       if ((m_focus_splitter_index > 0) && m_focus_splitter_index < (int) num_element - 1)
       {
-        if (geo.x < m_SplitterObject[m_focus_splitter_index - 1]->GetGeometry().x + VSPLITTERWIDTH)
+        if (( ltr && geo.x < m_SplitterObject[m_focus_splitter_index - 1]->GetGeometry().x + VSPLITTERWIDTH) ||
+            (!ltr && geo.x > m_SplitterObject[m_focus_splitter_index - 1]->GetGeometry().x - VSPLITTERWIDTH))
         {
-          geo.SetX(m_SplitterObject[m_focus_splitter_index - 1]->GetGeometry().x + VSPLITTERWIDTH);
+          geo.SetX(m_SplitterObject[m_focus_splitter_index - 1]->GetGeometry().x + 
+            (ltr ? VSPLITTERWIDTH : - VSPLITTERWIDTH));
         }
 
-        if (geo.x + VSPLITTERWIDTH > m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x)
+        if (( ltr && geo.x + VSPLITTERWIDTH > m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x) ||
+            (!ltr && geo.x - VSPLITTERWIDTH < m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x))
         {
-          geo.SetX(m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x - VSPLITTERWIDTH);
+          geo.SetX(m_SplitterObject[m_focus_splitter_index + 1]->GetGeometry().x +
+            (ltr ? - VSPLITTERWIDTH : VSPLITTERWIDTH));
         }
       }
 
@@ -265,6 +280,7 @@
 
   long VSplitter::ComputeContentSize()
   {
+    bool ltr = GetDirection() == LeftToRight;
     unsigned int num_element = (unsigned int) m_InterfaceObject.size();
     int x = GetBaseX();
     int y = GetBaseY();
@@ -312,7 +328,11 @@
     {
       int size_to_distribute = w - num_element * VSPLITTERWIDTH;
       int previous_spliter_end = m_current_x;
+      if (!ltr)
+        previous_spliter_end += m_current_width;
       int new_spliter_end = x;
+      if (!ltr)
+        new_spliter_end += w;
 
       for (unsigned int i = 0; i < num_element; i++)
       {
@@ -320,37 +340,64 @@
         // compute percentage of space occupied by the element i;
         // width of element i = m_SplitterObject[i]->GetX() - previous_splliter_end
         int splitter_start = m_SplitterObject[i]->GetBaseX();
+        if (!ltr)
+          splitter_start += VSPLITTERWIDTH;
         float percent = float(splitter_start - previous_spliter_end) / float(m_current_width - num_element * VSPLITTERWIDTH);
+        if (!ltr)
+          percent = -percent;
 
         if (percent > 1.0f)
           percent = 1.0f;
 
-        splitter_geo.SetX(new_spliter_end + size_to_distribute * percent);
-        previous_spliter_end = splitter_start + VSPLITTERWIDTH;
-        new_spliter_end = new_spliter_end + size_to_distribute * percent + VSPLITTERWIDTH;
+        if (ltr)
+        {
+          splitter_geo.SetX(new_spliter_end + size_to_distribute * percent);
+          previous_spliter_end = splitter_start + VSPLITTERWIDTH;
+          new_spliter_end = new_spliter_end + size_to_distribute * percent + VSPLITTERWIDTH;
+        }
+        else
+        {
+          splitter_geo.SetX(new_spliter_end - size_to_distribute * percent - VSPLITTERWIDTH);
+          previous_spliter_end = splitter_start - VSPLITTERWIDTH;
+          new_spliter_end = new_spliter_end - size_to_distribute * percent + VSPLITTERWIDTH;
+        }
         m_SplitterObject[i]->SetGeometry(splitter_geo);
       }
 
-      if (m_SplitterObject[0]->GetBaseX() < x)
+      if (ltr && m_SplitterObject[0]->GetBaseX() < x)
       {
         m_SplitterObject[0]->SetBaseX(x);
       }
+      else if (!ltr && m_SplitterObject[0]->GetBaseX() > x + w - VSPLITTERWIDTH)
+      {
+        m_SplitterObject[0]->SetBaseX(x + w - VSPLITTERWIDTH);
+      }
 
-      m_SplitterObject[num_element-1]->SetBaseX(x + w - VSPLITTERWIDTH);
+      if (ltr)
+        m_SplitterObject[num_element-1]->SetBaseX(x + w - VSPLITTERWIDTH);
+      else
+        m_SplitterObject[num_element-1]->SetBaseX(x);
     }
 
     int accwidth = x;
+    if (!ltr)
+      accwidth += w;
 
     for (unsigned int i = 0; i < num_element; i++)
     {
       Geometry splitter_geo = m_SplitterObject[i]->GetGeometry();
+      Geometry element_geo;
+      if (ltr)
+        element_geo = Geometry(accwidth, y, splitter_geo.x - accwidth, h);
+      else
+        element_geo = Geometry(splitter_geo.x + VSPLITTERWIDTH, y, accwidth - splitter_geo.x - VSPLITTERWIDTH, h);
 
-      //m_InterfaceObject[i]->SetGeometry(Geometry(accwidth, y, splitter_geo.x - accwidth, h));
+      //m_InterfaceObject[i]->SetGeometry(element_geo);
 
       if (m_InterfaceObject[i]->Type().IsDerivedFromType(View::StaticObjectType))
       {
         View *ic = NUX_STATIC_CAST(View *, m_InterfaceObject[i]);
-        ic->SetGeometry(Geometry(accwidth, y, splitter_geo.x - accwidth, h));
+        ic->SetGeometry(element_geo);
         // if we are already computing the layout from the main window down, we need to call
         // ComputeElementLayout to force the computing of this element layout.
         GetWindowThread()->ComputeElementLayout(ic);
@@ -358,18 +405,21 @@
       else if (m_InterfaceObject[i]->Type().IsObjectType(InputArea::StaticObjectType))
       {
         InputArea *base_area = NUX_STATIC_CAST(InputArea *, m_InterfaceObject[i]);
-        base_area->SetGeometry(Geometry(accwidth, y, splitter_geo.x - accwidth, h));
+        base_area->SetGeometry(element_geo);
       }
       else if (m_InterfaceObject[i]->Type().IsDerivedFromType(Layout::StaticObjectType))
       {
         Layout *layout = NUX_STATIC_CAST(Layout *, m_InterfaceObject[i]);
-        layout->SetGeometry(Geometry(accwidth, y, splitter_geo.x - accwidth, h));
+        layout->SetGeometry(element_geo);
         // if we are already computing the layout from the main window down, we need to call
         // ComputeElementLayout to force the computing of this element layout.
         GetWindowThread()->ComputeElementLayout(layout);
       }
 
-      accwidth += splitter_geo.x - accwidth + VSPLITTERWIDTH;
+      if (ltr)
+        accwidth += splitter_geo.x - accwidth + VSPLITTERWIDTH;
+      else
+        accwidth = splitter_geo.x;
     }
 
     m_current_height = h;
@@ -382,7 +432,10 @@
 
   void VSplitter::ResetSplitConfig()
   {
+    bool ltr = GetDirection() == LeftToRight;
     int x = GetBaseX();
+    if (!ltr)
+      x += GetBaseWidth();
     int y = GetBaseY();
     int w = GetBaseWidth();
     int h = GetBaseHeight();
@@ -420,12 +473,18 @@
     for (unsigned int i = 0; i < (unsigned int) m_SplitConfig.size(); i++)
     {
       stretchfactor = m_SplitConfig[i];
-      x += stretchfactor * max_size / max_stretch;
+      if (ltr)
+        x += stretchfactor * max_size / max_stretch;
+      else
+        x -= stretchfactor * max_size / max_stretch + VSPLITTERWIDTH;
       Geometry geo(x, y, VSPLITTERWIDTH, h);
       m_SplitterObject[i]->SetGeometry(geo);
     }
 
-    m_SplitterObject[num_element-1]->SetBaseX(x + w - VSPLITTERWIDTH);
+    if (ltr)
+      m_SplitterObject[num_element-1]->SetBaseX(GetBaseX() + w - VSPLITTERWIDTH);
+    else
+      m_SplitterObject[num_element-1]->SetBaseX(GetBaseX());
 
     m_initial_config = true;
   }
@@ -443,6 +502,7 @@
 
   void VSplitter::OnSplitterMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags, int header_pos)
   {
+    bool ltr = GetDirection() == LeftToRight;
     if (mvt_dx)
     {
       Geometry geo = m_SplitterObject[header_pos]->GetGeometry();
@@ -453,8 +513,9 @@
       if (header_pos < (int) num_element - 1)
       {
         // Make the splitter bar stick to the next one if the distance between them is less than VSTICK_SIZE
-        if (m_SplitterObject[header_pos + 1]->GetGeometry().x - geo.x - VSPLITTERWIDTH < VSTICK_SIZE)
-          geo.SetX( m_SplitterObject[header_pos + 1]->GetGeometry().x - VSPLITTERWIDTH );
+        if (( ltr && m_SplitterObject[header_pos + 1]->GetGeometry().x - geo.x - VSPLITTERWIDTH < VSTICK_SIZE) ||
+            (!ltr && m_SplitterObject[header_pos + 1]->GetGeometry().x - geo.x + VSPLITTERWIDTH > -VSTICK_SIZE))
+          geo.SetX( m_SplitterObject[header_pos + 1]->GetGeometry().x + (ltr ? - VSPLITTERWIDTH : + VSPLITTERWIDTH));
       }
 
       m_SplitterObject[header_pos]->SetGeometry(geo);
@@ -505,15 +566,22 @@
   {
     Geometry geo = m_SplitterObject[header_pos]->GetGeometry();
     int num_element = (int) m_SplitterObject.size();
+    bool ltr = GetDirection() == LeftToRight;
+    int leftmost_x  = GetBaseX();
+    int rightmost_x = GetBaseX() + GetBaseWidth() - VSPLITTERWIDTH;
 
-    if ((header_pos == 0) && (m_SplitterObject[header_pos]->GetBaseX() < GetBaseX()))
+    if ((header_pos == 0) && (
+      ( ltr && m_SplitterObject[header_pos]->GetBaseX() < leftmost_x) ||
+      (!ltr && m_SplitterObject[header_pos]->GetBaseX() > rightmost_x)))
     {
-      m_SplitterObject[header_pos]->SetBaseX(GetBaseX());
+      m_SplitterObject[header_pos]->SetBaseX(ltr ? leftmost_x : rightmost_x);
     }
 
-    if ((header_pos == num_element - 1) && (m_SplitterObject[header_pos]->GetBaseX() > GetBaseX() + GetBaseWidth() - VSPLITTERWIDTH))
+    if ((header_pos == num_element - 1) && (
+      ( ltr && m_SplitterObject[header_pos]->GetBaseX() > rightmost_x) ||
+      (!ltr && m_SplitterObject[header_pos]->GetBaseX() < leftmost_x)))
     {
-      m_SplitterObject[header_pos]->SetBaseX(GetBaseX() + GetBaseWidth() - VSPLITTERWIDTH);
+      m_SplitterObject[header_pos]->SetBaseX(ltr ? rightmost_x : leftmost_x);
     }
 
     if (header_pos < (int) num_element - 1)
@@ -522,9 +590,10 @@
       posx0 = m_SplitterObject[header_pos]->GetBaseX();
       posx1 = m_SplitterObject[header_pos + 1]->GetBaseX();
 
-      if (posx0 > posx1 - VSPLITTERWIDTH)
+      if (( ltr && posx0 > posx1 - VSPLITTERWIDTH) ||
+          (!ltr && posx0 < posx1 + VSPLITTERWIDTH))
       {
-        posx0 = posx1 - VSPLITTERWIDTH;
+        posx0 = posx1 + (ltr ? - VSPLITTERWIDTH : + VSPLITTERWIDTH);
         m_SplitterObject[header_pos]->SetBaseX(posx0);
       }
     }
@@ -535,9 +604,10 @@
       posx0 = m_SplitterObject[header_pos]->GetBaseX();
       posx1 = m_SplitterObject[header_pos - 1]->GetBaseX();
 
-      if (posx0 < posx1 + VSPLITTERWIDTH)
+      if (( ltr && posx0 < posx1 + VSPLITTERWIDTH) ||
+          (!ltr && posx0 > posx1 - VSPLITTERWIDTH))
       {
-        posx0 = posx1 + VSPLITTERWIDTH;
+        posx0 = posx1 + (ltr ? VSPLITTERWIDTH : - VSPLITTERWIDTH);
         m_SplitterObject[header_pos]->SetBaseX(posx0);
       }
     }
 
=== modified file 'tests/Helpers.cpp'
--- tests/Helpers.cpp	2011-07-15 04:00:00 +0000
+++ tests/Helpers.cpp	2012-04-27 07:24:03 +0000
@@ -25,11 +25,16 @@
 #include <fstream>
 #include <stdexcept>
 
+#include <Nux/Nux.h>
+
 namespace nux
 {
 namespace testing
 {
 
+nux::TimerFunctor* g_timer   = NULL;
+nux::TimerHandle   g_handler = NULL;
+
 std::string ReadFile(std::string const& filename)
 {
   std::ifstream input(filename.c_str());
@@ -47,6 +52,48 @@
   }
 }
 
-
-}
-}
+struct ThreadData
+{
+    TestFunc func;
+    nux::TimerFunctor* timer;
+    nux::TimerHandle   handler;
+
+    ThreadData(TestFunc func) : func(func), timer(NULL) {}
+};
+
+void
+terminate (void* data)
+{
+  nux::WindowThread* thread = NUX_STATIC_CAST (nux::WindowThread*, data);
+  thread->ExitMainLoop();
+}
+
+void
+init (nux::NThread* thread, void* data)
+{
+  TestFunc func = (TestFunc) data;
+
+  (func) ();
+
+  g_timer = new nux::TimerFunctor ();
+  g_timer->time_expires.connect (sigc::ptr_fun (&terminate));
+  g_handler = nux::GetTimer().AddTimerHandler (100,
+                                               g_timer,
+                                               nux::GetWindowThread ());
+}
+
+void
+run_test (TestFunc func)
+{
+  nux::WindowThread* wt = NULL;
+
+  wt = nux::CreateGUIThread (TEXT ("Canvas Test"), 400, 400, 0, &init, (void*) func);
+  wt->Run (NULL);
+  delete wt;
+  delete g_timer;
+  g_timer = NULL;
+}
+
+}
+}
+
 
=== modified file 'tests/Helpers.h'
--- tests/Helpers.h	2011-07-15 04:00:00 +0000
+++ tests/Helpers.h	2012-04-27 07:24:03 +0000
@@ -26,7 +26,6 @@
 #include <glib.h>
 #include <sigc++/sigc++.h>
 
-
 namespace nux
 {
 namespace testing
@@ -56,6 +55,8 @@
   bool happened;
 };
 
+typedef void (*TestFunc)(void);
+void run_test(TestFunc func);
 
 }
 }
 
=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2012-03-28 18:29:23 +0000
+++ tests/Makefile.am	2012-04-27 07:24:03 +0000
@@ -64,6 +64,8 @@
   -lboost_filesystem -lboost_system
 
 gtest_nux_SOURCES = \
+  Helpers.h \
+  Helpers.cpp \
   gtest-nux-area.cpp \
   gtest-nux-cairo-wrapper.cpp \
   gtest-nux-emmetrics.cpp \
@@ -72,7 +74,8 @@
   gtest-nux-textentry.cpp \
   gtest-nux-view.cpp \
   gtest-nux-windowcompositor.cpp \
-  gtest-nux-windowthread.cpp
+  gtest-nux-windowthread.cpp \
+  gtest-nux-hlayout.cpp
 
 gtest_nux_CPPFLAGS = \
   -I$(srcdir) \
 
=== modified file 'tests/gtest-nux-cairo-wrapper.cpp'
--- tests/gtest-nux-cairo-wrapper.cpp	2012-02-24 05:40:23 +0000
+++ tests/gtest-nux-cairo-wrapper.cpp	2012-04-27 07:24:03 +0000
@@ -26,10 +26,9 @@
 
 #include <iostream>
 
-typedef void (*TestFunc)(void);
+#include "Helpers.h"
 
-nux::TimerFunctor* g_timer   = NULL;
-nux::TimerHandle   g_handler = NULL;
+using nux::testing::run_test;
 
 void
 callback_one (nux::Geometry const& geom, cairo_t* cr)
@@ -70,39 +69,6 @@
 }
 
 void
-terminate (void* data)
-{
-  nux::WindowThread* thread = NUX_STATIC_CAST (nux::WindowThread*, data);
-  thread->ExitMainLoop();
-}
-
-void
-init (nux::NThread* thread, void* data)
-{
-  TestFunc func = (TestFunc) data;
-
-  (func) ();
-
-  g_timer = new nux::TimerFunctor ();
-  g_timer->time_expires.connect (sigc::ptr_fun (&terminate));
-  g_handler = nux::GetTimer().AddTimerHandler (100,
-                                               g_timer,
-                                               nux::GetWindowThread ());
-}
-
-void
-run_test (TestFunc func)
-{
-  nux::WindowThread* wt = NULL;
-
-  wt = nux::CreateGUIThread (TEXT ("Canvas Test"), 400, 400, 0, &init, (void*) func);
-  wt->Run (NULL);
-  delete wt;
-  delete g_timer;
-  g_timer = NULL;
-}
-
-void
 test_construction ()
 {
   nux::Geometry geom_one = {0, 0, 100, 100};
 
=== added file 'tests/gtest-nux-hlayout.cpp'
--- tests/gtest-nux-hlayout.cpp	1970-01-01 00:00:00 +0000
+++ tests/gtest-nux-hlayout.cpp	2012-04-27 07:24:03 +0000
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2011
+ *
+ * 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: Haggai Eran <[e-mail]>
+ *
+ */
+
+#include <gmock/gmock.h>
+
+#include "Nux/Nux.h"
+#include "Nux/HLayout.h"
+
+#include "Helpers.h"
+
+#include <iostream>
+#include <list>
+
+using namespace testing;
+using nux::testing::run_test;
+
+using nux::HLayout;
+using nux::Area;
+using nux::Geometry;
+
+using std::ostream;
+using std::list;
+
+namespace {
+
+ostream& operator<<(ostream& out, const Geometry& r)
+{
+  return out << "Geometry(" << r.x << ", " << r.y << ", " << r.width << ", " << r.height << ")";
+}
+
+list<Area*> fill_test_layout(HLayout* layout)
+{
+  EXPECT_THAT(layout, NotNull());
+
+  list<Area*> areas;
+
+  for (int i = 0; i < 3; ++i) 
+  {
+    Area* area = new Area(NUX_TRACKER_LOCATION);
+    EXPECT_THAT(area, NotNull());
+    area->SetMinimumSize(50, 60);
+    layout->AddView(area);
+    areas.push_back(area);
+  }
+
+  return areas;
+}
+
+void test_hlayout_ltr()
+{
+  nux::SetDefaultDirection(nux::LeftToRight);
+
+  HLayout* layout = new HLayout(NUX_TRACKER_LOCATION);
+  list<Area*> areas = fill_test_layout(layout);
+
+  Geometry geo(10,10,300,100);
+  layout->SetGeometry(geo);
+  layout->ComputeContentPosition(0, 0);
+
+  EXPECT_EQ(geo, layout->GetGeometry());
+
+  list<Area*>::const_iterator it = areas.begin();
+  for (int i = 0; it != areas.end(); ++i, ++it)
+  {
+    geo = Geometry(10 + 50 * i, 10, 50, 60);
+    EXPECT_EQ(geo, (*it)->GetGeometry());
+  }
+
+  layout->UnReference();
+}
+
+void test_hlayout_rtl()
+{
+  nux::SetDefaultDirection(nux::RightToLeft);
+
+  HLayout* layout = new HLayout(NUX_TRACKER_LOCATION);
+  list<Area*> areas = fill_test_layout(layout);
+
+  Geometry geo(10,10,300,100);
+  layout->SetGeometry(geo);
+  layout->ComputeContentPosition(0, 0);
+
+  EXPECT_EQ(geo, layout->GetGeometry());
+
+  list<Area*>::const_iterator it = areas.begin();
+  for (int i = 0; it != areas.end(); ++i, ++it)
+  {
+    geo = Geometry(310 - 50 * (i + 1), 10, 50, 60);
+    EXPECT_EQ(geo, (*it)->GetGeometry());
+  }
+
+  layout->UnReference();
+}
+
+TEST(TestHLayout, LTR) {
+  run_test(test_hlayout_ltr);
+}
+
+TEST(TestHLayout, RTL) {
+  run_test(test_hlayout_rtl);
+}
+
+}