Merge lp:~haggai-eran/nux/rtl-rebased into lp:nux/2.0

[Haggai Eran]

Add right-to-left mirroring support. Implement mirroring for HLayout.

Hi,

Here's my branch rebased against trunk. I hope the changes are more clear now.

There's still a problem with this patch to HLayout, though. When in right-to-left state, it packs child elements to the layout starting from the last on the list, instead of starting from the first, in order to get them in reverse order. However, it seems that for some of the widgets this doesn't work very well. I checked the CheckBox example, and the AbstractCheckedButton::ComputeContentSize code depends on the fact that the HLayout will first allocate space to the checkbox, and afterwards to the label. When using a right-to-left direction, the label is laid out first, and then the checkbox is positioned out of the widget's bounds.

Should I change my patch to pack the children in their logical order, starting from the rightmost edge, or should I leave the code as it is, and try to fix uses like the AbstractCheckedButton?

Regards,
Haggai

[Jay Taoko (jaytaoko)]

Haggai

Selecting right to left has to be done per layout. Lets say you have an horizontal layout that has a checkbox followed by a button, and the button is followed by a combobox. In LTR order you get this:
 checkbox | button | combobox

If you make the HLayout to be RTL then the content will look like this:

 combobox| button | checkbox

This should work out fine because only a specific HLayout has been been changed to RTL.

So you have to select only the layouts of the interface that need to be inverted. Rather than having SetDefaultDirection in Nux.cpp, it should be a function member of LinearLayout. Then for each layout (HLayout or VLayout), you will be able to decide if it goes from LTR or RTL. Individual views like the Checkbox, will remain un-affected.

How about that?

[Haggai Eran (haggai-eran)]

Jay,

I agree that we should be able to set directionality on per-layout basis. I even implemented it as a member of Area. However, I think that the default when using an RTL locale should be right to left, for all widgets, and not just specific HLayouts.

In the example you described, you could show the detailed widgets like this (in LTR):

[ combobox ↓ | button | [x] checkbox ]

Then, I expect the RTL rendering to be like this:

[ checkbox [x] | button | ↓ combobox ]

The internal layout of comboboxes and checkboxes should also be mirrored.

Please compare how GTK looks in LTR and RTL in the following two screenshots of the widget factory:
http://i44.tinypic.com/2lks0e8.jpg
http://i43.tinypic.com/25ri0ds.png

Haggai

[Jay Taoko (jaytaoko)]

Ok, I see how it is. I think many widget will have to have support for a RTL design.
But first we can get this branch in since it has global support for RTL at the layout level. Then the next step would be to go to each individual widgets that requires it and review the design.

It is up to me now to review and adapt this branch and see that we can merge it. We now have the requirement of proposing tests along side major features. Can you think of some way we can test the features of this branch?

[Haggai Eran (haggai-eran)]

Hi,

I think that perhaps rewriting the code to pack in the same order as in LTR might still have some advantages. I've tried to think on how that would work. Instead of walking the list of HLayout children in reverse, and packing them to the left, I'll walk the list in the usual order, and pack from right to left.

As far as I can see, I would only need to change HLayout::ComputeContentSize, and HLayout::ComputeContentPosition, which would make the changes simpler. I'm sure in both cases other widget will need to be modified, but if any widget's layout depends on the order of children's placement, then that order wouldn't change.

Regarding tests, I suppose that a tests for HLayout can be modified to test the RTL case as well, but I cannot find such a test (perhaps my tree isn't updated). I imagine a test that creates an HLayout, with several children that are using different settings for scaling, vertical placement, etc. and asserting there placement. What do you think?

Unmerged revisions

521. By Haggai Eran on 2011-11-14

Change LayoutContentDistribution only when in RTL mode.

520. By Haggai Eran on 2011-08-09

More HLayout changes toward right-to-left support.

519. By Haggai Eran on 2011-08-08

Add right-to-left mirroring support. Implement mirroring for HLayout.

=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2011-10-18 21:10:05 +0000
+++ Nux/Area.cpp	2011-11-14 21:17:09 +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())
   {
     visible_ = true;
     view_enabled_ = true;
@@ -1026,5 +1027,15 @@
 
     return false;
   }
+
+  Direction Area::GetDirection() const
+  {
+    return _direction;
+  }
+
+  void Area::SetDirection(Direction direction)
+  {
+    _direction = direction;
+  }
 }
 

=== modified file 'Nux/Area.h'
--- Nux/Area.h	2011-10-17 21:23:50 +0000
+++ Nux/Area.h	2011-11-14 21:17:09 +0000
@@ -140,6 +140,12 @@
     KEY_NAV_ENTER,
   };
 
+  typedef enum
+  {
+    LeftToRight,
+    RightToLeft
+  } Direction;
+
   class Layout;
   class View;
   class Area;
@@ -547,6 +553,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.
@@ -633,6 +647,8 @@
     bool                    _accept_mouse_wheel_event;
     bool                    _accept_keyboard_event;
 
+    Direction               _direction;
+
     friend class Layout;
     friend class View;
     friend class WindowThread;

=== modified file 'Nux/HLayout.cpp'
--- Nux/HLayout.cpp	2011-10-21 22:06:35 +0000
+++ Nux/HLayout.cpp	2011-11-14 21:17:09 +0000
@@ -127,7 +127,7 @@
       margin = 0;
     }
 
-    LayoutContentDistribution stacking = GetContentDistribution();
+    LayoutContentDistribution stacking = GetEffectiveContentDistribution();
 
     switch(stacking)
     {
@@ -178,6 +178,8 @@
     }
 
     std::list<Area *>::iterator it;
+    std::list<Area *>::reverse_iterator revit;
+    Area* area;
 
     for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
     {
@@ -248,19 +250,24 @@
       ComputeStacking(width, offset_space, space_after_element);
       current_x += offset_space;
 
-      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      revit = _layout_element_list.rbegin();
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
       {
-        if (!(*it)->IsVisible())
+        if (GetDirection() == LeftToRight)
+            area = *it;
+        else
+            area = *revit;
+        if (!area->IsVisible())
           continue;
 
         current_x += space_after_element;
 
-        (*it)->SetBaseX(current_x);
-        (*it)->SetBaseY(current_y);
+        area->SetBaseX(current_x);
+        area->SetBaseY(current_y);
 
-        MinorDimensionSize extend = (*it)->GetExtend();
-        MinorDimensionPosition positioning = (*it)->GetPositioning();
-        float percentage = (*it)->GetPercentage();
+        MinorDimensionSize extend = area->GetExtend();
+        MinorDimensionPosition positioning = area->GetPositioning();
+        float percentage = area->GetPercentage();
 
         // Compute the size of an ellement in the minor dimension(vertical)
         switch(extend)
@@ -270,7 +277,7 @@
             // The size of the processed element in the minor dimension is a percentage of layout minor dimension size.
             // Note that children of the processed element may force it to have a bigger size.
             int percentage_height = (height * percentage) / 100.0f;
-            (*it)->SetBaseHeight(percentage_height);
+            area->SetBaseHeight(percentage_height);
             break;
           }
 
@@ -278,7 +285,7 @@
           {
             // Force the element height to be the minimum has defined with SetMinimumHeight.
             // The children of this element can force it to get larger.
-            (*it)->ApplyMinHeight();
+            area->ApplyMinHeight();
             break;
           }
 
@@ -291,30 +298,30 @@
           case MINOR_SIZE_FULL:
           default:
           {
-            (*it)->SetBaseHeight(height);
+            area->SetBaseHeight(height);
             break;
           }
         }
 
         // Compute the position of an element in the minor dimension.
-        if ((*it)->GetBaseHeight() < height)
+        if (area->GetBaseHeight() < height)
         {
-          int widget_height = (*it)->GetBaseHeight();
+          int widget_height = area->GetBaseHeight();
 
           switch(positioning)
           {
             case MINOR_POSITION_START:
             {
               // do nothing
-              (*it)->SetBaseY(current_y);
+              area->SetBaseY(current_y);
               break;
             }
             case MINOR_POSITION_END:
             {
               if (widget_height < height)
-                (*it)->SetBaseY(current_y + height - widget_height);
+                area->SetBaseY(current_y + height - widget_height);
               else
-                (*it)->SetBaseY(current_y);
+                area->SetBaseY(current_y);
 
               break;
             }
@@ -323,14 +330,14 @@
             default:
             {
               if (widget_height < height)
-                (*it)->SetBaseY(current_y + (height - widget_height) / 2);
+                area->SetBaseY(current_y + (height - widget_height) / 2);
               else
-                (*it)->SetBaseY(current_y);
+                area->SetBaseY(current_y);
             }
           }
         }
 
-        current_x += (*it)->GetBaseWidth() + space_after_element + space_between_children_;
+        current_x += area->GetBaseWidth() + space_after_element + space_between_children_;
       }
 
       // Manage child layout
@@ -351,9 +358,15 @@
       // We check if that is the case and force a recompute.
       std::vector<int> FullSizeUnadjusted;
 
-      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      revit = _layout_element_list.rbegin();
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
       {
-        if (!(*it)->IsVisible())
+        if (GetDirection() == LeftToRight)
+          area = *it;
+        else
+          area = *revit;
+
+        if (!area->IsVisible())
           continue;
         bool smaller_height = false;
         bool larger_height  = false;
@@ -361,16 +374,16 @@
         bool smaller_width  = false;
         int ret = 0;
 
-        if (((*it)->IsLayout()  || (*it)->IsView()) /*&& ((*it)->IsLayoutDone() == false)*/ /*&& ((*it)->GetScaleFactor() != 0)*/)
+        if ((area->IsLayout()  || area->IsView()) /*&& (area->IsLayoutDone() == false)*/ /*&& (area->GetScaleFactor() != 0)*/)
         {
-          ret = (*it)->ComputeContentSize();
+          ret = area->ComputeContentSize();
 
           larger_width    = (ret & eLargerWidth)    ? true : false;
           smaller_width   = (ret & eSmallerWidth)   ? true : false;
           smaller_height  = (ret & eSmallerHeight)  ? true : false;
           larger_height   = (ret & eLargerHeight)   ? true : false;
 
-          if ((larger_width || smaller_width) && ((*it)->IsLayoutDone() == false))
+          if ((larger_width || smaller_width) && (area->IsLayoutDone() == false))
           {
             // Stop computing the size of this layout. Its size was not convenient to its children. So the children size take priority
             // over the layout. In ComputeContentSize, the dimension of the layout has been set so it encompasses its children(and the margins).
@@ -383,37 +396,37 @@
 
             {
               unadjusted_layout = true;
-              (*it)->SetLayoutDone(true);
+              area->SetLayoutDone(true);
             }
           }
 
-          if ((smaller_height == false) && ((*it)->GetExtend() == MINOR_SIZE_FULL) && ((*it)->GetBaseHeight() < (*it)->GetMaximumHeight()))
+          if ((smaller_height == false) && (area->GetExtend() == MINOR_SIZE_FULL) && (area->GetBaseHeight() < area->GetMaximumHeight()))
           {
             // We catch all object whose size is possibly larger than the layout. We check there size at the end and
             // recompute the layout if necessary.
             // For layout elements, make sure that the stretch factor is not 0. If it is, it means it will not use the
             // size provided by the parent layout. Its size will be adjusted to the minimum size of the layout content.
-            if (! ((*it)->IsLayout() && (*it)->GetScaleFactor() == 0))
-              FullSizeUnadjusted.push_back((*it)->GetBaseHeight());
+            if (! (area->IsLayout() && area->GetScaleFactor() == 0))
+              FullSizeUnadjusted.push_back(area->GetBaseHeight());
           }
 
-          if ((smaller_height || larger_height) && ((*it)->GetExtend() == MINOR_SIZE_MATCHCONTENT))
+          if ((smaller_height || larger_height) && (area->GetExtend() == MINOR_SIZE_MATCHCONTENT))
           {
-            (*it)->SetMinimumHeight((*it)->GetBaseHeight());
+            area->SetMinimumHeight(area->GetBaseHeight());
             unadjusted_layout = true;
           }
 
           // Should be reactivate so that if the parent Layout does not call
           // ComputeContentPosition, at least it is done here to arrange the internal
           // element of the children.
-          //(*it)->ComputeContentPosition(0,0);
+          //area->ComputeContentPosition(0,0);
         }
 
-        m_fittingWidth += (*it)->GetBaseWidth();
-
-        element_height = (*it)->GetBaseHeight();
-
-        if ((*it)->IsSpaceLayout() == false)
+        m_fittingWidth += area->GetBaseWidth();
+
+        element_height = area->GetBaseHeight();
+
+        if (area->IsSpaceLayout() == false)
         {
           if ((GetScaleFactor() != 0) /* && (ret & eSmallerHeight)*/)
           {
@@ -434,7 +447,7 @@
               m_contentHeight = element_height;
             }
 
-//                    else if ((*it)->GetExtend() == MINOR_SIZE_FULL)
+//                    else if (area->GetExtend() == MINOR_SIZE_FULL)
 //                    {
 //                        unadjusted_layout = true;
 //                    }
@@ -525,15 +538,22 @@
       int available_width = width;
       unsigned int max_stretchfactor = GetMaxStretchFactor();
       std::list<Area *>::iterator it;
+      std::list<Area *>::reverse_iterator revit;
+      Area* area;
 
-      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      revit = _layout_element_list.rbegin();
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
       {
-        if (!(*it)->IsVisible())
+        if (GetDirection() == LeftToRight)
+          area = *it;
+        else
+          area = *revit;
+        if (!area->IsVisible())
           continue;
 
-        if (((*it)->GetScaleFactor() == 0) && ((*it)->IsLayoutDone() != true))
+        if ((area->GetScaleFactor() == 0) && (area->IsLayoutDone() != true))
         {
-          (*it)->ApplyMinWidth();
+          area->ApplyMinWidth();
         }
       }
 
@@ -570,27 +590,32 @@
 
       if (available_width <= 2)
       {
-        for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+        revit = _layout_element_list.rbegin();
+        for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
         {
-          if (!(*it)->IsVisible())
+          if (GetDirection() == LeftToRight)
+            area = *it;
+          else
+            area = *revit;
+          if (!area->IsVisible())
             continue;
 
-          if (((*it)->GetScaleFactor() != 0) && (*it)->IsArea())
+          if ((area->GetScaleFactor() != 0) && area->IsArea())
           {
             // If it is not an object of type eInputArea, do not set layout_done_ to true,
             // so, the layout management function will later be called on the object.
-            (*it)->ApplyMinWidth();
-            (*it)->SetLayoutDone(true);
+            area->ApplyMinWidth();
+            area->SetLayoutDone(true);
           }
-          else if (((*it)->GetScaleFactor() != 0) && ((*it)->IsLayout()) && ((*it)->IsLayoutDone() == false)) // layout and not fixed by child
+          else if ((area->GetScaleFactor() != 0) && (area->IsLayout()) && (area->IsLayoutDone() == false)) // layout and not fixed by child
           {
             // The out of bound must be reset to false.
-            (*it)->ApplyMinWidth();
-            (*it)->SetLayoutDone(false);
+            area->ApplyMinWidth();
+            area->SetLayoutDone(false);
           }
-          else if (((*it)->GetScaleFactor() != 0) && ((*it)->IsLayoutDone() == false)) // layout and not fixed
+          else if ((area->GetScaleFactor() != 0) && (area->IsLayoutDone() == false)) // layout and not fixed
           {
-            (*it)->ApplyMinWidth();
+            area->ApplyMinWidth();
             // A layout must never have layout_done_ set to true "here" because it must continue
             // doing the layout of its children and finally resize itself to fit them.
             // The same way, A layout size factor should never be set to 0.
@@ -604,20 +629,26 @@
       Area *LastElementThatCanBeResized = 0;
       int total_distributed_size = 0;
 
-      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      revit = _layout_element_list.rbegin();
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
       {
-        if (!(*it)->IsVisible())
+        if (GetDirection() == LeftToRight)
+          area = *it;
+        else
+          area = *revit;
+        
+        if (!area->IsVisible())
           continue;
 
-        if (((*it)->GetScaleFactor() != 0) && ((*it)->IsLayoutDone() == false))
+        if ((area->GetScaleFactor() != 0) && (area->IsLayoutDone() == false))
         {
-          float sf = (float) (*it)->GetScaleFactor();
+          float sf = (float) area->GetScaleFactor();
           cumul += sf / max_stretchfactor;
-          LastElementThatCanBeResized = (*it);
+          LastElementThatCanBeResized = area;
         }
         else
         {
-          total_distributed_size += (*it)->GetBaseWidth();
+          total_distributed_size += area->GetBaseWidth();
         }
       }
 
@@ -633,14 +664,20 @@
 
       need_recompute = false;;
 
-      for (it = _layout_element_list.begin(); it != _layout_element_list.end() && !need_recompute; it++)
+      revit = _layout_element_list.rbegin();
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end() && !need_recompute; it++, revit++)
       {
-        if (!(*it)->IsVisible())
+        if (GetDirection() == LeftToRight)
+          area = *it;
+        else
+          area = *revit;
+
+        if (!area->IsVisible())
           continue;
         
-        if (((*it)->GetScaleFactor() != 0) && ((*it)->IsLayoutDone() == false))
+        if ((area->GetScaleFactor() != 0) && (area->IsLayoutDone() == false))
         {
-          unsigned int sf = (*it)->GetScaleFactor();
+          unsigned int sf = area->GetScaleFactor();
           int new_width;
 
           if (sf == max_stretchfactor)
@@ -654,7 +691,7 @@
 
           total_distributed_size += new_width;
 
-          if (LastElementThatCanBeResized == (*it))
+          if (LastElementThatCanBeResized == area)
           {
             // Redistribute the remaining size to the last element(at the right).
             // This is necessary because of imprecision. For instance if available_height = 451 and we have 2 elements
@@ -667,8 +704,8 @@
             }
           }
 
-          int elemt_max_width = (*it)->GetMaximumSize().width;
-          int elemt_min_width = (*it)->GetMinimumSize().width;
+          int elemt_max_width = area->GetMaximumSize().width;
+          int elemt_min_width = area->GetMinimumSize().width;
 
           // A layout must never have layout_done_ set to true "here" because it must continue
           // doing the layout of its children and finally resize itself to fit them.
@@ -679,22 +716,22 @@
           if (new_width < elemt_min_width)
           {
             // assume the minimum width
-            (*it)->SetBaseWidth(elemt_min_width);
+            area->SetBaseWidth(elemt_min_width);
 
-            if ((*it)->IsLayout() == false || (*it)->IsSpaceLayout())
+            if (area->IsLayout() == false || area->IsSpaceLayout())
             {
-              (*it)->SetLayoutDone(true);
+              area->SetLayoutDone(true);
               need_recompute = true;
             }
           }
           else if (new_width > elemt_max_width)
           {
             // assume the maximum width
-            (*it)->SetBaseWidth(elemt_max_width);
+            area->SetBaseWidth(elemt_max_width);
 
-            if ((*it)->IsLayout() == false || (*it)->IsSpaceLayout())
+            if (area->IsLayout() == false || area->IsSpaceLayout())
             {
-              (*it)->SetLayoutDone(true);
+              area->SetLayoutDone(true);
               need_recompute = true;
             }
 
@@ -706,7 +743,7 @@
           }
           else
           {
-            (*it)->SetBaseWidth(new_width);
+            area->SetBaseWidth(new_width);
           }
         }
         else
@@ -714,10 +751,10 @@
           // For fixed element, reset their size to the same so it is checked against
           // the min and max. This is necessary in case you have set the size of the element first then latter,
           // you define its MinimumSize and/or MaximumSize size.
-          unsigned int w = (*it)->GetBaseWidth();
-          unsigned int h = (*it)->GetBaseHeight();
-          (*it)->SetBaseWidth(w);
-          (*it)->SetBaseHeight(h);
+          unsigned int w = area->GetBaseWidth();
+          unsigned int h = area->GetBaseHeight();
+          area->SetBaseWidth(w);
+          area->SetBaseHeight(h);
         }
       }
     }
@@ -754,6 +791,8 @@
   void HLayout::ComputeContentPosition(float offsetX, float offsetY)
   {
     std::list<Area *>::iterator it;
+    std::list<Area *>::reverse_iterator revit;
+    Area* area;
     {
       unsigned int num_element = 0;
       for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
@@ -778,37 +817,42 @@
       ComputeStacking(width, offset_space, element_margin);
       current_x += offset_space;
 
-      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      revit = _layout_element_list.rbegin();
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
       {
-        if (!(*it)->IsVisible())
+        if (GetDirection() == LeftToRight)
+            area = *it;
+        else
+            area = *revit;
+        if (!area->IsVisible())
           continue;
 
         current_x += element_margin;
 
-        (*it)->SetBaseX(current_x);
-        (*it)->SetBaseY(current_y);
-
-        MinorDimensionSize extend = (*it)->GetExtend();
-        MinorDimensionPosition positioning = (*it)->GetPositioning();
-
-        if ((*it)->GetBaseHeight() < height)
+        area->SetBaseX(current_x);
+        area->SetBaseY(current_y);
+
+        MinorDimensionSize extend = area->GetExtend();
+        MinorDimensionPosition positioning = area->GetPositioning();
+
+        if (area->GetBaseHeight() < height)
         {
-          int widget_height = (*it)->GetBaseHeight();
+          int widget_height = area->GetBaseHeight();
 
           switch(positioning)
           {
             case MINOR_POSITION_START:
             {
               // do nothing
-              (*it)->SetBaseY(current_y);
+              area->SetBaseY(current_y);
               break;
             }
             case MINOR_POSITION_END:
             {
               if (widget_height < height)
-                (*it)->SetBaseY(current_y + height - widget_height);
+                area->SetBaseY(current_y + height - widget_height);
               else
-                (*it)->SetBaseY(current_y);
+                area->SetBaseY(current_y);
 
               break;
             }
@@ -817,29 +861,34 @@
             default:
             {
               if (widget_height < height)
-                (*it)->SetBaseY(current_y + (height - widget_height) / 2);
+                area->SetBaseY(current_y + (height - widget_height) / 2);
               else
-                (*it)->SetBaseY(current_y);
+                area->SetBaseY(current_y);
             }
           }
         }
 
-        current_x += (*it)->GetBaseWidth() + element_margin + space_between_children_;
+        current_x += area->GetBaseWidth() + element_margin + space_between_children_;
       }
     }
 
-    for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+    revit = _layout_element_list.rbegin();
+    for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++, revit++)
     {
-      if (!(*it)->IsVisible())
+      if (GetDirection() == LeftToRight)
+        area = *it;
+      else
+        area = *revit;
+      if (!area->IsVisible())
         continue;
 
-      if ((*it)->Type().IsDerivedFromType(Layout::StaticObjectType))
+      if (area->Type().IsDerivedFromType(Layout::StaticObjectType))
       {
-        (*it)->ComputeContentPosition(offsetX, offsetY);
+        area->ComputeContentPosition(offsetX, offsetY);
       }
-      else if ((*it)->Type().IsDerivedFromType(View::StaticObjectType))
+      else if (area->Type().IsDerivedFromType(View::StaticObjectType))
       {
-        (*it)->ComputeContentPosition(offsetX, offsetY);
+        area->ComputeContentPosition(offsetX, offsetY);
       }
     }
   }

=== modified file 'Nux/Layout.cpp'
--- Nux/Layout.cpp	2011-10-17 20:57:35 +0000
+++ Nux/Layout.cpp	2011-11-14 21:17:09 +0000
@@ -557,6 +557,22 @@
     return m_ContentStacking;
   }
 
+  LayoutContentDistribution Layout::GetEffectiveContentDistribution()
+  {
+    LayoutContentDistribution stacking = GetContentDistribution();
+    if (GetDirection() == LeftToRight)
+      return stacking;
+    switch (stacking)
+    {
+      case eStackLeft:
+        return eStackRight;
+      case eStackRight:
+        return eStackLeft;
+      default:
+        return stacking;
+    }
+  }
+
   void Layout::RequestBottomUpLayoutComputation(Area *bo_initiator)
   {
 

=== modified file 'Nux/Layout.h'
--- Nux/Layout.h	2011-10-10 01:52:00 +0000
+++ Nux/Layout.h	2011-11-14 21:17:09 +0000
@@ -201,6 +201,9 @@
     virtual void SetContentDistribution(LayoutContentDistribution stacking_order);
     virtual LayoutContentDistribution GetContentDistribution();
 
+    //! Switch the content distribution in case a RightToLeft direction is used
+    LayoutContentDistribution GetEffectiveContentDistribution();
+
     virtual bool FindWidget(Area *WidgetObject) const;
     virtual bool IsEmpty() const;
     /*

=== modified file 'Nux/Nux.cpp'
--- Nux/Nux.cpp	2011-11-10 17:28:44 +0000
+++ Nux/Nux.cpp	2011-11-14 21:17:09 +0000
@@ -349,4 +349,16 @@
     return NUX_STATIC_CAST(WindowThread *, thread)->GetGraphicsEngine();
   }
 
+  static Direction defaultDirection = LeftToRight;
+
+  Direction GetDefaultDirection()
+  {
+    return defaultDirection;
+  }
+
+  void SetDefaultDirection(Direction direction)
+  {
+    defaultDirection = direction;
+  }
+
 }

=== modified file 'Nux/Nux.h'
--- Nux/Nux.h	2011-10-21 22:06:35 +0000
+++ Nux/Nux.h	2011-11-14 21:17:09 +0000
@@ -150,6 +150,9 @@
 
   inlDeclareThreadLocalStorage(NThread *, 0, ThreadLocal_InalogicAppImpl);
 
+  Direction GetDefaultDirection();
+  void SetDefaultDirection(Direction direction);
+
 }
 
 #endif // NUX_H