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

[Haggai Eran]

Unity currently lacks support for right-to-left interface mirroring, for languages such as Hebrew and Arabic. These patches could facilitate such support. They add a GetDefaultDirection and SetDefaultDirection global function (modeled after GTK's gtk_widget_get_default_direction), and also GetDirection and SetDirection per Area.
The second patch implements interface mirroring for the HLayout class, when using a RightToLeft direction.

[Jay Taoko (jaytaoko)]

Thank you for your patch!

Before we can accept it, we require you to agree to inalogic's contributor agreement (http://inalogic.com/license). If you accept it, send and email to <email address hidden> and state that you agree.

[Haggai Eran (haggai-eran)]

Okay, I've sent the email.

[Jay Taoko (jaytaoko)]

thanks, got it!

[Jay Taoko (jaytaoko)]

Haggai,

Sorry that I haven’t been able to review your branch yet. The reason for that is Nux trunk is being stabilized in anticipation of the release of Ubuntu Oneiric. Once we branch Nux for the next release, I will review your branch.

Jay

[Haggai Eran (haggai-eran)]

  That's too bad. I was hoping to get my patches for unity 2d into Oneiric.

[lp:~haggai-eran/nux/rtl]

417. By Haggai Eran on 2011-10-15

Merged trunk.

418. By Haggai Eran on 2011-10-25

Merge trunk.

[Haggai Eran (haggai-eran)]

Hi,

Is there a chance you could review this branch for the Precise version? I would like to help Unity get RTL support in this version, especially since it is an LTS.

[Jay Taoko (jaytaoko)]

Sure, your branch is on the agenda. There have been substantial changes to Nux, so I will have to adapt your branch to it.

[Haggai Eran (haggai-eran)]

Thanks,
Let me know if I can help.

[Jay Taoko (jaytaoko)]

Haggai

From your patch, it appears that an HLayout will be able to process their content from Right to Left (rather than only from Left to Right as it is at the moment). However, I think that this will give the same result as the current processing. Or am I missing something?
Did you also meant to have elements filled inside an Hlayout from Right to Left? (Currently HLayout are filled from Left to Right).

Jay

[Haggai Eran (haggai-eran)]

Jay,

My intention was to have HLayout position it's elements from right to left (when in the right locale), instead of from left to right. This is similar to how GtkHBox behaves, for example.

I think that this is also what the implementation does. It starts with the last child in the HLayout's list, and lays it at the leftmost position, and then follows on to the previous child in the list, and so on.

Haggai

[Tim Penhey (thumper)]

This is an absolutely massive branch. I see that some of the changes are pure whitespace changes.

Can these please be broken out separately from any actual code changes. Thanks.

review: Needs Fixing

[Jay Taoko (jaytaoko)]

I am working on that branch. It isn't massive actually once you re-base it with on nux trunk. Only a few files have changed.

[Jay Taoko (jaytaoko)]

Haggai

In the case of the Hlayout, the first element that is added to the list will be the left-most element inside the Hlayout. You are proposing that the first element added to the Hlayout, be the right-most element inside the HLayout. And when processing the sizes of the HLayout elements, we either start from left or right depending on the direction option you have added. Is that correct?

Can you re-base this branch on Nux trunk? Your changes will be more obvious. I believe you only have a few files that are different from Nux trunk.

[Haggai Eran (haggai-eran)]

Jay, you are correct. In fact, when in right-to-left locale, I replaced the content distribution enum values, so that if it is set to eStackLeft, elements would actually be aligned to the right, and vice versa. Most of the changes in HLayout just change the order in which elements are packed.

I'll gladly rebase the branch. I probably should have done that in the first place, instead of merging the trunk, but I'm a little bit new to bazaar and launchpad. Should I use push --override to upload the results, or just create a new branch?

[Jason Smith (jassmith)]

It is almost always better to create a new branch rather than do a bzr push --override. Sorry about the delayed answer. Seems your review got lost in the holiday shuffle.

[Haggai Eran (haggai-eran)]

Thanks Jason. Eventually, I did create a new branch (lp:~haggai-eran/nux/rtl-rebased), but before it was merged I thought of a better way to implement the patch, so I created yet another branch (lp:~haggai-eran/nux/rtl-logical-packing). I thought I should delete this merge proposal, but launchpad said it would delete all the discussion, so I wasn't sure if that was the right thing to do.

Unmerged revisions

418. By Haggai Eran on 2011-10-25

Merge trunk.

417. By Haggai Eran on 2011-10-15

Merged trunk.

416. By Haggai Eran on 2011-08-13

Merged trunk changes.

415. By Haggai Eran on 2011-08-09

More HLayout changes toward right-to-left support.

414. By Haggai Eran on 2011-08-08

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

=== modified file 'Nux/AbstractButton.cpp'
--- Nux/AbstractButton.cpp	2011-10-05 20:56:39 +0000
+++ Nux/AbstractButton.cpp	2011-10-25 21:32:25 +0000
@@ -22,7 +22,7 @@
 
 #include "Nux.h"
 #include "AbstractButton.h"
-#include "HLayout.h"
+#include "StaticText.h"
 
 namespace nux
 {
@@ -30,20 +30,15 @@
 
   AbstractButton::AbstractButton(NUX_FILE_LINE_DECL)
   : View(NUX_FILE_LINE_PARAM)
-  , state(NUX_STATE_NORMAL)
-  {
-    active = false;
-    togglable_ = false;
-    Init();
-  }
-
-  AbstractButton::~AbstractButton()
-  {
-
-  }
-
-  void AbstractButton::Init()
-  {
+  , visual_state_(VISUAL_STATE_NORMAL)
+  {
+    active_ = false;
+    mouse_pressed_ = false;
+    static_text_ = NULL;
+    label_color_ = color::White;
+    same_size_as_content_ = false;
+    label_font_size_ = 12;
+
     mouse_click.connect(sigc::mem_fun(this, &AbstractButton::RecvClick));
     mouse_down.connect(sigc::mem_fun(this, &AbstractButton::RecvMouseDown));
     mouse_double_click.connect(sigc::mem_fun(this, &AbstractButton::RecvMouseDown));
@@ -53,50 +48,50 @@
     mouse_leave.connect(sigc::mem_fun(this, &AbstractButton::RecvMouseLeave));
   }
 
-  long AbstractButton::ProcessEvent(IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
-  {
-    return PostProcessEvent2 (ievent, TraverseInfo, ProcessEventInfo);
-  }
-
-  void AbstractButton::RecvClick(int x, int y, unsigned long button_flags, unsigned long key_flags)
-  {
-    if (!IsViewActive())
-      return;
-
-    if(togglable_)
-    {
-      active = !active;
-    }
+  AbstractButton::~AbstractButton()
+  {
+
+  }
+
+  bool AbstractButton::Active() const
+  {
+    return active_;
+  }
+
+  void AbstractButton::SetActive(bool active)
+  {
+    if (active)
+      Activate();
     else
-    {
-      active = true;
-    }
-
-    if(togglable_ == false)
-    {
-      active = false;
-    }
-
-    activated.emit(this);
-    QueueDraw();
+      Deactivate();
+  }
+
+  ButtonVisualState AbstractButton::GetVisualState()
+  {
+    return visual_state_;
   }
 
   void AbstractButton::RecvMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
-    if (!IsViewActive())
-      return;
+    if (IsMousePointerInside())
+    {
+      visual_state_ = VISUAL_STATE_PRELIGHT;
+    }
+    else
+    {
+      visual_state_ = VISUAL_STATE_NORMAL;
+    }
 
-    state = NUX_STATE_PRELIGHT;
-    //state = 1;
+    mouse_pressed_ = false;
+    visual_state_change.emit(this);
     QueueDraw();
   }
 
   void AbstractButton::RecvMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
-    if (!IsViewActive())
-      return;
-
-    state = NUX_STATE_ACTIVE;
+    visual_state_ = VISUAL_STATE_PRESSED;
+    mouse_pressed_ = true;
+    visual_state_change.emit(this);
     QueueDraw();
   }
 
@@ -107,13 +102,54 @@
 
   void AbstractButton::RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
-    state = NUX_STATE_PRELIGHT;
+    if (mouse_pressed_)
+    {
+      visual_state_ = VISUAL_STATE_PRESSED;
+    }
+    else
+    {
+      visual_state_ = VISUAL_STATE_PRELIGHT;
+    }
+
+    visual_state_change.emit(this);
     QueueDraw();
   }
 
   void AbstractButton::RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
-    state = NUX_STATE_NORMAL;
-    QueueDraw();
+    visual_state_ = VISUAL_STATE_NORMAL;
+    visual_state_change.emit(this);
+    QueueDraw();
+  }
+
+  void AbstractButton::SetLabelColor(const Color &color)
+  {
+    label_color_ = color;
+    if (static_text_)
+      static_text_->SetTextColor(label_color_);
+    QueueDraw();
+  }
+
+  Color AbstractButton::GetLabelColor()
+  {
+    return label_color_;
+  }
+
+  ButtonVisualState AbstractButton::GetVisualState() const
+  {
+    return visual_state_;
+  }
+
+  void AbstractButton::SetLabelFontSize(int point)
+  {
+    if (point < 0)
+      return;
+
+    label_font_size_ = point;
+  }
+
+  int AbstractButton::GetLabelFontSize() const
+  {
+    return label_font_size_;
   }
 }
 
=== modified file 'Nux/AbstractButton.h'
--- Nux/AbstractButton.h	2011-09-20 06:03:43 +0000
+++ Nux/AbstractButton.h	2011-10-25 21:32:25 +0000
@@ -27,47 +27,118 @@
 
 namespace nux
 {
-  enum State
+  class StaticText;
+
+  enum ButtonVisualState
   {
-    NUX_STATE_ACTIVE = 0,
-    NUX_STATE_NORMAL = 1,
-    NUX_STATE_PRELIGHT = 2,
-    NUX_STATE_SELECTED = 3,
-    NUX_STATE_INSENSITIVE = 4
+    VISUAL_STATE_PRESSED = 0,
+    VISUAL_STATE_NORMAL = 1,
+    VISUAL_STATE_PRELIGHT = 2,
+    VISUAL_STATE_DISABLED = 3
   };
 
-  //! The base class of Button widgets.
+  //! The base class of button type widgets.
+  /*!
+      AbstractButton is the direct base class of Button, CheckBox and RadioButton. It is a base class for ToggleButton.
+  */
   class AbstractButton : public View
   {
     NUX_DECLARE_OBJECT_TYPE(AbstractButton, View);
   public:
     AbstractButton(NUX_FILE_LINE_PROTO);
-    ~AbstractButton();
-
-    //! Signal emitted when the button is activated.
-    Property<bool> active;
-
-    //! Signal emitted when the button is activated.
-    sigc::signal<void, AbstractButton*> activated;
+    virtual ~AbstractButton();
+
+    sigc::signal<void, AbstractButton*> visual_state_change;
+
+    //! Returns the visual state of the AbstractButton
+    /*!
+        Returns the visual state of the AbstractButton.
+
+        @return The visual state of the AbstractButton.
+    */
+    ButtonVisualState GetVisualState();
+
+    //! Return the active state of the button.
+    /*!
+        Return the active state of the button. A Button has a non-persistent active state. It always returns false.
+        CheckBox, RadionButton and ToggleButton return true if they are active.
+
+        @return True if the button object is in an active state.
+    */
+    bool Active() const;
+
+    //! Activate the button.
+    /*!
+         Activate the button. If this object is a Button, then it has no persistent state and the function does nothing.
+    */
+    virtual void Activate() = 0;
+
+    //! Deactivate the button.
+    /*!
+         Deactivate the button. If this object is a Button, then it has no persistent state and the function does nothing.
+    */
+    virtual void Deactivate() = 0;
+
+    //! Set the state of the button.
+    /*!
+        Set the sate of the button. The button is either activated or deactivated.
+
+        @param active The button state.
+    */
+    virtual void SetActive(bool active);
+
+    //! Set the text color.
+    /*!
+        Set the text color.
+
+        @param color the text color.
+    */
+    void SetLabelColor(const Color &color);
+
+    //! Get the text color.
+    /*!
+        Get the text color.
+
+        @return The text color.
+    */
+    Color GetLabelColor();
+
+    //! Get the button visual state.
+    /*!
+        Get the button visual state.
+
+        @return The button visual state.
+    */
+    ButtonVisualState GetVisualState() const;
+
+    virtual void SetLabelFontSize(int point);
+    int GetLabelFontSize() const;
 
   protected:
-    bool togglable_;
-
-    //! Button state property.
-    // FIXME: Should be read only.
-    nux::Property<State> state;
-
-    virtual long ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
-
-    void RecvMouseUp    (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseDown  (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseMove  (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvClick      (int x, int y, unsigned long button_flags, unsigned long key_flags);
-
-  private:
-    void Init ();
+    //! The state of the AbstractButton. 
+    bool active_;
+
+    bool mouse_pressed_;
+
+    //! Visual state of the button object.
+    ButtonVisualState visual_state_;
+
+
+    // Common attribute for all the classes that inherit from AbstractButton.
+    std::string label_;
+    Color label_color_;
+    StaticText *static_text_;
+    int label_font_size_;
+    bool same_size_as_content_;
+    int pre_layout_width_;
+    int pre_layout_height_;
+
+    virtual void RecvMouseUp    (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    virtual void RecvMouseDown  (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    virtual void RecvMouseMove  (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
+    virtual void RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags);
+    virtual void RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags);
+    virtual void RecvClick      (int x, int y, unsigned long button_flags, unsigned long key_flags) = 0;
   };
 }
 
 
=== added file 'Nux/AbstractCheckedButton.cpp'
--- Nux/AbstractCheckedButton.cpp	1970-01-01 00:00:00 +0000
+++ Nux/AbstractCheckedButton.cpp	2011-10-25 21:32:25 +0000
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2010 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *
+ */
+
+
+#include "Nux.h"
+#include "HLayout.h"
+#include "AbstractCheckedButton.h"
+#include "StaticText.h"
+
+namespace nux
+{
+  NUX_IMPLEMENT_OBJECT_TYPE(AbstractCheckedButton);
+  
+  AbstractCheckedButton::AbstractCheckedButton(const std::string &str, bool state, NUX_FILE_LINE_DECL)
+    : AbstractButton(NUX_FILE_LINE_PARAM)
+  {
+    label_ = str;
+    active_ = state;
+    hlayout_ = 0;
+
+    static_text_  = new StaticText(label_, NUX_TRACKER_LOCATION);
+    static_text_->SetTextColor(label_color_);
+    hlayout_      = new HLayout(NUX_TRACKER_LOCATION);
+    check_area_   = new InputArea(NUX_TRACKER_LOCATION);
+
+    check_area_->SetInputEventSensitivity(false);
+    static_text_->SetInputEventSensitivity(false);
+
+    // Set Geometry
+    check_area_->SetMinMaxSize(14, 14);
+
+    hlayout_->SetSpaceBetweenChildren(4);
+    hlayout_->SetContentDistribution(MAJOR_POSITION_LEFT);
+    hlayout_->AddView(check_area_, 0, MINOR_POSITION_CENTER, MINOR_SIZE_MATCHCONTENT);
+    hlayout_->AddView(static_text_, 1, MINOR_POSITION_CENTER, MINOR_SIZE_MATCHCONTENT);
+
+//     // This is convenient to make the layout and the AbstractCheckedButton fit the check area and the caption area.
+//     // Since the check area is bigger than 4x4, it will force the layout and the AbstractCheckedButton to grow.
+//     // This is useful if the AbstractCheckedButton is put in a vertical layout and it has a stretch factor of 0. Then the width of the AbstractCheckedButton
+//     // will be adjusted to fit the minimum width of the check area and the caption area.
+//     {
+//       hlayout_->SetMinimumSize(1, 1);
+//       SetMinimumSize(14, 14);
+//       ApplyMinWidth();
+//       ApplyMinHeight();
+//     }
+
+    hlayout_->SetScaleFactor(0);
+    SetLayout(hlayout_);
+
+  }
+
+  AbstractCheckedButton::~AbstractCheckedButton()
+  {
+  }
+
+  void AbstractCheckedButton::SetLabel(const std::string &checkbox_label)
+  {
+    label_ = checkbox_label;
+    static_text_->SetText(label_);
+    QueueDraw();
+  }
+
+  std::string AbstractCheckedButton::GetLabel() const
+  {
+    return label_;
+  }
+
+  void AbstractCheckedButton::Draw(GraphicsEngine &graphics_engine, bool force_draw)
+  {
+    Geometry base = GetGeometry();
+    graphics_engine.PushClippingRectangle(base);
+
+    GetPainter().PaintBackground(graphics_engine, base);
+
+    InteractState is;
+    is.is_on = active_;
+
+    if (visual_state_ == VISUAL_STATE_PRESSED)
+    {
+      is.is_focus = true;
+    }
+    else if (visual_state_ == VISUAL_STATE_PRELIGHT)
+    {
+      is.is_prelight = true;
+    }
+    else
+    {
+      is.is_focus = false;
+      is.is_prelight = false;
+    }
+
+    GetPainter().PushPaintLayerStack();
+    {
+      GetPainter().PaintCheckBox(graphics_engine, check_area_->GetGeometry(), is, Color(0xff000000));
+      static_text_->ProcessDraw(graphics_engine, true);
+    }
+    GetPainter().PopPaintLayerStack();
+
+    graphics_engine.PopClippingRectangle();
+  }
+
+  long AbstractCheckedButton::ComputeContentSize()
+  {
+    if (view_layout_)
+    {
+      PreLayoutManagement();
+
+      int old_width = GetBaseWidth();
+      int old_height = GetBaseHeight();
+
+      // Let the text view be as large as possible.
+      static_text_->SetMaximumWidth(AREA_MAX_WIDTH);
+
+      // Constrain the vertical expansion of the color selector.
+      view_layout_->SetBaseHeight(1);
+      long ret = view_layout_->ComputeContentSize();
+
+      PostLayoutManagement(ret);
+
+      {
+        // Check if the text view goes out of the AbstractCheckedButton area.
+        Geometry base = GetGeometry();
+        Geometry text_geo = static_text_->GetGeometry();
+ 
+        // Intersect the AbstractCheckedButton and the text view
+        Geometry intersection = base.Intersect(text_geo);
+        if (intersection != text_geo)
+        {
+          // The text view goes outside of the AbstractCheckedButton area. We have to clip it
+          static_text_->SetMaximumWidth(intersection.width);
+
+          // Assign a size of 1 to the layout and call ComputeContentSize.
+          // Inside the StaticText::ComputeContentSize there is code that takes care of size negociation.
+          view_layout_->SetBaseWidth(1);
+          ret = view_layout_->ComputeContentSize();
+
+          // Assign the layout geometry to the AbstractCheckedButton view.
+          PostLayoutManagement(ret);
+        }
+      }
+
+      int new_width = GetBaseWidth();
+      int new_height = GetBaseHeight();
+
+      long size_compliance = 0;
+
+      // The layout has been resized to tightly pack its content
+      if (new_width > old_width)
+      {
+        size_compliance |= eLargerWidth; // need scrollbar
+      }
+      else if (new_width < old_width)
+      {
+        size_compliance |= eSmallerWidth;
+      }
+      else
+      {
+        size_compliance |= eCompliantWidth;
+      }
+
+      // The layout has been resized to tightly pack its content
+      if (new_height > old_height)
+      {
+        size_compliance |= eLargerHeight; // need scrollbar
+      }
+      else if (new_height < old_height)
+      {
+        size_compliance |= eSmallerHeight;
+      }
+      else
+      {
+        size_compliance |= eCompliantHeight;
+      }
+
+      return size_compliance;
+    }
+    else
+    {
+      PreLayoutManagement();
+      int ret = PostLayoutManagement(eCompliantHeight | eCompliantWidth);
+      return ret;
+    }
+
+    return 0;
+  }
+
+  void AbstractCheckedButton::SetLabelFontSize(int point)
+  {
+    AbstractButton::SetLabelFontSize(point);
+    if (static_text_ == NULL)
+      return;
+    
+    static_text_->SetTextPointSize(point);
+    
+    ComputeContentSize();
+    QueueDraw();
+  }
+}
 
=== added file 'Nux/AbstractCheckedButton.h'
--- Nux/AbstractCheckedButton.h	1970-01-01 00:00:00 +0000
+++ Nux/AbstractCheckedButton.h	2011-10-25 21:32:25 +0000
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2010 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *
+ */
+
+
+#ifndef ABSTRACTCHECKEDBUTTON_H
+#define ABSTRACTCHECKEDBUTTON_H
+
+#include "AbstractButton.h"
+
+namespace nux
+{
+  class HLayout;
+  class InputArea;
+  class StaticText;
+
+  //! AbstractCheckedButton class
+  /*!
+      Acts as a base class for CheckBox and radioButton.\n
+  */
+  class AbstractCheckedButton: public AbstractButton
+  {
+    NUX_DECLARE_OBJECT_TYPE(AbstractCheckedButton, AbstractButton);
+  public:
+    AbstractCheckedButton(const std::string &str, bool state = false, NUX_FILE_LINE_PROTO);
+    virtual ~AbstractCheckedButton();
+
+    //! Emitted when the button is clicked.
+    sigc::signal<void, AbstractCheckedButton*> click;
+
+    //! Emitted when the active state changes.
+    /*!
+        Emitted when the active state changes, as a result of a mouse click or an API call.\n
+        \sa Activate, Deactivate.
+    */
+    sigc::signal<void, AbstractCheckedButton*> state_change;
+
+    //! Set the label.
+    /*!
+        Set the label of this AbstractCheckedButton. If the \a label argument is an empty string, then the the AbstractCheckedButton label is destroyed,
+        and the content of the AbstractCheckedButton is re-arranged accordingly.
+
+        @param label The label of the AbstractCheckedButton.
+    */
+    void SetLabel(const std::string &checkbox_label);
+
+    //!Return the label of this AbstractCheckedButton.
+    /*!
+        Return the label of this AbstractCheckedButton.
+
+        @return The AbstractCheckedButton label string.
+    */
+    std::string GetLabel() const;
+
+    //! Activate the check box.
+    /*!
+         Activate the check box.
+    */
+    virtual void Activate() = 0;
+
+    //! Deactivate the check box.
+    /*!
+         Deactivate the check box.
+    */
+    virtual void Deactivate() = 0;
+
+    virtual void SetLabelFontSize(int point);
+
+  protected:
+    virtual void Draw(GraphicsEngine &graphics_engine, bool force_draw) = 0;
+    virtual void RecvClick(int x, int y, unsigned long button_flags, unsigned long key_flags) = 0;
+    virtual long ComputeContentSize();
+
+    HLayout   *hlayout_;
+    InputArea *check_area_;
+
+  private:
+    //! Override of Area::SetMinimumHeight and made private.
+    /*!
+        Prevent changing the minimum height of the StaticText view.
+    */
+    virtual void SetMinimumHeight(){};
+
+    //! Override of Area::SetMaximumHeight and made private.
+    /*!
+        Prevent changing the maximum height of the StaticText view.
+    */
+    virtual void SetMaximumHeight(){};
+  };
+
+}
+
+#endif // ABSTRACTCHECKEDBUTTON_H
 
=== modified file 'Nux/AbstractComboBox.cpp'
--- Nux/AbstractComboBox.cpp	2011-09-20 06:03:43 +0000
+++ Nux/AbstractComboBox.cpp	2011-10-25 21:32:25 +0000
@@ -28,94 +28,94 @@
 namespace nux
 {
 
-  Color AbstractComboBox::m_sCOMBO_COLOR = Color (0x009F9F00);
-  Color AbstractComboBox::m_sCOMBO_BUTTON_COLOR = Color (0x00FFFFFF);
-  Color AbstractComboBox::m_sCOMBO_MOUSEOVER_COLOR = Color (0x55FFFFFF);
+  Color AbstractComboBox::m_sCOMBO_COLOR = Color(0x009F9F00);
+  Color AbstractComboBox::m_sCOMBO_BUTTON_COLOR = Color(0x00FFFFFF);
+  Color AbstractComboBox::m_sCOMBO_MOUSEOVER_COLOR = Color(0x55FFFFFF);
 
-  AbstractComboBox::AbstractComboBox (NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-    ,   m_MenuIsActive (false)
+  AbstractComboBox::AbstractComboBox(NUX_FILE_LINE_DECL)
+    :   View(NUX_FILE_LINE_PARAM)
+    ,   m_MenuIsActive(false)
   {
     m_hlayout   = new HLayout(NUX_TRACKER_LOCATION);
     _combo_box_area = new InputArea(NUX_TRACKER_LOCATION);
     _combo_box_opening_area    = new InputArea(NUX_TRACKER_LOCATION);
 
-    m_hlayout->AddView (_combo_box_area, 1);
-    m_hlayout->AddView (_combo_box_opening_area, 0);
-    m_hlayout->SetHorizontalExternalMargin (0);
-    m_hlayout->SetVerticalExternalMargin (0);
-    SetLayout (m_hlayout);
-
-    _combo_box_area->mouse_enter.connect (sigc::mem_fun (this, &AbstractComboBox::RecvMouseEnter) );
-    _combo_box_area->mouse_leave.connect (sigc::mem_fun (this, &AbstractComboBox::RecvMouseLeave) );
-
-    _combo_box_opening_area->mouse_enter.connect (sigc::mem_fun (this, &AbstractComboBox::RecvMouseEnter) );
-    _combo_box_opening_area->mouse_leave.connect (sigc::mem_fun (this, &AbstractComboBox::RecvMouseLeave) );
-
-    SetTextColor (color::Black);
-
-    _pango_static_text = new StaticText (TEXT(""), NUX_TRACKER_LOCATION);
+    m_hlayout->AddView(_combo_box_area, 1);
+    m_hlayout->AddView(_combo_box_opening_area, 0);
+    m_hlayout->SetHorizontalExternalMargin(0);
+    m_hlayout->SetVerticalExternalMargin(0);
+    SetLayout(m_hlayout);
+
+    _combo_box_area->mouse_enter.connect(sigc::mem_fun(this, &AbstractComboBox::RecvMouseEnter));
+    _combo_box_area->mouse_leave.connect(sigc::mem_fun(this, &AbstractComboBox::RecvMouseLeave));
+
+    _combo_box_opening_area->mouse_enter.connect(sigc::mem_fun(this, &AbstractComboBox::RecvMouseEnter));
+    _combo_box_opening_area->mouse_leave.connect(sigc::mem_fun(this, &AbstractComboBox::RecvMouseLeave));
+
+    SetTextColor(color::Black);
+
+    _pango_static_text = new StaticText("", NUX_TRACKER_LOCATION);
   }
 
   AbstractComboBox::~AbstractComboBox()
   {
     if (_pango_static_text)
-      _pango_static_text->Dispose ();
+      _pango_static_text->Dispose();
     _pango_static_text = 0;
   }
 
-  void AbstractComboBox::Draw (GraphicsEngine &GfxContext, bool force_draw)
+  void AbstractComboBox::Draw(GraphicsEngine &graphics_engine, bool force_draw)
   {
     Geometry base = GetGeometry();
     
-    GfxContext.PushClippingRectangle (base);
-    GetPainter().PaintBackground (GfxContext, base);
-    GetPainter().PaintShape (GfxContext, base, m_sCOMBO_COLOR,  eSHAPE_CORNER_ROUND4);
+    graphics_engine.PushClippingRectangle(base);
+    GetPainter().PaintBackground(graphics_engine, base);
+    GetPainter().PaintShape(graphics_engine, base, m_sCOMBO_COLOR,  eSHAPE_CORNER_ROUND4);
 
     {
-      //GetPainter().PaintTextLineStatic (GfxContext, GetFont (), _combo_box_area->GetGeometry(), _combo_box_area->GetBaseString().GetTCharPtr(), GetTextColor(), eAlignTextLeft);
-      _pango_static_text->SetGeometry (_combo_box_area->GetGeometry ());
-      _pango_static_text->ProcessDraw (GfxContext, true);
+      //GetPainter().PaintTextLineStatic(graphics_engine, GetFont(), _combo_box_area->GetGeometry(), _combo_box_area->GetBaseString().GetTCharPtr(), GetTextColor(), eAlignTextLeft);
+      _pango_static_text->SetGeometry(_combo_box_area->GetGeometry());
+      _pango_static_text->ProcessDraw(graphics_engine, true);
     }
     
     Geometry button_geo = _combo_box_opening_area->GetGeometry();
-    button_geo.OffsetSize (-5, -2);
-    button_geo.OffsetPosition (+4, +1);
+    button_geo.OffsetSize(-5, -2);
+    button_geo.OffsetPosition(+4, +1);
 
-    if (_combo_box_area->IsMouseInside() || _combo_box_opening_area->IsMouseInside() || GetFocused ())
-      GetPainter().PaintShape (GfxContext, button_geo, m_sCOMBO_MOUSEOVER_COLOR,  eSHAPE_CORNER_ROUND4);
+    if (_combo_box_area->IsMouseInside() || _combo_box_opening_area->IsMouseInside())
+      GetPainter().PaintShape(graphics_engine, button_geo, m_sCOMBO_MOUSEOVER_COLOR,  eSHAPE_CORNER_ROUND4);
     else
-      GetPainter().PaintShape (GfxContext, button_geo, m_sCOMBO_BUTTON_COLOR,  eSHAPE_CORNER_ROUND4);
+      GetPainter().PaintShape(graphics_engine, button_geo, m_sCOMBO_BUTTON_COLOR,  eSHAPE_CORNER_ROUND4);
 
-    GeometryPositioning gp (eHACenter, eVACenter);
-    Geometry GeoPo = ComputeGeometryPositioning (button_geo, GetTheme().GetImageGeometry (eCOMBOBOX_OPEN_BUTTON), gp);
-    GetPainter().PaintShape (GfxContext, GeoPo, Color (0xFFFFFFFF), eCOMBOBOX_OPEN_BUTTON);
+    GeometryPositioning gp(eHACenter, eVACenter);
+    Geometry GeoPo = ComputeGeometryPositioning(button_geo, GetTheme().GetImageGeometry(eCOMBOBOX_OPEN_BUTTON), gp);
+    GetPainter().PaintShape(graphics_engine, GeoPo, Color(0xFFFFFFFF), eCOMBOBOX_OPEN_BUTTON);
 
     Geometry popup_geometry;
-    popup_geometry.SetX (_combo_box_area->GetBaseX() );
-    popup_geometry.SetY (_combo_box_area->GetBaseY() + _combo_box_area->GetBaseHeight() );
-    popup_geometry.SetWidth (_combo_box_area->GetBaseWidth() );
-    popup_geometry.SetHeight (_combo_box_area->GetBaseHeight() );
-
-    GfxContext.PopClippingRectangle ();
-  }
-
-  void AbstractComboBox::DrawContent (GraphicsEngine &GfxContext, bool force_draw)
-  {
-
-  }
-
-  void AbstractComboBox::PostDraw (GraphicsEngine &GfxContext, bool force_draw)
-  {
-
-  }
-
-  void AbstractComboBox::RecvMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags)
+    popup_geometry.SetX(_combo_box_area->GetBaseX());
+    popup_geometry.SetY(_combo_box_area->GetBaseY() + _combo_box_area->GetBaseHeight());
+    popup_geometry.SetWidth(_combo_box_area->GetBaseWidth());
+    popup_geometry.SetHeight(_combo_box_area->GetBaseHeight());
+
+    graphics_engine.PopClippingRectangle();
+  }
+
+  void AbstractComboBox::DrawContent(GraphicsEngine &graphics_engine, bool force_draw)
+  {
+
+  }
+
+  void AbstractComboBox::PostDraw(GraphicsEngine &graphics_engine, bool force_draw)
+  {
+
+  }
+
+  void AbstractComboBox::RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
     QueueDraw();
   }
 
-  void AbstractComboBox::RecvMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags)
+  void AbstractComboBox::RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
     QueueDraw();
   }
 
=== modified file 'Nux/AbstractComboBox.h'
--- Nux/AbstractComboBox.h	2011-04-06 21:54:09 +0000
+++ Nux/AbstractComboBox.h	2011-10-25 21:32:25 +0000
@@ -31,18 +31,17 @@
   class AbstractComboBox: public View
   {
   public:
-    AbstractComboBox (NUX_FILE_LINE_PROTO);
+    AbstractComboBox(NUX_FILE_LINE_PROTO);
     virtual ~AbstractComboBox();
 
-    virtual long ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo) = 0;
-    virtual void Draw (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void DrawContent (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void PostDraw (GraphicsEngine &GfxContext, bool force_draw);
-
-    void RecvMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags);
-
-    StaticText * GetStaticText ()
+    virtual void Draw(GraphicsEngine &graphics_engine, bool force_draw);
+    virtual void DrawContent(GraphicsEngine &graphics_engine, bool force_draw);
+    virtual void PostDraw(GraphicsEngine &graphics_engine, bool force_draw);
+
+    void RecvMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags);
+
+    StaticText * GetStaticText()
     {
       return _pango_static_text;
     }
 
=== modified file 'Nux/AbstractPaintLayer.cpp'
--- Nux/AbstractPaintLayer.cpp	2011-09-20 06:03:43 +0000
+++ Nux/AbstractPaintLayer.cpp	2011-10-25 21:32:25 +0000
@@ -4,33 +4,33 @@
 
 namespace nux
 {
-  AbstractPaintLayer::AbstractPaintLayer ()
-  {
-
-  }
-
-  AbstractPaintLayer::~AbstractPaintLayer ()
-  {
-
-  }
-
-  void AbstractPaintLayer::SetGeometry (const Geometry &geo)
-  {
-    _geometry = geo;
-  }
-
-  Geometry const& AbstractPaintLayer::GetGeometry () const
-  {
-    return _geometry;
-  }
-
-  void AbstractPaintLayer::SetModelViewMatrix (const Matrix4 &mat)
-  {
-    _model_view_matrix = mat;
-  }
-
-  Matrix4 AbstractPaintLayer::GetModelViewMatrix ()
-  {
-    return _model_view_matrix;
+  AbstractPaintLayer::AbstractPaintLayer()
+  {
+
+  }
+
+  AbstractPaintLayer::~AbstractPaintLayer()
+  {
+
+  }
+
+  void AbstractPaintLayer::SetGeometry(const Geometry &geo)
+  {
+    geometry_ = geo;
+  }
+
+  Geometry const& AbstractPaintLayer::GetGeometry() const
+  {
+    return geometry_;
+  }
+
+  void AbstractPaintLayer::SetModelViewMatrix(const Matrix4 &mat)
+  {
+    model_view_matrix_ = mat;
+  }
+
+  Matrix4 AbstractPaintLayer::GetModelViewMatrix()
+  {
+    return model_view_matrix_;
   }
 }
 
=== modified file 'Nux/AbstractPaintLayer.h'
--- Nux/AbstractPaintLayer.h	2011-09-20 06:03:43 +0000
+++ Nux/AbstractPaintLayer.h	2011-10-25 21:32:25 +0000
@@ -40,24 +40,24 @@
       PaintLayer_ImageStyle,
     };
 
-    AbstractPaintLayer ();
-    virtual ~AbstractPaintLayer ();
-    virtual AbstractPaintLayer *Clone () const = 0; //Virtual Constructor Idiom
-
-    virtual void Renderlayer (GraphicsEngine &GfxContext) = 0;
-
-    virtual void SetGeometry (const Geometry &geo);
+    AbstractPaintLayer();
+    virtual ~AbstractPaintLayer();
+    virtual AbstractPaintLayer *Clone() const = 0; //Virtual Constructor Idiom
+
+    virtual void Renderlayer(GraphicsEngine &graphics_engine) = 0;
+
+    virtual void SetGeometry(const Geometry &geo);
 
     //! Preserve the model view matrix at the moment layer is pushed on the paint layer stack. See Painter class.
-    void SetModelViewMatrix (const Matrix4 &mat);
+    void SetModelViewMatrix(const Matrix4 &mat);
 
-    Matrix4 GetModelViewMatrix ();
+    Matrix4 GetModelViewMatrix();
 
     Geometry const& GetGeometry() const;
 
   protected:
-    Geometry _geometry;
-    Matrix4  _model_view_matrix;
+    Geometry geometry_;
+    Matrix4  model_view_matrix_;
   };
 
 }
 
=== removed file 'Nux/AbstractRadioButton.cpp'
--- Nux/AbstractRadioButton.cpp	2011-08-17 02:27:23 +0000
+++ Nux/AbstractRadioButton.cpp	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-#include "Nux.h"
-
-#include "AbstractRadioButton.h"
-#include "HLayout.h"
-
-namespace nux
-{
-  NUX_IMPLEMENT_OBJECT_TYPE(AbstractRadioButton);
-
-  AbstractRadioButton::AbstractRadioButton (const TCHAR *Caption, NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-  {
-    _state  = false;
-  }
-
-  AbstractRadioButton::~AbstractRadioButton()
-  {
-
-  }
-}
 
=== removed file 'Nux/AbstractRadioButton.h'
--- Nux/AbstractRadioButton.h	2011-08-17 02:27:23 +0000
+++ Nux/AbstractRadioButton.h	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-
-#ifndef ABSTRACTRADIOBUTTON_H
-#define ABSTRACTRADIOBUTTON_H
-
-namespace nux
-{
-  //! The base class of Button, CheckBox, RadioButton and PushButton.
-  class AbstractRadioButton : public View
-  {
-    NUX_DECLARE_OBJECT_TYPE (AbstractRadioButton, View);
-  public:
-    AbstractRadioButton (const TCHAR *Caption = TEXT (""), NUX_FILE_LINE_PROTO);
-    ~AbstractRadioButton();
-
-    virtual void SetCaption (const TCHAR *Caption) = 0;
-    virtual const NString &GetCaption() const = 0;
-
-    virtual void SetState (bool b) = 0;
-    virtual void SetState (bool State, bool EmitSignal) = 0;
-    virtual bool GetState() const = 0;
-
-  protected:
-    bool _state;
-  };
-}
-
-#endif // ABSTRACTRADIOBUTTON_H
 
=== removed file 'Nux/AbstractSeparator.cpp'
--- Nux/AbstractSeparator.cpp	2011-04-06 21:54:09 +0000
+++ Nux/AbstractSeparator.cpp	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-
-#include "Nux.h"
-
-#include "AbstractSeparator.h"
-
-namespace nux
-{
-
-  AbstractSeparator::AbstractSeparator (NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-    ,   m_Color (0xFF888888)
-    ,   m_Alpha0 (0.0f)
-    ,   m_Alpha1 (0.592f)
-    ,   m_BorderSize (10)
-  {
-
-  }
-
-  AbstractSeparator::AbstractSeparator (const Color &color, float Alpha0, float Alpha1, int Border, NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-    ,   m_Color (color)
-    ,   m_Alpha0 (Alpha0)
-    ,   m_Alpha1 (Alpha1)
-    ,   m_BorderSize (Border)
-  {
-
-  }
-
-  AbstractSeparator::~AbstractSeparator()
-  {
-
-  }
-
-  void AbstractSeparator::SetColor (const Color &color)
-  {
-    m_Color = color;
-  }
-
-  void AbstractSeparator::SetAlpha (float Alpha0, float Alpha1)
-  {
-    m_Alpha0 = Alpha0;
-    m_Alpha1 = Alpha1;
-  }
-
-  void AbstractSeparator::SetBorderSize (int Border)
-  {
-    m_BorderSize = Border;
-  }
-}
 
=== removed file 'Nux/AbstractSeparator.h'
--- Nux/AbstractSeparator.h	2011-04-06 21:54:09 +0000
+++ Nux/AbstractSeparator.h	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-
-#ifndef ABSTRACTSEPARATOR_H
-#define ABSTRACTSEPARATOR_H
-
-namespace nux
-{
-
-  class AbstractSeparator: public View
-  {
-  public:
-    AbstractSeparator (NUX_FILE_LINE_PROTO);
-    AbstractSeparator (const Color &color, float Alpha0, float Alpha1, int Border, NUX_FILE_LINE_PROTO);
-    ~AbstractSeparator();
-    void SetColor (const Color &color);
-    void SetAlpha (float Alpha0, float Alpha1);
-    void SetBorderSize (int Border);
-
-  protected:
-    Color m_Color;
-    float m_Alpha0;
-    float m_Alpha1;
-    int m_BorderSize;
-  };
-
-}
-
-#endif // ABSTRACTSEPARATOR_H
 
=== modified file 'Nux/AbstractThread.cpp'
--- Nux/AbstractThread.cpp	2011-04-06 21:54:09 +0000
+++ Nux/AbstractThread.cpp	2011-10-25 21:32:25 +0000
@@ -26,12 +26,12 @@
 namespace nux
 {
 
-  NUX_IMPLEMENT_OBJECT_TYPE (AbstractThread);
+  NUX_IMPLEMENT_OBJECT_TYPE(AbstractThread);
 
-  AbstractThread::AbstractThread (AbstractThread *Parent)
-    :   m_Parent (Parent)
-    ,   m_UserInitFunc (0)
-    ,   m_UserExitFunc (0)
+  AbstractThread::AbstractThread(AbstractThread *Parent)
+    :   m_Parent(Parent)
+    ,   m_UserInitFunc(0)
+    ,   m_UserExitFunc(0)
   {
 
   }
 
=== modified file 'Nux/AbstractThread.h'
--- Nux/AbstractThread.h	2011-04-06 21:54:09 +0000
+++ Nux/AbstractThread.h	2011-10-25 21:32:25 +0000
@@ -26,25 +26,25 @@
 namespace nux
 {
 
-  typedef void (*ThreadUserInitFunc) (NThread *, void *InitData);
-  typedef void (*ThreadUserExitFunc) (NThread *, void *ExitData);
-  typedef void (*ThreadMainFunc) (NThread *, void *MainData);
+  typedef void(*ThreadUserInitFunc) (NThread *, void *InitData);
+  typedef void(*ThreadUserExitFunc) (NThread *, void *ExitData);
+  typedef void(*ThreadMainFunc) (NThread *, void *MainData);
 
   class AbstractThread: public NThread, public sigc::trackable
   {
-    NUX_DECLARE_OBJECT_TYPE (AbstractThread, NThread);
+    NUX_DECLARE_OBJECT_TYPE(AbstractThread, NThread);
 
   public:
-    AbstractThread (AbstractThread *Parent);
+    AbstractThread(AbstractThread *Parent);
     virtual ~AbstractThread();
 
   protected:
-    virtual unsigned int Run (void *) = 0;
+    virtual unsigned int Run(void *) = 0;
 
-    virtual ThreadState StartChildThread (NThread *thread, bool Modal) = 0;
-    virtual void AddChildThread (NThread *) = 0;
-    virtual void RemoveChildThread (NThread *) = 0;
-    virtual void ChildHasFinished (NThread *app) = 0;
+    virtual ThreadState StartChildThread(NThread *thread, bool Modal) = 0;
+    virtual void AddChildThread(NThread *) = 0;
+    virtual void RemoveChildThread(NThread *) = 0;
+    virtual void ChildHasFinished(NThread *app) = 0;
     virtual void TerminateAllChildThread() = 0;
 
     std::list<NThread *> m_ChildThread;
@@ -61,7 +61,7 @@
     std::list<NThread *> m_ThreadList;
 
   private:
-    AbstractThread (const AbstractThread &);
+    AbstractThread(const AbstractThread &);
     // Does not make sense for a singleton. This is a self assignment.
     AbstractThread &operator= (const AbstractThread &);
     // Declare operator adress-of as private
 
=== modified file 'Nux/ActionItem.cpp'
--- Nux/ActionItem.cpp	2011-09-20 06:03:43 +0000
+++ Nux/ActionItem.cpp	2011-10-25 21:32:25 +0000
@@ -27,86 +27,86 @@
 namespace nux
 {
 
-  NUX_IMPLEMENT_OBJECT_TYPE (ActionItem);
+  NUX_IMPLEMENT_OBJECT_TYPE(ActionItem);
 
-  ActionItem::ActionItem (const TCHAR *label, int UserValue, NUX_FILE_LINE_DECL)
-    :   Object (true, NUX_FILE_LINE_PARAM)
-    ,   m_UserValue (UserValue)
-    ,   m_Label (TEXT ("") )
-    ,   m_IsActivated (true)
-    ,   m_Menu (0)
-    ,   m_Enable (true)
+  ActionItem::ActionItem(const char *label, int UserValue, NUX_FILE_LINE_DECL)
+    :   Object(true, NUX_FILE_LINE_PARAM)
+    ,   m_UserValue(UserValue)
+    ,   m_Label("")
+    ,   m_IsActivated(true)
+    ,   m_Menu(0)
+    ,   m_Enable(true)
   {
     m_Icon = 0;
-    SetLabel (label);
+    SetLabel(label);
   }
 
   ActionItem::~ActionItem()
   {
-    if(m_Icon)
+    if (m_Icon)
       m_Icon->UnReference();
   }
 
-  void ActionItem::DrawAsMenuItem (GraphicsEngine &GfxContext, InputArea &area, bool is_highlighted, bool draw_icone)
+  void ActionItem::DrawAsMenuItem(GraphicsEngine &graphics_engine, InputArea &area, bool is_highlighted, bool draw_icone)
   {
     Geometry geo = area.GetGeometry();
-    Geometry icon_geo (0, 0, 20, 20);
+    Geometry icon_geo(0, 0, 20, 20);
     Geometry text_geo = geo;
 
-    text_geo.OffsetPosition (24, 2);
-    text_geo.OffsetSize (2 * 24, 2 * 2);
-
-    icon_geo.SetX (geo.x + 2);
-    icon_geo.SetY (geo.y + 2);
-
-    const TCHAR *label = GetLabel();
+    text_geo.OffsetPosition(24, 2);
+    text_geo.OffsetSize(2 * 24, 2 * 2);
+
+    icon_geo.SetX(geo.x + 2);
+    icon_geo.SetY(geo.y + 2);
+
+    const char *label = GetLabel();
 
     if (is_highlighted)
     {
-      GetPainter().Paint2DQuadColor (GfxContext, geo, Color (COLOR_FOREGROUND_SECONDARY) );
+      GetPainter().Paint2DQuadColor(graphics_engine, geo, Color(COLOR_FOREGROUND_SECONDARY));
     }
 
-    if(m_Icon)
-      GetPainter().Draw2DTextureAligned (GfxContext, m_Icon, icon_geo, TextureAlignmentStyle (eTACenter, eTACenter) );
+    if (m_Icon)
+      GetPainter().Draw2DTextureAligned(graphics_engine, m_Icon, icon_geo, TextureAlignmentStyle(eTACenter, eTACenter));
 
-    GetPainter().PaintTextLineStatic (GfxContext, GetSysFont(), text_geo, std::string (label), Color (0xFF000000), eAlignTextLeft);
+    GetPainter().PaintTextLineStatic(graphics_engine, GetSysFont(), text_geo, std::string(label), Color(0xFF000000), eAlignTextLeft);
   }
 
-  void ActionItem::DrawAsToolButton (GraphicsEngine &GfxContext, InputArea &area)
+  void ActionItem::DrawAsToolButton(GraphicsEngine &graphics_engine, InputArea &area)
   {
     Geometry base = area.GetGeometry();
 
-    if (area.IsMouseOwner() )
+    if (area.IsMouseOwner())
     {
-      if (area.IsMouseInside() )
+      if (area.IsMouseInside())
       {
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_BACKGROUND_SECONDARY),  eSHAPE_CORNER_ROUND2);
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_BACKGROUND_SECONDARY),  eSHAPE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
       }
       else
       {
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_FOREGROUND_PRIMARY),  eSHAPE_CORNER_ROUND2);
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_FOREGROUND_PRIMARY),  eSHAPE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
       }
     }
     else
     {
-      if (area.IsMouseInside() && (!area.MouseFocusOnOtherArea() ) )
+      if (area.IsMouseInside() && (!area.MouseFocusOnOtherArea()))
       {
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_FOREGROUND_PRIMARY),  eSHAPE_CORNER_ROUND2);
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_FOREGROUND_PRIMARY),  eSHAPE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
       }
       else
       {
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_BACKGROUND_SECONDARY),  eSHAPE_CORNER_ROUND2);
-        GetPainter().PaintShape (GfxContext, base, Color (COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_BACKGROUND_SECONDARY),  eSHAPE_CORNER_ROUND2);
+        GetPainter().PaintShape(graphics_engine, base, Color(COLOR_BLACK),  eSTROKE_CORNER_ROUND2);
       }
     }
 
-    GetPainter().Draw2DTextureAligned (GfxContext, m_Icon, base, TextureAlignmentStyle (eTACenter, eTACenter) );
+    GetPainter().Draw2DTextureAligned(graphics_engine, m_Icon, base, TextureAlignmentStyle(eTACenter, eTACenter));
   }
 
-  void ActionItem::Activate (bool b)
+  void ActionItem::Activate(bool b)
   {
     m_IsActivated = b;
   }
@@ -116,7 +116,7 @@
     sigAction.emit();
   }
 
-  void ActionItem::Enable (bool b)
+  void ActionItem::Enable(bool b)
   {
     m_Enable = b;
   }
@@ -126,19 +126,19 @@
     return m_Enable;
   }
 
-  void ActionItem::SetLabel (const TCHAR *label)
+  void ActionItem::SetLabel(const char *label)
   {
     m_Label = label;
   }
 
-  const TCHAR *ActionItem::GetLabel() const
+  const char *ActionItem::GetLabel() const
   {
     return m_Label.GetTCharPtr();
   }
 
-  void ActionItem::SetIcon (const BaseTexture* icon)
+  void ActionItem::SetIcon(const BaseTexture* icon)
   {
-    if(m_Icon)
+    if (m_Icon)
       m_Icon->UnReference();
     m_Icon = icon->Clone();
   }
 
=== modified file 'Nux/AnimatedTextureArea.cpp'
--- Nux/AnimatedTextureArea.cpp	2011-09-20 06:03:43 +0000
+++ Nux/AnimatedTextureArea.cpp	2011-10-25 21:32:25 +0000
@@ -27,113 +27,108 @@
 namespace nux
 {
 
-  AnimatedTextureArea::AnimatedTextureArea (NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-    ,   m_UserTexture (0)
+  AnimatedTextureArea::AnimatedTextureArea(NUX_FILE_LINE_DECL)
+    :   View(NUX_FILE_LINE_PARAM)
+    ,   m_UserTexture(0)
   {
-    SetMinMaxSize (32, 32);
+    SetMinMaxSize(32, 32);
 
-    mouse_down.connect (sigc::mem_fun (this, &AnimatedTextureArea::RecvMouseDown) );
-    mouse_drag.connect (sigc::mem_fun (this, &AnimatedTextureArea::RecvMouseDrag) );
+    mouse_down.connect(sigc::mem_fun(this, &AnimatedTextureArea::RecvMouseDown));
+    mouse_drag.connect(sigc::mem_fun(this, &AnimatedTextureArea::RecvMouseDrag));
 
     m_TimerFunctor = new TimerFunctor();
-    m_TimerFunctor->OnTimerExpired.connect (sigc::mem_fun (this, &AnimatedTextureArea::TimerNextFrame) );
+    m_TimerFunctor->time_expires.connect(sigc::mem_fun(this, &AnimatedTextureArea::TimerNextFrame));
   }
 
   AnimatedTextureArea::~AnimatedTextureArea()
   {
-    GetTimer().RemoveTimerHandler (m_TimerHandler);
+    GetTimer().RemoveTimerHandler(m_TimerHandler);
     m_TimerHandler = 0;
     delete m_TimerFunctor;
     m_TimerFunctor = 0;
   }
 
-  long AnimatedTextureArea::ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
-  {
-    return PostProcessEvent2 (ievent, TraverseInfo, ProcessEventInfo);
-  }
-
-  void AnimatedTextureArea::Draw (GraphicsEngine &GfxContext, bool force_draw)
+  void AnimatedTextureArea::Draw(GraphicsEngine &graphics_engine, bool force_draw)
   {
     if (m_UserTexture)
     {
-      GetPainter().PaintBackground (GfxContext, GetGeometry() );
-      GfxContext.GetRenderStates().SetBlend (true, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+      GetPainter().PaintBackground(graphics_engine, GetGeometry());
+      graphics_engine.GetRenderStates().SetBlend(true, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       nux::Geometry base = GetGeometry();
       nux::TexCoordXForm texxform;
-      GfxContext.QRP_1Tex (base.x, base.y, base.width, base.height, m_UserTexture->GetDeviceTexture(), texxform, nux::color::White);
+      graphics_engine.QRP_1Tex(base.x, base.y, base.width, base.height, m_UserTexture->GetDeviceTexture(), texxform, nux::color::White);
 
-      GfxContext.GetRenderStates().SetBlend (false);
+      graphics_engine.GetRenderStates().SetBlend(false);
     }
   }
-  void AnimatedTextureArea::DrawContent (GraphicsEngine &GfxContext, bool force_draw)
-  {
-
-  }
-
-  void AnimatedTextureArea::PostDraw (GraphicsEngine &GfxContext, bool force_draw)
-  {
-
-  }
-
-  void AnimatedTextureArea::SetTexture (TextureFrameAnimation *Texture)
+  void AnimatedTextureArea::DrawContent(GraphicsEngine &graphics_engine, bool force_draw)
+  {
+
+  }
+
+  void AnimatedTextureArea::PostDraw(GraphicsEngine &graphics_engine, bool force_draw)
+  {
+
+  }
+
+  void AnimatedTextureArea::SetTexture(TextureFrameAnimation *Texture)
   {
     m_UserTexture = Texture;
 
     if (m_UserTexture)
     {
-      ObjectPtr< CachedTextureFrameAnimation > Texture = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource (m_UserTexture);
+      ObjectPtr< CachedTextureFrameAnimation > Texture = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource(m_UserTexture);
       ObjectPtr<IOpenGLAnimatedTexture> AnimatedTexture = Texture->m_Texture; //Texture->m_Texture.CastRef<IOpenGLAnimatedTexture>();
       ObjectPtr<IOpenGLBaseTexture> Texture2D = Texture->m_Texture; //Texture->m_Texture.CastRef<IOpenGLAnimatedTexture>();
 
-      AnimatedTexture->SetFiltering (GL_LINEAR, GL_LINEAR);
-      AnimatedTexture->SetWrap (GL_CLAMP, GL_CLAMP, GL_CLAMP);
+      AnimatedTexture->SetFiltering(GL_LINEAR, GL_LINEAR);
+      AnimatedTexture->SetWrap(GL_CLAMP, GL_CLAMP, GL_CLAMP);
     }
 
     QueueDraw();
   }
 
-  void AnimatedTextureArea::RecvMouseDown (int x, int y, long button_flags, long key_flags)
+  void AnimatedTextureArea::RecvMouseDown(int x, int y, long button_flags, long key_flags)
   {
-    sigMouseDown.emit (x, y);
+    sigMouseDown.emit(x, y);
   }
 
-  void AnimatedTextureArea::RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+  void AnimatedTextureArea::RecvMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
   {
-    sigMouseDrag.emit (x, y);
+    sigMouseDrag.emit(x, y);
   }
 
   void AnimatedTextureArea::StartAnimation()
   {
-    if (m_TimerHandler.IsValid() )
+    if (m_TimerHandler.IsValid())
     {
-      GetTimer().RemoveTimerHandler (m_TimerHandler);
+      GetTimer().RemoveTimerHandler(m_TimerHandler);
       m_TimerHandler = 0;
     }
 
-    m_TimerHandler = GetTimer().AddTimerHandler (41, m_TimerFunctor, 0);
+    m_TimerHandler = GetTimer().AddTimerHandler(41, m_TimerFunctor, 0);
     QueueDraw();
   }
 
   void AnimatedTextureArea::StopAnimation()
   {
-    if (m_TimerHandler.IsValid() )
+    if (m_TimerHandler.IsValid())
     {
-      GetTimer().RemoveTimerHandler (m_TimerHandler);
+      GetTimer().RemoveTimerHandler(m_TimerHandler);
       m_TimerHandler = 0;
     }
   }
 
-  void AnimatedTextureArea::TimerNextFrame (void *v)
+  void AnimatedTextureArea::TimerNextFrame(void *v)
   {
     if (m_UserTexture)
     {
-      ObjectPtr< CachedTextureFrameAnimation > Texture = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource (m_UserTexture);
+      ObjectPtr< CachedTextureFrameAnimation > Texture = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource(m_UserTexture);
       ObjectPtr<IOpenGLAnimatedTexture> AnimatedTexture = Texture->m_Texture; //Texture->m_Texture.CastRef<IOpenGLAnimatedTexture>();
       ObjectPtr<IOpenGLBaseTexture> Texture2D = Texture->m_Texture; //Texture->m_Texture.CastRef<IOpenGLAnimatedTexture>();
 
       AnimatedTexture->PresentNextFrame();
-      m_TimerHandler = GetTimer().AddTimerHandler (41, m_TimerFunctor, 0);
+      m_TimerHandler = GetTimer().AddTimerHandler(41, m_TimerFunctor, 0);
     }
 
     QueueDraw();
 
=== modified file 'Nux/AnimatedTextureArea.h'
--- Nux/AnimatedTextureArea.h	2011-09-20 06:03:43 +0000
+++ Nux/AnimatedTextureArea.h	2011-10-25 21:32:25 +0000
@@ -32,16 +32,15 @@
   class AnimatedTextureArea : public View
   {
   public:
-    AnimatedTextureArea (NUX_FILE_LINE_PROTO);
+    AnimatedTextureArea(NUX_FILE_LINE_PROTO);
     ~AnimatedTextureArea();
-    virtual long ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
-    virtual void Draw (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void DrawContent (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void PostDraw (GraphicsEngine &GfxContext, bool force_draw);
+    virtual void Draw(GraphicsEngine &graphics_engine, bool force_draw);
+    virtual void DrawContent(GraphicsEngine &graphics_engine, bool force_draw);
+    virtual void PostDraw(GraphicsEngine &graphics_engine, bool force_draw);
 
-    void SetTexture (TextureFrameAnimation *Texture);
-    void RecvMouseDown (int x, int y, long button_flags, long key_flags);
-    void RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
+    void SetTexture(TextureFrameAnimation *Texture);
+    void RecvMouseDown(int x, int y, long button_flags, long key_flags);
+    void RecvMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
 
     sigc::signal<void, int, int> sigMouseDown;
     sigc::signal<void, int, int> sigMouseDrag;
@@ -51,7 +50,7 @@
 
 
   private:
-    void TimerNextFrame (void *v);
+    void TimerNextFrame(void *v);
     TimerFunctor *m_TimerFunctor;
     TimerHandle m_TimerHandler;
 
 
=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2011-09-20 06:03:43 +0000
+++ Nux/Area.cpp	2011-10-25 21:32:25 +0000
@@ -32,38 +32,37 @@
 namespace nux
 {
 
-  NUX_IMPLEMENT_OBJECT_TYPE (Area);
+  NUX_IMPLEMENT_OBJECT_TYPE(Area);
 
   Area::Area (NUX_FILE_LINE_DECL)
-    :   InitiallyUnownedObject (NUX_FILE_LINE_PARAM)
-    ,   _is_focused (0)
-    ,   _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)
+    :   InitiallyUnownedObject(NUX_FILE_LINE_PARAM)
+    ,   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())
   {
-    _parent_area = NULL;
+    visible_ = true;
+    view_enabled_ = true;
+    parent_area_ = NULL;
+
     next_object_to_key_focus_area_ = NULL;
     has_key_focus_ = false;
 
-    _stretch_factor = 1;
-    _layout_properties = NULL;
-    _visible = true;
-    _sensitive = true;
+    scale_factor_ = 1;
+    sensitive_ = true;
 
-    _on_geometry_changeg_reconfigure_parent_layout = true;
+    on_geometry_change_reconfigure_parent_layout_ = true;
     _accept_mouse_wheel_event = false;
     _accept_keyboard_event = false;
 
-    _2d_xform.Identity ();
-    _3d_xform.Identity ();
+    _2d_xform.Identity();
+    _3d_xform.Identity();
     _3d_area = false;
   }
 
 
   Area::~Area()
   {
-    if (_layout_properties)
-      delete _layout_properties;
   }
 
   const NString &Area::GetBaseString() const
@@ -71,362 +70,360 @@
     return _base_string;
   }
 
-  void Area::SetBaseString (const TCHAR *Caption)
+  void Area::SetBaseString(const char *Caption)
   {
     _base_string = Caption;
   }
 
   void Area::CheckMinSize()
   {
-    int w = _min_size.width;
+    int w = min_size_.width;
     w = Max<int>(AREA_MIN_WIDTH, w);
-    int h = _min_size.height;
+    int h = min_size_.height;
     h = Max<int>(AREA_MIN_HEIGHT, h);
 
-    _min_size = Size(w, h);
-
-    if (_min_size.width > _max_size.width)
-    {
-      _max_size.width = _min_size.width;
-    }
-
-    if (_min_size.height > _max_size.height)
-    {
-      _max_size.height = _min_size.height;
-    }
-
-    if (_geometry.width < _min_size.width)
-    {
-      _geometry.width = _min_size.width;
-    }
-
-    if (_geometry.height < _min_size.height )
-    {
-      _geometry.height = _min_size.height;
+    min_size_ = Size(w, h);
+
+    if (min_size_.width > max_size_.width)
+    {
+      max_size_.width = min_size_.width;
+    }
+
+    if (min_size_.height > max_size_.height)
+    {
+      max_size_.height = min_size_.height;
+    }
+
+    if (geometry_.width < min_size_.width)
+    {
+      geometry_.width = min_size_.width;
+    }
+
+    if (geometry_.height < min_size_.height )
+    {
+      geometry_.height = min_size_.height;
     }
   }
 
   void Area::CheckMaxSize()
   {
-    int w = _max_size.width;
-    w = Min<int>(AREA_MAX_WIDTH, w);
-    int h = _max_size.height;
-    h = Min<int>(AREA_MAX_HEIGHT, h);
-
-    _max_size = Size(w, h);
-
-    if (_min_size.width > _max_size.width)
-    {
-      _min_size.width = _max_size.width;
-    }
-
-    if (_min_size.height > _max_size.height)
-    {
-      _min_size.height = _max_size.height;
-    }
-
-    if (_geometry.width > _max_size.width)
-    {
-      _geometry.width = _max_size.width;
-    }
-
-    if (_geometry.height > _max_size.height)
-    {
-      _geometry.height = _max_size.height;
+    int w = max_size_.width;
+    w = w <= AREA_MAX_WIDTH ? w : AREA_MAX_WIDTH;
+    int h = max_size_.height;
+    h = h <= AREA_MAX_HEIGHT ? h: AREA_MAX_HEIGHT;
+
+    max_size_ = Size(w, h);
+
+    if (min_size_.width > max_size_.width)
+    {
+      min_size_.width = max_size_.width;
+    }
+
+    if (min_size_.height > max_size_.height)
+    {
+      min_size_.height = max_size_.height;
+    }
+
+    if (geometry_.width > max_size_.width)
+    {
+      geometry_.width = max_size_.width;
+    }
+
+    if (geometry_.height > max_size_.height)
+    {
+      geometry_.height = max_size_.height;
     }
   }
 
-  void Area::SetMinimumSize (int w, int h)
+  void Area::SetMinimumSize(int w, int h)
   {
-    nuxAssert (w >= 0);
-    nuxAssert (h >= 0);
-    _min_size = Size(w, h);
+    nuxAssert(w >= 0);
+    nuxAssert(h >= 0);
+    min_size_ = Size(w, h);
 
     CheckMinSize();
 
     ReconfigureParentLayout();
   }
 
-  void Area::SetMaximumSize (int w, int h)
+  void Area::SetMaximumSize(int w, int h)
   {
-    nuxAssert (w >= 0);
-    nuxAssert (h >= 0);
-    _max_size = Size(w, h);
+    nuxAssert(w >= 0);
+    nuxAssert(h >= 0);
+    max_size_ = Size(w, h);
 
     CheckMaxSize();
 
     ReconfigureParentLayout();
   }
 
-  void Area::SetMinMaxSize (int w, int h)
+  void Area::SetMinMaxSize(int w, int h)
   {
-    nuxAssert (w >= 0);
-    nuxAssert (h >= 0);
-    SetMinimumSize (w, h);
-    SetMaximumSize (w, h);
+    nuxAssert(w >= 0);
+    nuxAssert(h >= 0);
+    SetMinimumSize(w, h);
+    SetMaximumSize(w, h);
 
     //ReconfigureParentLayout();
   }
 
   void Area::ApplyMinWidth()
   {
-    _geometry.width = _min_size.width;
+    geometry_.width = min_size_.width;
 
     ReconfigureParentLayout();
   }
 
   void Area::ApplyMinHeight()
   {
-    _geometry.height = _min_size.height;
+    geometry_.height = min_size_.height;
 
     ReconfigureParentLayout();
   }
 
   void Area::ApplyMaxWidth()
   {
-    _geometry.width = _max_size.width;
+    geometry_.width = max_size_.width;
 
     ReconfigureParentLayout();
   }
 
   void Area::ApplyMaxHeight()
   {
-    _geometry.height = _max_size.height;
+    geometry_.height = max_size_.height;
 
     ReconfigureParentLayout();
   }
 
   Size Area::GetMinimumSize() const
   {
-    return _min_size;
+    return min_size_;
   }
 
   Size Area::GetMaximumSize() const
   {
-    return _max_size;
+    return max_size_;
   }
 
-  void Area::SetMinimumWidth (int w)
+  void Area::SetMinimumWidth(int w)
   {
-    nuxAssert (w >= 0);
-    _min_size.width = w;
+    nuxAssert(w >= 0);
+    min_size_.width = w;
     CheckMinSize();
     ReconfigureParentLayout();
   }
 
-  void Area::SetMaximumWidth (int w)
+  void Area::SetMaximumWidth(int w)
   {
-    nuxAssert (w >= 0);
-    _max_size.width = w;
+    nuxAssert(w >= 0);
+    max_size_.width = w;
     CheckMaxSize();
     ReconfigureParentLayout();
   }
 
-  void Area::SetMinimumHeight (int h)
+  void Area::SetMinimumHeight(int h)
   {
-    nuxAssert (h >= 0);
-    _min_size.height = h;
+    nuxAssert(h >= 0);
+    min_size_.height = h;
     CheckMinSize();
     ReconfigureParentLayout();
   }
 
-  void Area::SetMaximumHeight (int h)
+  void Area::SetMaximumHeight(int h)
   {
-    nuxAssert (h >= 0);
-    _max_size.height = h;
+    nuxAssert(h >= 0);
+    max_size_.height = h;
     CheckMaxSize();
     ReconfigureParentLayout();
   }
 
   int Area::GetMinimumWidth() const
   {
-    return _min_size.width;
+    return min_size_.width;
   }
 
   int Area::GetMaximumWidth() const
   {
-    return _max_size.width;
+    return max_size_.width;
   }
 
   int Area::GetMinimumHeight() const
   {
-    return _min_size.height;
+    return min_size_.height;
   }
 
   int Area::GetMaximumHeight() const
   {
-    return _max_size.height;
+    return max_size_.height;
   }
 
-  unsigned int Area::GetStretchFactor()
+  unsigned int Area::GetScaleFactor()
   {
-    return _stretch_factor;
+    return scale_factor_;
   }
 
-  void Area::SetStretchFactor (unsigned int sf)
+  void Area::SetScaleFactor(unsigned int sf)
   {
     // re implemented by Layout
-    _stretch_factor = sf;
+    scale_factor_ = sf;
   }
 
-  void Area::SetParentObject (Area *bo)
+  bool Area::SetParentObject(Area *parent)
   {
-    if (bo == 0)
-    {
-      nuxAssertMsg (0, TEXT ("[Area::SetParentObject] Invalid parent obejct.") );
-      return;
-    }
-
-    if (_parent_area)
-    {
-      nuxAssertMsg (0, TEXT ("[Area::SetParentObject] Object already has a parent. You must UnParent the object before you can parenting again.") );
-      return;
-    }
-
-    _parent_area = bo;
+    if (parent == 0)
+    {
+      nuxAssertMsg(0, "[Area::SetParentObject] Invalid parent obejct.");
+      return false;
+    }
+
+    if (parent_area_ && (parent_area_ != parent))
+    {
+      nuxAssertMsg(0, "[Area::SetParentObject] Object already has a parent. You must UnParent the object before you can parenting again.");
+      return false;
+    }
+
+    if (parent_area_)
+    {
+      // Already parented to the same area. Return.
+      return true;
+    }
+
+    parent_area_ = parent;
     Reference();
+
+    return true;
   }
 
   void Area::UnParentObject()
   {
-    if (_parent_area)
+    if (parent_area_)
     {
-      _parent_area = 0;
+      parent_area_ = 0;
       UnReference();
     }
   }
 
   Area *Area::GetParentObject() const
   {
-    return _parent_area;
+    return parent_area_;
   }
 
   int Area::GetBaseX     () const
   {
-    return _geometry.x;
+    return geometry_.x;
   }
 
   int Area::GetBaseY     () const
   {
-    return _geometry.y;
+    return geometry_.y;
   }
 
   int Area::GetBaseWidth    () const
   {
-    return _geometry.width;
+    return geometry_.width;
   }
 
   int Area::GetBaseHeight   () const
   {
-    return _geometry.height;
+    return geometry_.height;
   }
 
   void Area::SetGeometry(int x, int y, int w, int h)
   {
-    h = nux::Clamp<int> (h, _min_size.height, _max_size.height);
-    w = nux::Clamp<int> (w, _min_size.width, _max_size.width);
+    h = nux::Clamp<int> (h, min_size_.height, max_size_.height);
+    w = nux::Clamp<int> (w, min_size_.width, max_size_.width);
 
     nux::Geometry geometry(x, y, w, h);
-    if (_geometry == geometry)
+    if (geometry_ == geometry)
       return;
 
     GeometryChangePending();
-    _geometry = geometry;
+    geometry_ = geometry;
     ReconfigureParentLayout();
     GeometryChanged();
 
-    OnGeometryChanged.emit(this, _geometry);
+    OnGeometryChanged.emit(this, geometry_);
   }
 
-  void Area::SetGeometry (const Geometry &geo)
+  void Area::SetGeometry(const Geometry &geo)
   {
-    SetGeometry (geo.x, geo.y, geo.width, geo.height);
+    SetGeometry(geo.x, geo.y, geo.width, geo.height);
   }
 
   Geometry const& Area::GetGeometry() const
   {
-    return _geometry;
+    return geometry_;
   }
 
   void Area::SetBaseX(int x)
   {
-    SetGeometry(x, _geometry.y, _geometry.width, _geometry.height);
+    SetGeometry(x, geometry_.y, geometry_.width, geometry_.height);
   }
 
   void Area::SetBaseY    (int y)
   {
-    SetGeometry (_geometry.x, y, _geometry.width, _geometry.height);
+    SetGeometry(geometry_.x, y, geometry_.width, geometry_.height);
   }
 
   void Area::SetBaseXY    (int x, int y)
   {
-    SetGeometry (x, y, _geometry.width, _geometry.height);
-  }
-
-  void Area::SetBaseSize (int w, int h)
-  {
-    SetGeometry (_geometry.x, _geometry.y, w, h);
-  }
-
-  void Area::SetBaseWidth (int w)
-  {
-    SetGeometry (_geometry.x, _geometry.y, w, _geometry.height);
-  }
-
-  void Area::SetBaseHeight (int h)
-  {
-    SetGeometry (_geometry.x, _geometry.y, _geometry.width, h);
-  }
-
-  void Area::IncreaseSize (int x, int y)
-  {
-    _geometry.OffsetPosition (x, y);
-    OnResize.emit (_geometry.x, _geometry.y, _geometry.width, _geometry.height );
-  }
-
-  long Area::ComputeChildLayout()
-  {
-    return 0;
-  }
-
-  void Area::PositionChildLayout (float offsetX, float offsetY)
-  {
-
-  }
-
-  long Area::ComputeLayout2()
+    SetGeometry(x, y, geometry_.width, geometry_.height);
+  }
+
+  void Area::SetBaseSize(int w, int h)
+  {
+    SetGeometry(geometry_.x, geometry_.y, w, h);
+  }
+
+  void Area::SetBaseWidth(int w)
+  {
+    SetGeometry(geometry_.x, geometry_.y, w, geometry_.height);
+  }
+
+  void Area::SetBaseHeight(int h)
+  {
+    SetGeometry(geometry_.x, geometry_.y, geometry_.width, h);
+  }
+
+  void Area::IncreaseSize(int x, int y)
+  {
+    geometry_.OffsetPosition(x, y);
+    OnResize.emit(geometry_.x, geometry_.y, geometry_.width, geometry_.height );
+  }
+
+  long Area::ComputeContentSize()
   {
     return (eCompliantWidth | eCompliantHeight);
   }
 
-  void Area::ComputePosition2 (float offsetX, float offsetY)
+  void Area::ComputeContentPosition(float offsetX, float offsetY)
   {
 
   }
 
   void Area::SetReconfigureParentLayoutOnGeometryChange(bool reconfigure_parent_layout)
   {
-    _on_geometry_changeg_reconfigure_parent_layout = reconfigure_parent_layout;
+    on_geometry_change_reconfigure_parent_layout_ = reconfigure_parent_layout;
   }
   
   bool Area::ReconfigureParentLayoutOnGeometryChange()
   {
-    return _on_geometry_changeg_reconfigure_parent_layout;
+    return on_geometry_change_reconfigure_parent_layout_;
   }
 
   void Area::ReconfigureParentLayout(Area *child)
   {
-    if(_on_geometry_changeg_reconfigure_parent_layout == false)
+    if (on_geometry_change_reconfigure_parent_layout_ == false)
       return;
 
-    if (GetWindowThread ()->IsComputingLayout() )
+    if (GetWindowThread() && GetWindowThread()->IsComputingLayout())
     {
       // there is no need to do the following while we are already computing the layout.
       // If we do, we will end up in an infinite loop.
       return;
     }
 
-    if (this->Type().IsDerivedFromType (View::StaticObjectType) )
+    if (this->Type().IsDerivedFromType(View::StaticObjectType))
     {
       // The object that is being resized is a View object and it has a parent.
       if (this->OwnsTheReference() == false && this->GetParentObject())
@@ -437,29 +434,29 @@
 
       View *ic = static_cast<View *>(this);
 
-      if (ic->CanBreakLayout() )
+      if (ic->CanBreakLayout())
       {
 
-        if ( (child != 0) &&
-             (ic->Type().IsObjectType (VSplitter::StaticObjectType) || ic->Type().IsObjectType (HSplitter::StaticObjectType) ) )
+        if ((child != 0) &&
+             (ic->Type().IsObjectType(VSplitter::StaticObjectType) || ic->Type().IsObjectType(HSplitter::StaticObjectType)))
         {
           // If this element is a Splitter, then we submit its child to the refresh list. We don't want to submit the
-          // splitter because this will cause a redraw of all parts of the splitter (costly and unnecessary).
-          GetWindowThread ()->QueueObjectLayout (child);
+          // splitter because this will cause a redraw of all parts of the splitter(costly and unnecessary).
+          GetWindowThread()->QueueObjectLayout(child);
         }
         else
         {
-          GetWindowThread ()->QueueObjectLayout (ic);
+          GetWindowThread()->QueueObjectLayout(ic);
         }
       }
-      else if (ic->_parent_area)
-        ic->_parent_area->ReconfigureParentLayout (this);
+      else if (ic->parent_area_)
+        ic->parent_area_->ReconfigureParentLayout(this);
       else
       {
-        GetWindowThread ()->QueueObjectLayout (ic);
+        GetWindowThread()->QueueObjectLayout(ic);
       }
     }
-    else if (this->Type().IsDerivedFromType (Layout::StaticObjectType) )
+    else if (this->Type().IsDerivedFromType(Layout::StaticObjectType))
     {
       // The object that is being resized is a View object and it has a parent.
       if (this->OwnsTheReference() == false && this->GetParentObject())
@@ -470,47 +467,47 @@
 
       Layout *layout = static_cast<Layout *>(this);
 
-      if (layout->_parent_area)
+      if (layout->parent_area_)
       {
-        if (layout->_parent_area->Type().IsDerivedFromType (View::StaticObjectType) )
+        if (layout->parent_area_->Type().IsDerivedFromType(View::StaticObjectType))
         {
-          View *ic = (View *) (layout->_parent_area);
+          View *ic = (View *) (layout->parent_area_);
 
-          if (ic->CanBreakLayout() )
+          if (ic->CanBreakLayout())
           {
-            if ( (child != 0) &&
-                 (ic->Type().IsObjectType (VSplitter::StaticObjectType) || ic->Type().IsObjectType (HSplitter::StaticObjectType) ) )
+            if ((child != 0) &&
+                 (ic->Type().IsObjectType(VSplitter::StaticObjectType) || ic->Type().IsObjectType(HSplitter::StaticObjectType)))
             {
               // If the parent of this element is a splitter, then we submit its child to the refresh list. We don't want to submit the
-              // splitter because this will cause a redraw of all parts of the splitter (costly and unnecessary).
-              GetWindowThread ()->QueueObjectLayout (this);
+              // splitter because this will cause a redraw of all parts of the splitter(costly and unnecessary).
+              GetWindowThread()->QueueObjectLayout(this);
             }
             else
             {
-              GetWindowThread ()->QueueObjectLayout (ic);
+              GetWindowThread()->QueueObjectLayout(ic);
             }
           }
           else
           {
             // The parent object of an object of type View is a Layout object type.
-            layout->_parent_area->ReconfigureParentLayout (this);
+            layout->parent_area_->ReconfigureParentLayout(this);
           }
         }
         else
         {
-          layout->_parent_area->ReconfigureParentLayout (this);
+          layout->parent_area_->ReconfigureParentLayout(this);
         }
       }
       else
       {
-        // This is possibly the Main layout or the layout of a floating object (popup for example) unless the layout is not part of the object tree.
-        GetWindowThread ()->QueueObjectLayout (layout);
+        // This is possibly the Main layout or the layout of a floating object(popup for example) unless the layout is not part of the object tree.
+        GetWindowThread()->QueueObjectLayout(layout);
       }
     }
     else
     {
       // The object that is being resized is a InputArea object.
-      if (this->_parent_area)
+      if (this->parent_area_)
       {
         // The object that is being resized is a View object and it has a parent.
         if (this->OwnsTheReference() == false && this->GetParentObject())
@@ -520,125 +517,128 @@
         }
 
         // The parent object of an object of type InputArea is a Layout object type.
-        this->_parent_area->ReconfigureParentLayout (this);
+        this->parent_area_->ReconfigureParentLayout(this);
       }
     }
   }
 
-  void Area::RequestBottomUpLayoutComputation (Area *bo_initiator)
+  void Area::RequestBottomUpLayoutComputation(Area *bo_initiator)
   {
-    if (_parent_area && _parent_area->IsLayout() )
+    if (parent_area_ && parent_area_->IsLayout())
     {
-      _parent_area->RequestBottomUpLayoutComputation (bo_initiator);
+      parent_area_->RequestBottomUpLayoutComputation(bo_initiator);
     }
   }
 
-  void Area::SetLayoutProperties (LayoutProperties *properties)
-  {
-    if (_layout_properties)
-      delete _layout_properties;
-
-    _layout_properties = properties;
-  }
-
-  Area::LayoutProperties * Area::GetLayoutProperties ()
-  {
-    return _layout_properties;
-  }
-
-  void Area::SetVisible (bool visible)
-  {
-    if (_visible == visible)
-      return;
-
-    _visible = visible;
-
-    OnVisibleChanged.emit (this, _visible);
-  }
-
-  bool Area::IsVisible ()
-  {
-    return _visible;
-  }
-
-  void Area::SetSensitive (bool sensitive)
-  {
-    if (_sensitive == sensitive)
-      return;
-
-    _sensitive = sensitive;
-
-    OnSensitiveChanged.emit (this, _sensitive);
-  }
-
-  bool Area::IsSensitive ()
-  {
-    return _sensitive;
+  void Area::SetVisible(bool visible)
+  {
+    if (IsLayout())
+      return;
+
+    if (visible_ == visible)
+      return;
+
+    visible_ = visible;
+
+    OnVisibleChanged.emit(this, visible_);
+  }
+
+  bool Area::IsVisible()
+  {
+    return visible_;
+  }
+
+  void Area::SetSensitive(bool sensitive)
+  {
+    SetInputEventSensitivity(sensitive);
+  }
+
+  void Area::SetInputEventSensitivity(bool sensitive)
+  {
+    if (IsLayout())
+      return;
+
+    if (sensitive_ == sensitive)
+      return;
+
+    sensitive_ = sensitive;
+
+    OnSensitiveChanged.emit(this, sensitive_);
+  }
+
+  bool Area::IsSensitive() const
+  {
+    return GetInputEventSensitivity();
+  }
+
+  bool Area::GetInputEventSensitivity() const
+  {
+    return sensitive_;
   }
 
   MinorDimensionPosition Area::GetPositioning()
   {
-    return _positioning;
+    return minor_axis_position_;
   }
 
-  void Area::SetPositioning (MinorDimensionPosition p)
+  void Area::SetPositioning(MinorDimensionPosition p)
   {
-    _positioning = p;
+    minor_axis_position_ = p;
   }
 
   MinorDimensionSize Area::GetExtend()
   {
-    return _extend;
+    return minor_axis_size_;
   }
 
-  void Area::SetExtend (MinorDimensionSize ext)
+  void Area::SetExtend(MinorDimensionSize ext)
   {
-    _extend = ext;
+    minor_axis_size_ = ext;
   }
 
   float Area::GetPercentage()
   {
-    return _percentage;
+    return minor_axis_size_scale_;
   }
 
-  void Area::SetPercentage (float p)
+  void Area::SetPercentage(float p)
   {
-    _percentage = p;
+    minor_axis_size_scale_ = p;
   }
 
   bool Area::IsLayoutDone()
   {
-    return _layout_done;
-  }
-
-  void Area::SetLayoutDone (bool b)
-  {
-    _layout_done = b;
-  }
-
-  bool Area::IsArea () const
-  {
-    return this->Type ().IsDerivedFromType (Area::StaticObjectType);;
-  }
-
-  bool Area::IsInputArea () const
-  {
-    return this->Type ().IsDerivedFromType (InputArea::StaticObjectType);;
-  }
-
-  bool Area::IsView () const
-  {
-    return this->Type ().IsDerivedFromType (View::StaticObjectType);;
-  }
-
-  bool Area::IsLayout () const
-  {
-    return this->Type ().IsDerivedFromType (Layout::StaticObjectType);
-  }
-
-  bool Area::IsViewWindow () const
-  {
-    return this->Type ().IsDerivedFromType (BaseWindow::StaticObjectType);
+    return layout_done_;
+  }
+
+  void Area::SetLayoutDone(bool b)
+  {
+    layout_done_ = b;
+  }
+
+  bool Area::IsArea() const
+  {
+    return this->Type().IsDerivedFromType(Area::StaticObjectType);;
+  }
+
+  bool Area::IsInputArea() const
+  {
+    return this->Type().IsDerivedFromType(InputArea::StaticObjectType);;
+  }
+
+  bool Area::IsView() const
+  {
+    return this->Type().IsDerivedFromType(View::StaticObjectType);;
+  }
+
+  bool Area::IsLayout() const
+  {
+    return this->Type().IsDerivedFromType(Layout::StaticObjectType);
+  }
+
+  bool Area::IsViewWindow() const
+  {
+    return this->Type().IsDerivedFromType(BaseWindow::StaticObjectType);
   }
 
   bool Area::IsSpaceLayout() const
@@ -646,113 +646,113 @@
     return this->Type().IsDerivedFromType(SpaceLayout::StaticObjectType);;
   }
 
-  void Area::Set2DMatrix (const Matrix4 &mat)
+  void Area::Set2DMatrix(const Matrix4 &mat)
   {
     _2d_xform = mat;
   }
 
-  void Area::Set2DTranslation (float tx, float ty, float tz)
+  void Area::Set2DTranslation(float tx, float ty, float tz)
   {
-    _2d_xform.Translate (tx, ty, tz);
+    _2d_xform.Translate(tx, ty, tz);
   }
 
-  Matrix4 Area::Get2DMatrix () const
+  Matrix4 Area::Get2DMatrix() const
   {
     return _2d_xform;
   }
 
-  Matrix4 Area::Get3DMatrix () const
+  Matrix4 Area::Get3DMatrix() const
   {
     return _3d_xform;
   }
 
-  bool Area::Is3DArea () const
+  bool Area::Is3DArea() const
   {
     return _3d_area;
   }
 
-  static void MatrixXFormGeometry (const Matrix4 &matrix, Geometry &geo)
+  static void MatrixXFormGeometry(const Matrix4 &matrix, Geometry &geo)
   {
-    Vector4 in (geo.x, geo.y, 0, 1);
+    Vector4 in(geo.x, geo.y, 0, 1);
     // This is mean only for translation matrices. It will not work with matrices containing rotations or scalings.
     Vector4 out = matrix * in;
     geo.x = out.x;
     geo.y = out.y;
   }
 
-  void Area::InnerGetAbsoluteGeometry (Geometry &geometry)
+  void Area::InnerGetAbsoluteGeometry(Geometry &geometry)
   {
-    if (this->Type ().IsDerivedFromType (BaseWindow::StaticObjectType) || (this == GetWindowThread ()->GetMainLayout ()))
+    if (this->Type().IsDerivedFromType(BaseWindow::StaticObjectType) || (this == GetWindowThread()->GetMainLayout()))
     {
-      geometry.OffsetPosition (_geometry.x, _geometry.y);
+      geometry.OffsetPosition(geometry_.x, geometry_.y);
       return;
     }
 
-    MatrixXFormGeometry (_2d_xform, geometry);
+    MatrixXFormGeometry(_2d_xform, geometry);
 
-    Area *parent = GetParentObject ();
+    Area *parent = GetParentObject();
     if (parent)
-      parent->InnerGetAbsoluteGeometry (geometry);
+      parent->InnerGetAbsoluteGeometry(geometry);
   }
 
-  Geometry Area::GetAbsoluteGeometry () const
+  Geometry Area::GetAbsoluteGeometry() const
   {
     if (Type().IsDerivedFromType(BaseWindow::StaticObjectType) ||
       Type().IsDerivedFromType(MenuPage::StaticObjectType) ||
       (this == GetWindowThread()->GetMainLayout()))
     {
       // Do not apply the _2D_xform matrix  to a BaseWindow or the main layout
-      return _geometry;
+      return geometry_;
     }
     else
     {
-      nux::Geometry geo = _geometry;
-      MatrixXFormGeometry (_2d_xform, geo);
+      nux::Geometry geo = geometry_;
+      MatrixXFormGeometry(_2d_xform, geo);
 
-      Area *parent = GetParentObject ();
+      Area *parent = GetParentObject();
       if (parent)
-        parent->InnerGetAbsoluteGeometry (geo);
+        parent->InnerGetAbsoluteGeometry(geo);
 
       return geo;
     }
   }
 
-  int Area::GetAbsoluteX () const
-  {
-    return GetAbsoluteGeometry ().x;
-  }
-
-  int Area::GetAbsoluteY () const
-  {
-    return GetAbsoluteGeometry ().y;
-  }
-
-  int Area::GetAbsoluteWidth () const
-  {
-    return GetAbsoluteGeometry ().width;
-  }
-
-  int Area::GetAbsoluteHeight () const
-  {
-    return GetAbsoluteGeometry ().height;
-  }
-
-  void Area::InnerGetRootGeometry (Geometry &geometry)
-  {
-    if (this->Type ().IsDerivedFromType (BaseWindow::StaticObjectType) || (this == GetWindowThread ()->GetMainLayout ()))
+  int Area::GetAbsoluteX() const
+  {
+    return GetAbsoluteGeometry().x;
+  }
+
+  int Area::GetAbsoluteY() const
+  {
+    return GetAbsoluteGeometry().y;
+  }
+
+  int Area::GetAbsoluteWidth() const
+  {
+    return GetAbsoluteGeometry().width;
+  }
+
+  int Area::GetAbsoluteHeight() const
+  {
+    return GetAbsoluteGeometry().height;
+  }
+
+  void Area::InnerGetRootGeometry(Geometry &geometry)
+  {
+    if (this->Type().IsDerivedFromType(BaseWindow::StaticObjectType) || (this == GetWindowThread()->GetMainLayout()))
       return;
 
-    MatrixXFormGeometry (_2d_xform, geometry);
+    MatrixXFormGeometry(_2d_xform, geometry);
 
-    Area *parent = GetParentObject ();
+    Area *parent = GetParentObject();
     if (parent)
-      parent->InnerGetRootGeometry (geometry);
+      parent->InnerGetRootGeometry(geometry);
   }
 
-  Geometry Area::GetRootGeometry () const
+  Geometry Area::GetRootGeometry() const
   {
-    nux::Geometry geo = _geometry;
-    MatrixXFormGeometry (_2d_xform, geo);
+    nux::Geometry geo = geometry_;
+    MatrixXFormGeometry(_2d_xform, geo);
 
     if (Type().IsDerivedFromType(BaseWindow::StaticObjectType) || (this == GetWindowThread()->GetMainLayout()))
     {
@@ -760,62 +760,67 @@
     }
     else
     {
-      Area *parent = GetParentObject ();
+      Area *parent = GetParentObject();
       if (parent)
-        parent->InnerGetRootGeometry (geo);
+        parent->InnerGetRootGeometry(geo);
 
       return geo;
     }
   }
 
-  int Area::GetRootX () const
-  {
-    return GetRootGeometry ().x;
-  }
-
-  int Area::GetRootY () const
-  {
-    return GetRootGeometry ().y;
-  }
-
-  int Area::GetRootWidth () const
-  {
-    return GetRootGeometry ().width;
-  }
-
-  int Area::GetRootHeight () const
-  {
-    return GetRootGeometry ().height;
-  }
-
-  Area* Area::GetToplevel ()
-  {
-    if (Type ().IsDerivedFromType (BaseWindow::StaticObjectType) || (this == GetWindowThread ()->GetMainLayout ()))
+  int Area::GetRootX() const
+  {
+    return GetRootGeometry().x;
+  }
+
+  int Area::GetRootY() const
+  {
+    return GetRootGeometry().y;
+  }
+
+  int Area::GetRootWidth() const
+  {
+    return GetRootGeometry().width;
+  }
+
+  int Area::GetRootHeight() const
+  {
+    return GetRootGeometry().height;
+  }
+
+  Area* Area::GetToplevel()
+  {
+    return GetRootParent();
+  }
+
+  Area* Area::GetRootParent()
+  {
+    if (Type().IsDerivedFromType(BaseWindow::StaticObjectType) || (this == GetWindowThread()->GetMainLayout()))
     {
       return this;
     }
 
-    Area* parent = GetParentObject ();
+    Area* parent = GetParentObject();
     if (!parent) //we didn't find a way to salvation!
     {
       return 0;
     }
-    return parent->GetToplevel ();
+    return parent->GetRootParent();
   }
 
-  Area* Area::GetTopLevelViewWindow ()
+  Area* Area::GetTopLevelViewWindow()
   {
-    Area* area = GetToplevel ();
+    Area* area = GetRootParent();
 
-    if (area && area->IsViewWindow ())
+    if (area && area->IsViewWindow())
       return area;
 
     return NULL;
   }
 
-  bool Area::HasTopLevelParent ()
+  bool Area::HasTopLevelParent()
   {
-    if (GetToplevel ())
+    if (GetRootParent())
     {
       return true;
     }
@@ -827,42 +832,15 @@
     if (this == parent)
       return true;
 
-    if (!parent || !_parent_area)
+    if (!parent || !parent_area_)
       return false;
 
-    return _parent_area->IsChildOf(parent);    
-  }
-
-  /* handles our focusable code */
-  bool Area::DoGetFocused ()
-  {
-    return _is_focused;
-  }
-
-  /* Pretty much everything is going to have to override this */
-  void Area::DoSetFocused (bool focused)
-  {
-    if (_is_focused == focused)
-      return;
-    
-    _is_focused = focused;
-    FocusChanged.emit (this);
-  }
-
-  bool Area::DoCanFocus ()
-  {
-    return true;
-  }
-
-  /* override me! */
-  void Area::DoActivateFocus ()
-  {
-    FocusActivated.emit (this);
-  }
-
-  void Area::QueueRelayout ()
-  {
-    nux::GetWindowThread ()->QueueObjectLayout (this);
+    return parent_area_->IsChildOf(parent);    
+  }
+
+  void Area::QueueRelayout()
+  {
+    nux::GetWindowThread()->QueueObjectLayout(this);
   }
   
   void Area::SetAcceptKeyboardEvent(bool accept_keyboard_event)
@@ -885,45 +863,70 @@
     return _accept_mouse_wheel_event;
   }
 
-  bool Area::TestMousePointerInclusion(const Point& mouse_position, NuxEventType event_type)
-  {
-    bool mouse_pointer_inside_area = false;
-
-    if (Type().IsDerivedFromType(MenuPage::StaticObjectType))
-    {
-      // A MenuPage geometry is already in absolute coordinates.
-      mouse_pointer_inside_area = _geometry.IsInside(mouse_position);
-    }
-    else
-    {
-      mouse_pointer_inside_area = GetAbsoluteGeometry().IsInside(mouse_position);
-    }
-
-    if ((event_type == NUX_MOUSE_WHEEL) && mouse_pointer_inside_area)
-    {
-      if (_accept_mouse_wheel_event == false)
-        return NULL;
-    }
-
-    return mouse_pointer_inside_area;
-  }
-
-  bool Area::TestMousePointerInclusionFilterMouseWheel(const Point& mouse_position, NuxEventType event_type)
-  {
-    bool mouse_pointer_inside_area = false;
-
-    if (Type().IsDerivedFromType(MenuPage::StaticObjectType))
-    {
-      // A MenuPage geometry is already in absolute coordinates.
-      mouse_pointer_inside_area = _geometry.IsInside(mouse_position);
-    }
-    else
-    {
-      mouse_pointer_inside_area = GetAbsoluteGeometry().IsInside(mouse_position);
-    }
-
-    return mouse_pointer_inside_area;
-  }
+   bool Area::TestMousePointerInclusion(const Point& mouse_position, NuxEventType event_type)
+   {
+     if ((IsLayout() == false) && ((visible_ == false) ||
+       (sensitive_ == false) ||
+       (view_enabled_ == false)))
+     {
+       // If this area is not a view and:
+       //    - it is insensitive to input event
+       //    - it is not enabled
+       //    - it is not visible
+       // then return false.
+       return false;
+     }
+ 
+     bool mouse_pointer_inside_area = false;
+ 
+     if (Type().IsDerivedFromType(MenuPage::StaticObjectType))
+     {
+       // A MenuPage geometry is already in absolute coordinates.
+       mouse_pointer_inside_area = geometry_.IsInside(mouse_position);
+     }
+     else
+     {
+       mouse_pointer_inside_area = GetAbsoluteGeometry().IsInside(mouse_position);
+     }
+ 
+     if ((event_type == NUX_MOUSE_WHEEL) && mouse_pointer_inside_area)
+     {
+       if (_accept_mouse_wheel_event == false)
+         return NULL;
+     }
+ 
+     return mouse_pointer_inside_area;
+   }
+ 
+   bool Area::TestMousePointerInclusionFilterMouseWheel(const Point& mouse_position, NuxEventType event_type)
+   {
+     if ((IsLayout() == false) && ((visible_ == false) ||
+       (sensitive_ == false) ||
+       (view_enabled_ == false)))
+     {
+       // If this area is not a view and:
+       //    - it is insensitive to input event
+       //    - it is not enabled
+       //    - it is not visible
+       // then return false.
+ 
+       return false;
+     }
+ 
+     bool mouse_pointer_inside_area = false;
+ 
+     if (Type().IsDerivedFromType(MenuPage::StaticObjectType))
+     {
+       // A MenuPage geometry is already in absolute coordinates.
+       mouse_pointer_inside_area = geometry_.IsInside(mouse_position);
+     }
+     else
+     {
+       mouse_pointer_inside_area = GetAbsoluteGeometry().IsInside(mouse_position);
+     }
+ 
+     return mouse_pointer_inside_area;
+   }
 
   Area* Area::FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type)
   {
@@ -970,7 +973,7 @@
     {
       next_object_to_key_focus_area_->ResetDownwardPathToKeyFocusArea();
     }
-    if(next_object_to_key_focus_area_)
+    if (next_object_to_key_focus_area_)
       next_object_to_key_focus_area_->UnReference();
 
     next_object_to_key_focus_area_ = NULL;
@@ -979,11 +982,11 @@
   void Area::ResetUpwardPathToKeyFocusArea()
   {
     has_key_focus_ = false;
-    if (_parent_area)
+    if (parent_area_)
     {
-      _parent_area->ResetUpwardPathToKeyFocusArea();
+      parent_area_->ResetUpwardPathToKeyFocusArea();
     }
-    if(next_object_to_key_focus_area_)
+    if (next_object_to_key_focus_area_)
       next_object_to_key_focus_area_->UnReference();
 
     next_object_to_key_focus_area_ = NULL;
@@ -998,6 +1001,9 @@
 
   bool Area::AcceptKeyNavFocus()
   {
+    if (GetInputEventSensitivity() == false)
+      return false;
+
     return true;
   }
 
@@ -1010,5 +1016,26 @@
   {
     return has_key_focus_;
   }
+
+  Direction Area::GetDirection() const
+  {
+    return _direction;
+  }
+
+  void Area::SetDirection(Direction direction)
+  {
+    _direction = direction;
+  }
+
+  bool Area::IsMousePointerInside() const
+  {
+    Geometry geo = GetAbsoluteGeometry();
+    Point position = GetWindowCompositor().GetMousePosition();
+    
+    if (geo.IsInside(position))
+      return true;
+
+    return false;
+  }
 }
 
 
=== modified file 'Nux/Area.h'
--- Nux/Area.h	2011-09-20 06:03:43 +0000
+++ Nux/Area.h	2011-10-25 21:32:25 +0000
@@ -26,7 +26,6 @@
 #include <sigc++/sigc++.h>
 #include "NuxCore/InitiallyUnownedObject.h"
 #include "NuxGraphics/Events.h"
-#include "Focusable.h"
 #include "Utils.h"
 #include "WidgetMetrics.h"
 
@@ -65,11 +64,14 @@
 //! Policy for and element position in the minor dimension of a layout.
   typedef enum
   {
-    MINOR_POSITION_TOP,           //!< Place the element on the top side of the layout (Hlayout)
-    MINOR_POSITION_BOTTOM,        //!< Place the element on the bottom side of the layout (Hlayout)
-    MINOR_POSITION_LEFT,          //!< Place the element on the left side of the layout (Vlayout)
-    MINOR_POSITION_RIGHT,         //!< Place the element on the right side of the layout (Hlayout)
-    MINOR_POSITION_CENTER,        //!< Place the element at the center of the layout (Hlayout and VLayout)
+    MINOR_POSITION_START,         //!< Place the element at the start of the layout(Hlayout and VLayout)
+    MINOR_POSITION_CENTER,        //!< Place the element at the center of the layout(Hlayout and VLayout)
+    MINOR_POSITION_END,           //!< Place the element at the end of the layout(Hlayout and VLayout)
+    MINOR_POSITION_TOP = MINOR_POSITION_START,   //!< Deprecated.
+    MINOR_POSITION_LEFT = MINOR_POSITION_START,  //!< Deprecated.
+    MINOR_POSITION_BOTTOM = MINOR_POSITION_END,  //!< Deprecated.
+    MINOR_POSITION_RIGHT = MINOR_POSITION_END,   //!< Deprecated.
+
     eAbove = MINOR_POSITION_TOP,      //!< Deprecated.
     eBelow = MINOR_POSITION_BOTTOM,   //!< Deprecated.
     eLeft = MINOR_POSITION_LEFT,      //!< Deprecated.
@@ -84,19 +86,23 @@
   */
   typedef enum
   {
-    MAJOR_POSITION_TOP,      //!< Stack elements at the top (for VLayout only).
-    MAJOR_POSITION_BOTTOM,   //!< Stack elements at the bottom (for VLayout only).
-    MAJOR_POSITION_LEFT,     //!< Stack elements at the left (for HLayout only).
-    MAJOR_POSITION_RIGHT,    //!< Stack elements at the right (for HLayout only).
-    MAJOR_POSITION_CENTER,   //!< Stack elements in the center of the layout (for HLayout and VLayout).
-    MAJOR_POSITION_EXPAND,   //!< Spread elements evenly inside the layout (for HLayout and VLayout).
+    MAJOR_POSITION_CENTER,   //!< Stack elements in the center of the layout(for HLayout and VLayout).
+    MAJOR_POSITION_START,    //!< Stack elements at the begining of the layout(for HLayout and VLayout).
+    MAJOR_POSITION_END,      //!< Stack elements at the end of the layout(for HLayout and VLayout).
+    MAJOR_POSITION_SPREAD,   //!< Spread elements evenly inside the layout(for HLayout and VLayout).
+
+    MAJOR_POSITION_TOP = MAJOR_POSITION_START,    //!< Deprecated.
+    MAJOR_POSITION_BOTTOM = MAJOR_POSITION_END,   //!< Deprecated.
+    MAJOR_POSITION_LEFT = MAJOR_POSITION_START,   //!< Deprecated.
+    MAJOR_POSITION_RIGHT = MAJOR_POSITION_END,    //!< Deprecated.
+
 
     eStackTop = MAJOR_POSITION_TOP,         //!< Deprecated.
     eStackBottom = MAJOR_POSITION_BOTTOM,   //!< Deprecated.
     eStackLeft = MAJOR_POSITION_LEFT,       //!< Deprecated.
     eStackRight = MAJOR_POSITION_RIGHT,     //!< Deprecated.
     eStackCenter = MAJOR_POSITION_CENTER,   //!< Deprecated.
-    eStackExpand = MAJOR_POSITION_EXPAND,   //!< Deprecated.
+    eStackExpand = MAJOR_POSITION_SPREAD,   //!< Deprecated.
   }  LayoutContentDistribution;
 
   //! For internal use only.
@@ -134,25 +140,21 @@
     KEY_NAV_ENTER,
   };
 
+  typedef enum
+  {
+    LeftToRight,
+    RightToLeft
+  } Direction;
+
   class Layout;
   class View;
   class Area;
 
-  class Area: public InitiallyUnownedObject, public Focusable
+  class Area: public InitiallyUnownedObject
   {
-    NUX_DECLARE_OBJECT_TYPE (Area, InitiallyUnownedObject);
-  public:
-    class LayoutProperties
-    {
-      public:
-      virtual ~LayoutProperties ()
-      {
-
-      }
-    };
-
-  public:
-    Area (NUX_FILE_LINE_DECL);
+    NUX_DECLARE_OBJECT_TYPE(Area, InitiallyUnownedObject);
+  public:
+    Area(NUX_FILE_LINE_DECL);
     virtual ~Area();
 
     int GetBaseX() const;
@@ -171,29 +173,29 @@
         The size is adjusted to respect the min and max size policy
         \sa SetWidth(), SetHeight(), SetMinimumSize(), SetMaximumSize().
     */
-    void SetBaseSize (int w, int h);
-
-    void SetMinimumSize(int w, int h);
-    void SetMaximumSize(int w, int h);
-    void SetMinMaxSize(int w, int h);
-
-    void SetMinimumWidth(int w);
-    void SetMaximumWidth(int w);
-    void SetMinimumHeight(int h);
-    void SetMaximumHeight(int h);
-
-    int GetMinimumWidth() const;
-    int GetMaximumWidth() const;
-    int GetMinimumHeight() const;
-    int GetMaximumHeight() const;
-
-    void ApplyMinWidth();
-    void ApplyMinHeight();
-    void ApplyMaxWidth();
-    void ApplyMaxHeight();
-
-    Size GetMinimumSize() const;
-    Size GetMaximumSize() const;
+    virtual void SetBaseSize(int w, int h);
+
+    virtual void SetMinimumSize(int w, int h);
+    virtual void SetMaximumSize(int w, int h);
+    virtual void SetMinMaxSize(int w, int h);
+
+    virtual void SetMinimumWidth(int w);
+    virtual void SetMaximumWidth(int w);
+    virtual void SetMinimumHeight(int h);
+    virtual void SetMaximumHeight(int h);
+
+    virtual int GetMinimumWidth() const;
+    virtual int GetMaximumWidth() const;
+    virtual int GetMinimumHeight() const;
+    virtual int GetMaximumHeight() const;
+
+    virtual void ApplyMinWidth();
+    virtual void ApplyMinHeight();
+    virtual void ApplyMaxWidth();
+    virtual void ApplyMaxHeight();
+
+    virtual Size GetMinimumSize() const;
+    virtual Size GetMaximumSize() const;
 
     //! Get the geometry of the object.
     /*!
@@ -212,7 +214,7 @@
 
         \sa SetBaseWidth(), SetBaseHeight(), SetBaseX(), SetBaseY().
     */
-    void SetGeometry (int x, int y, int w, int h);
+    void SetGeometry(int x, int y, int w, int h);
 
     //! Set the geometry of the object.
     /*!
@@ -222,32 +224,36 @@
         @param geo Geometry object.
         \sa SetWidth(), SetHeight(), SetX(), SetY().
     */
-    void SetGeometry (const Geometry &geo);
-
-    void IncreaseSize (int x, int y);
-
-    void SetBaseString (const TCHAR *Caption);
+    void SetGeometry(const Geometry &geo);
+
+    void IncreaseSize(int x, int y);
+
+    void SetBaseString(const char *Caption);
     const NString &GetBaseString() const;
 
-    //! Return the Top level parent of this area.
+    //! Deprecated. Use GetToplevel.
+    Area* GetToplevel();
+
+    //! Return the root parent of the rendering tree for this area.
     /*!
-        The top Level parent is either a BaseWindow or the main layout.
+        The root parent of the rendering tree is either a BaseWindow or the main layout.
+        If the object isn't hooked to the rendering tree the function returns NULL.
 
-        @return The top level parent or Null.
+        @return The root parent of the rendering tree or NULL.
     */
-    Area * GetToplevel ();
+    Area* GetRootParent();
 
     //! Return the Top level BaseWindow of this area.
     /*!
         @return The top level BaseWindow or NULL.
     */
-    Area * GetTopLevelViewWindow ();
+    Area* GetTopLevelViewWindow();
 
     //! Return true is this area has a top level parent.
     /*!
         @return True if this area has a top level parent.
     */
-    bool HasTopLevelParent ();
+    bool HasTopLevelParent();
 
     //! Return true is area is a child of the given parent in the widget tree.
     /*!
@@ -260,7 +266,7 @@
         Test if a point is inside the area.
 
         @param p A 2D point.
-        @param event_type The type of mouse event (a parameter of FindAreaUnderMouse).
+        @param event_type The type of mouse event(a parameter of FindAreaUnderMouse).
 
         @return True if p is located inside the Area.
     */
@@ -270,7 +276,7 @@
         Test if a point is inside the area and if the area accepts mouse wheel events.
 
         @param p A 2D point.
-        @param event_type The type of mouse event (a parameter of FindAreaUnderMouse).
+        @param event_type The type of mouse event(a parameter of FindAreaUnderMouse).
         @param filter_mouse_wheel_event If the event type is NUX_MOUSE_WHEEL and the mouse is over this area and this
         area does not accept mouse wheel events, then return false.
 
@@ -278,34 +284,23 @@
     */
     bool TestMousePointerInclusionFilterMouseWheel(const Point& mouse_position, NuxEventType event);
 
-    virtual long ComputeChildLayout ();
-    virtual void PositionChildLayout (float offsetX, float offsetY);
-    virtual long ComputeLayout2 ();
-    virtual void ComputePosition2 (float offsetX, float offsetY);
-
-    virtual bool IsArea () const;
-    virtual bool IsInputArea () const;
-    virtual bool IsView () const;
-    virtual bool IsLayout () const;
-    virtual bool IsSpaceLayout () const;
-    virtual bool IsViewWindow () const;
-
-    //! Set the layout properties for this area
-    /*!
-        Allows the Layout managing this area to store the properties specifc to this area. Layouts
-        should create a sub-class of LayoutProperties. The LayoutProperties of an area will
-        be deleted upon destruction.
-        @param properties the LayoutProperties sub-class  associated with this area. Can be NULL to
-         unset.
-    */
-    void SetLayoutProperties (LayoutProperties *properties);
-
-    //! Get the layout properties for this area
-    /*!
-        Retrieves the LayoutProperties sub-class with this area. See SetLayoutProperties
-        @return LayoutProperties sub-class associated with this area.
-    */
-    LayoutProperties * GetLayoutProperties ();
+    //! Test if the muse pointer is inside the area.
+    /*!
+        Return true if the mouse pointer is inside the area.
+        
+        @return True if the mouse pointer is inside the area.
+    */
+    bool IsMousePointerInside() const;
+
+    virtual long ComputeContentSize();
+    virtual void ComputeContentPosition(float offsetX, float offsetY);
+
+    virtual bool IsArea() const;
+    virtual bool IsInputArea() const;
+    virtual bool IsView() const;
+    virtual bool IsLayout() const;
+    virtual bool IsSpaceLayout() const;
+    virtual bool IsViewWindow() const;
 
     Area * GetParentObject() const;
 
@@ -314,36 +309,41 @@
         If visible, an area will be drawn. Default: true.
         @param visible if the area is visible to the user
     */
-    void SetVisible  (bool visible);
+    void SetVisible(bool visible);
 
     //! Get the visibility of the area
     /*!
         Gets whether the area is visible to the user and will be visible to the user. Default is true.
         @return whether the area is visible
     */
-    bool IsVisible ();
-
-    //! Set sensitivity of the area
+    bool IsVisible();
+
+    //! Deprecated. Use SetInputEventSensitivity.
+    void SetSensitive(bool);
+
+    //! Set input event sensitivity of the area.
     /*!
-        If sensitive, an area will receive input events. Default is true.
-        @param  if the area should receive input events
+        A insensitive Area will not receive input events.\n
+        If the Area has a layout, the event will be passed down to it. Sensitivity only control an area's ability to receive input events(keyboard, mouse, touch).
+        An area that is not sensitive will return false in \a TestMousePointerInclusion, \a TestMousePointerInclusionFilterMouseWheel and \a AcceptKeyNavFocus.\n
+        Sensitivity does not affect layouts since they do not process events.
+
+        By default, an area is sensitive.
+
+        @param sensitive If the area should receive input events
     */
-    void SetSensitive  (bool sensitive);
-
-    //! Get whether the area is sensitive
+    void SetInputEventSensitivity(bool sensitive);
+
+    //! Deprecated. Use GetInputEventSensitivity.
+    bool IsSensitive() const;
+
+    //! Get input event sensitivity of the area is sensitive
     /*!
         Gets whether the area is sensitive to input events
         @return whether the area is visible
     */
-    bool IsSensitive ();
+    bool GetInputEventSensitivity() const;
 
-    virtual bool DoGetFocused ();
-    virtual void DoSetFocused (bool focused);
-    virtual bool DoCanFocus ();
-    virtual void DoActivateFocus ();
-    
-    sigc::signal<void, Area *> FocusActivated;
-    sigc::signal<void, Area *> FocusChanged;
     sigc::signal<void, Area*> ChildFocusChanged; // sends parent + child
 
     /*!
@@ -358,106 +358,132 @@
     /*!
         Queues a relayout before the next paint cycle. This is safe to call multiple times within a cycle.
     */
-    void QueueRelayout ();
-
-    virtual unsigned int GetStretchFactor();
-    virtual void SetStretchFactor (unsigned int sf);
+    void QueueRelayout();
+
+    //! Get the area scale factor.
+    /*!
+        The scale factor is used to control the layout of area objects inside HLayout and VLayout.
+        \sa HLayout, VLayout.
+
+        @return the Area scale factor.
+    */
+    virtual unsigned int GetScaleFactor();
+
+    //! Set the area scale factor.
+    /*!
+        The scale factor is used to control the layout of area objects inside HLayout and VLayout.
+        \sa HLayout, VLayout.
+
+        @param the scale factor.
+    */
+    virtual void SetScaleFactor(unsigned int sf);
 
     virtual MinorDimensionPosition GetPositioning();
-    virtual void SetPositioning (MinorDimensionPosition p);
+    virtual void SetPositioning(MinorDimensionPosition p);
 
     virtual MinorDimensionSize GetExtend();
-    virtual void SetExtend (MinorDimensionSize ext);
+    virtual void SetExtend(MinorDimensionSize ext);
 
     virtual float GetPercentage();
-    virtual void SetPercentage (float f);
+    virtual void SetPercentage(float f);
     virtual bool IsLayoutDone();
-    virtual void SetLayoutDone (bool b);
-
-    void Set2DMatrix (const Matrix4 &mat);
-    void Set2DTranslation (float tx, float ty, float tz);
-    Matrix4 Get2DMatrix () const;
-
-    Matrix4 Get3DMatrix () const;
-    bool Is3DArea () const;
+    virtual void SetLayoutDone(bool b);
+
+    void Set2DMatrix(const Matrix4 &mat);
+    void Set2DTranslation(float tx, float ty, float tz);
+    Matrix4 Get2DMatrix() const;
+
+    Matrix4 Get3DMatrix() const;
+    bool Is3DArea() const;
 
     //! Return the position of this object with regard to its top left corner of the physical window.
     /*!
         Return the position of the Area inside the physical window.
         For the main layout set in WindowThread, The following functions are equivalent:
-        \li GetGeometry ()
-        \li GetRootGeometry ()
-        \li GetAbsoluteGeometry ()
+        \li GetGeometry()
+        \li GetRootGeometry()
+        \li GetAbsoluteGeometry()
     */
-    virtual Geometry GetAbsoluteGeometry () const;
+    virtual Geometry GetAbsoluteGeometry() const;
 
     //! Return the area absolute x coordinate.
-    int GetAbsoluteX () const;
+    int GetAbsoluteX() const;
     
     //! Return the area absolute y coordinate.
-    int GetAbsoluteY () const;
+    int GetAbsoluteY() const;
     
     //! Return the area absolute width.
     /*!
-        As long as _2d_xform contains only translations, the absolute width is the same as value returned by GetBaseWidth ();
+        As long as _2d_xform contains only translations, the absolute width is the same as value returned by GetBaseWidth();
     */
-    int GetAbsoluteWidth () const;
+    int GetAbsoluteWidth() const;
     
     //! Return the area absolute height.
     /*!
-        As long as _2d_xform contains only translations, the absolute height is the same as value returned by GetBaseHeight ();
+        As long as _2d_xform contains only translations, the absolute height is the same as value returned by GetBaseHeight();
     */
-    int GetAbsoluteHeight () const;
+    int GetAbsoluteHeight() const;
 
-    //! Return the position of this object with regard to its top level parent (the main layout or a BaseWindow).
+    //! Return the position of this object with regard to its top level parent(the main layout or a BaseWindow).
     /*!
         Return the position of the Area inside the physical window.
-        For the main layout set in WindowThread or for a BaseWindow, GetRootGeometry () is equivalent to GetGeometry ().
+        For the main layout set in WindowThread or for a BaseWindow, GetRootGeometry() is equivalent to GetGeometry().
     */
-    virtual Geometry GetRootGeometry () const;
+    virtual Geometry GetRootGeometry() const;
 
     //! Return the area root x coordinate.
-    int GetRootX () const;
+    int GetRootX() const;
 
     //! Return the area root y coordinate.
-    int GetRootY () const;
+    int GetRootY() const;
 
     //! Return the area root width.
     /*!
-        As long as _2d_xform contains only translations, the root width is the same as value returned by GetBaseWidth ();
+        As long as _2d_xform contains only translations, the root width is the same as value returned by GetBaseWidth();
     */
-    int GetRootWidth () const;
+    int GetRootWidth() const;
 
     //! Return the area root height.
     /*!
-        As long as _2d_xform contains only translations, the root width is the same as value returned by GetBaseWidth ();
+        As long as _2d_xform contains only translations, the root width is the same as value returned by GetBaseWidth();
     */
-    int GetRootHeight () const;
+    int GetRootHeight() const;
 
     sigc::signal<void, int, int, int, int> OnResize; //!< Signal emitted when an area is resized.
     sigc::signal<void, Area *, bool> OnVisibleChanged;
     sigc::signal<void, Area *, bool> OnSensitiveChanged;
+
+    /*!
+        This signal is only meant to inform of a change of size. When receiving this signal don't do anything
+        that could change the size of this object. Or you risk creating an infinite loop.
+    */
     sigc::signal<void, Area *, Geometry&> OnGeometryChanged;
 
     /*!
-        SetParentObject/UnParentObject are protected API. it is not meant to be used directly by users.
+        SetParentObject/UnParentObject are protected API. They are not meant to be used directly by users.
         Users add widgets to layouts and layout have to be attached to a composition for objects to be rendered.
         Setting a parent to and child widget does not mean that when the parent is rendered, the child is also rendered.
-        For instance, setting a button the be the child of a check-box means absolutely nothing is terms of rendering.
-        A widget with a parent cannot be added to a added to a layout for rendering. The widget has to be un-parented first.
-        A layout with a parent cannot be added to a widget or another layout for rendering. The layout has to be un-parented first.
-        In essence only View and Layouts should be calling SetParentObject/UnParentObject.
+        For instance, setting a button to be the child of a check-box means absolutely nothing is terms of rendering.
+        The check-box draw function would have to be aware of the existence of the button in order to render it.\n
+        A view with a parent cannot be parented to another area for rendering. It has to be un-parented first.\n
+        A layout with a parent cannot be parented to another area for rendering. It has to be un-parented first.\n
+        In essence only View and Layouts should be calling SetParentObject/UnParentObject.\n
+        SetParentObject returns true if it was successful.
+        
+
+        @param parent The object that will become the parent of this area.
+        @return True if the object is successfully parented. 
     */
-    virtual void SetParentObject (Area *);
+    virtual bool SetParentObject(Area *parent);
 
     //! Un-parent and area
     /*!
         For un-parented areas the following functions are equivalent:
-          \li GetGeometry ()
-          \li GetRootGeometry ()
-          \li GetAbsoluteGeometry ()
+          \li GetGeometry()
+          \li GetRootGeometry()
+          \li GetAbsoluteGeometry()
     */
-    virtual void UnParentObject ();
+    virtual void UnParentObject();
 
     /*!
         Return the area under the mouse pointer.
@@ -491,7 +517,7 @@
         When the geometry of an area changes, the new geometry can be recursively propagated to all its 
         parent so a layout reconfiguration is initiated.
         \sa ReconfigureParentLayout()
-        \sa _on_geometry_changeg_reconfigure_parent_layout
+        \sa on_geometry_change_reconfigure_parent_layout_
 
         @param reconfigure_parent_layout Set it to True to reconfigure this area parent layouts.
     */
@@ -527,37 +553,53 @@
     */
     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:
-    bool _is_focused;
     /*
         This function is reimplemented in Layout as it need to perform some special operations.
         It does nothing for Area and View classes.
     */
     //virtual void RemoveChildObject(smptr(Area));
 
-    virtual void GeometryChangePending () {}
-    virtual void GeometryChanged () {}
+    /*!
+        This signal is only meant to inform that the size is about to change. When overriding this function,
+        don't do anything that could change the size of this object. Or you risk creating an infinite loop.
+    */
+    virtual void GeometryChangePending() {}
+    
+    /*!
+        This signal is only meant to inform that the size has changed. When overriding this function,
+        don't do anything that could change the size of this object. Or you risk creating an infinite loop.
+    */
+    virtual void GeometryChanged() {}
 
     //! Request a Layout recompute after a change of size
     /*
         When an object size changes, it is necessary for its parent structure to initiate a layout
         re computation in order preserve the layout structure defined by the user through the API.
     */
-    virtual void RequestBottomUpLayoutComputation (Area *bo_initiator);
-
-    //! Return the absolute geometry starting with a relative geometry passed as argument.
-    void InnerGetAbsoluteGeometry (Geometry &geometry);
-
-    //! Return the absolute geometry starting with a relative geometry passed as argument.
-    void InnerGetRootGeometry (Geometry &geometry);
+    virtual void RequestBottomUpLayoutComputation(Area *bo_initiator);
+
+    //! Return the absolute geometry starting with a relative geometry passed as argument.
+    void InnerGetAbsoluteGeometry(Geometry &geometry);
+
+    //! Return the absolute geometry starting with a relative geometry passed as argument.
+    void InnerGetRootGeometry(Geometry &geometry);
 
 //     //! Add a "secondary" child to this Area. The
 //     /*!
 //         @return True if the child has been added; False otherwise;
 //     */
-//     bool Secondary (Area *child);
+//     bool Secondary(Area *child);
    
-    bool _on_geometry_changeg_reconfigure_parent_layout;
+    bool on_geometry_change_reconfigure_parent_layout_;
 
     bool                    has_key_focus_;
 
@@ -568,32 +610,32 @@
     void CheckMaxSize();
 
 
-    Geometry                _geometry;        //!< The area geometry.
+    Geometry                geometry_;        //!< The area geometry.
 
     //! Define a parent child structure
     /*
         An object of the class Area may have another of the class Layout as Parent.
         An object of the class View may have an object of the class Layout as parent.
         An object of the class Layout may have a parent of the class Layout or View as parent.
-        A Area cannot have children (that may change later).
+        A Area cannot have children(that may change later).
     */
-    Area                    *_parent_area;
-    
+    Area                    *parent_area_;
 
-    LayoutProperties        *_layout_properties;
-    bool                    _visible;
-    bool                    _sensitive;
+    bool              visible_;       //!< Visible state of the area.
+    bool              sensitive_;     //!< Input sensitive state of the area
+    bool              view_enabled_;  //!< The enable state of a view.
 
     NString                 _base_string;     //!< A text string property for this area.
 
-    Size                    _min_size;        //!< A text string property for this area.
-    Size                    _max_size;        //!< A text string property for this area.
+    Size                    min_size_;        //!< A text string property for this area.
+    Size                    max_size_;        //!< A text string property for this area.
 
-    unsigned int            _stretch_factor;  //!< Factor for element expansion.
-    MinorDimensionPosition  _positioning;     //!< Area position hint
-    MinorDimensionSize      _extend;          //!< Area dimension hint
-    float                   _percentage;      //!< Area size percentage value.
-    bool                    _layout_done;     //!< Area layout status flag.
+    // Parameters used in layouts
+    unsigned int            scale_factor_;          //!< Factor for element expansion.
+    MinorDimensionPosition  minor_axis_position_;   //!< Area position hint
+    MinorDimensionSize      minor_axis_size_;       //!< Area dimension hint
+    float                   minor_axis_size_scale_; //!< Area size percentage value.
+    bool                    layout_done_;           //!< Area layout status flag.
 
 
     Matrix4                 _2d_xform;        //!< 2D transformation matrix for this area and its children. Contains only translations.
@@ -605,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/BaseWindow.cpp'
--- Nux/BaseWindow.cpp	2011-09-20 06:03:43 +0000
+++ Nux/BaseWindow.cpp	2011-10-25 21:32:25 +0000
@@ -32,7 +32,7 @@
 namespace nux
 {
 
-  NUX_IMPLEMENT_OBJECT_TYPE (BaseWindow);
+  NUX_IMPLEMENT_OBJECT_TYPE(BaseWindow);
 
   const int SizeGripWidth = 20;
   const int SizeGripHeight = 20;
@@ -44,10 +44,10 @@
       pass the top-left corner position of the window. When drawing, make a similar adjustment.
   */
 
-  BaseWindow::BaseWindow (const TCHAR *WindowName, NUX_FILE_LINE_DECL)
-    : View (NUX_FILE_LINE_PARAM)
+  BaseWindow::BaseWindow(const char *WindowName, NUX_FILE_LINE_DECL)
+    : View(NUX_FILE_LINE_PARAM)
     , _paint_layer(new ColorLayer(Color(0xFF707070)))
-    , _opacity (1.0f)
+    , _opacity(1.0f)
   {
     premultiply = true;
     _name = WindowName;
@@ -70,9 +70,9 @@
     accept_key_nav_focus_ = false;
 
     // Should be at the end of the constructor
-    GetWindowCompositor().RegisterWindow (this);
+    GetWindowCompositor().RegisterWindow(this);
 
-    SetMinimumSize (1, 1);
+    SetMinimumSize(1, 1);
     SetGeometry(Geometry(100, 100, 320, 200));
   }
 
@@ -80,7 +80,7 @@
   {
     if (_enter_focus_input_area)
     {
-      _enter_focus_input_area->UnReference ();
+      _enter_focus_input_area->UnReference();
     }
 
 #if defined(NUX_OS_LINUX)
@@ -89,160 +89,90 @@
 #endif
   }
 
-  long BaseWindow::ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
-  {
-    long ret = TraverseInfo;
-    long ProcEvInfo = 0;
-
-    IEvent window_event = ievent;
-    Geometry base = GetGeometry();
-    window_event.e_x_root = base.x;
-    window_event.e_y_root = base.y;
-
-    // The child layout get the Mouse down button only if the MouseDown happened inside the client view Area
-    Geometry viewGeometry = GetGeometry();
-
-    if (ievent.e_event == NUX_MOUSE_PRESSED)
-    {
-      if (!viewGeometry.IsPointInside (ievent.e_x - ievent.e_x_root, ievent.e_y - ievent.e_y_root) )
-      {
-        ProcEvInfo = eDoNotProcess;
-      }
-    }
-
-    if (m_layout)
-      ret = m_layout->ProcessEvent (window_event, ret, ProcEvInfo);
-
-    // PostProcessEvent2 must always have its last parameter set to 0
-    // because the m_BackgroundArea is the real physical limit of the window.
-    // So the previous test about IsPointInside do not prevail over m_BackgroundArea
-    // testing the event by itself.
-    ret = PostProcessEvent2 (ievent, ret, 0);
-    return ret;
-  }
-
   Area* BaseWindow::FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type)
   {
     bool mouse_inside = TestMousePointerInclusionFilterMouseWheel(mouse_position, event_type);
 
-    if(mouse_inside == false)
+    if (mouse_inside == false)
       return NULL;
 
-    if(m_layout)
+    if (m_layout)
     {
       nuxAssert(m_layout->IsLayout());
       Area* found_area = m_layout->FindAreaUnderMouse(mouse_position, event_type);
-      if(found_area)
+      if (found_area)
         return found_area;
     }
 
-    if((event_type == NUX_MOUSE_WHEEL) && (!AcceptMouseWheelEvent()))
+    if ((event_type == NUX_MOUSE_WHEEL) && (!AcceptMouseWheelEvent()))
       return NULL;
     return this;
   }
 
-  void BaseWindow::Draw (GraphicsEngine &GfxContext, bool force_draw)
+  void BaseWindow::Draw(GraphicsEngine &graphics_engine, bool force_draw)
   {
     Geometry base = GetGeometry();
-    // The elements position inside the window are referenced to top-left window corner. So bring base to (0, 0).
-    base.SetX (0);
-    base.SetY (0);
-    GfxContext.PushClippingRectangle (base);
+    // The elements position inside the window are referenced to top-left window corner. So bring base to(0, 0).
+    base.SetX(0);
+    base.SetY(0);
+    graphics_engine.PushClippingRectangle(base);
 
-    GetPainter().PushDrawLayer(GfxContext, base, _paint_layer.get());
+    GetPainter().PushDrawLayer(graphics_engine, base, _paint_layer.get());
 
     GetPainter().PopBackground();
-    GfxContext.PopClippingRectangle();
+    graphics_engine.PopClippingRectangle();
   }
 
-  void BaseWindow::DrawContent (GraphicsEngine &GfxContext, bool force_draw)
+  void BaseWindow::DrawContent(GraphicsEngine &graphics_engine, bool force_draw)
   {
 
     Geometry base = GetGeometry();
-    // The elements position inside the window are referenced to top-left window corner. So bring base to (0, 0).
-    base.SetX (0);
-    base.SetY (0);
-
-
-    GetPainter().PushLayer(GfxContext, base, _paint_layer.get());
+    // The elements position inside the window are referenced to top-left window corner. So bring base to(0, 0).
+    base.SetX(0);
+    base.SetY(0);
+
+
+    GetPainter().PushLayer(graphics_engine, base, _paint_layer.get());
 
     if (m_layout)
     {
-      GfxContext.PushClippingRectangle (base);
-      m_layout->ProcessDraw (GfxContext, force_draw);
-      GfxContext.PopClippingRectangle();
+      graphics_engine.PushClippingRectangle(base);
+      m_layout->ProcessDraw(graphics_engine, force_draw);
+      graphics_engine.PopClippingRectangle();
     }
 
     GetPainter().PopBackground();
   }
 
-  void BaseWindow::PostDraw (GraphicsEngine &GfxContext, bool force_draw)
+  void BaseWindow::PostDraw(GraphicsEngine &graphics_engine, bool force_draw)
   {
 
   }
 
-  void BaseWindow::SetConfigureNotifyCallback (ConfigureNotifyCallback Callback, void *Data)
+  void BaseWindow::SetConfigureNotifyCallback(ConfigureNotifyCallback Callback, void *Data)
   {
     m_configure_notify_callback = Callback;
     m_configure_notify_callback_data = Data;
   }
 
-  void BaseWindow::AddWidget (View *ic)
-  {
-    if (ic && m_layout)
-    {
-      m_layout->AddView (ic, 0);
-      // 0: the WidgetLayout geometry will be set to SetGeometry(0,0,1,1);
-      // and the children will take their natural size by expending WidgetLayout.
-      // If the parent of WidgetLayout offers more space, it won't be used by WidgetLayout.
-
-      ComputeChildLayout();
-    }
-  }
-
-  void BaseWindow::AddWidget (View *ic, int stretchfactor)
-  {
-    if (ic && m_layout)
-    {
-      m_layout->AddView (ic, stretchfactor);
-      // if(stretchfactor ==0): the WidgetLayout geometry will be set to SetGeometry(0,0,1,1);
-      // and the children will take their natural size by expending WidgetLayout.
-      // If the parent of WidgetLayout offers more space, it won't be used by WidgetLayout.
-
-      ComputeChildLayout();
-    }
-  }
-
-  void BaseWindow::AddWidget (std::list<View *> *ViewList)
-  {
-    m_CompositionLayout->Clear();
-
-    std::list<View *>::iterator it;
-
-    for (it = ViewList->begin(); it != ViewList->end(); it++)
-    {
-      AddWidget ( (*it) );
-    }
-  }
-
-  Layout* BaseWindow::GetLayout ()
+  Layout* BaseWindow::GetLayout()
   {
     return m_layout;
   }
 
-  bool BaseWindow::SetLayout (Layout *layout)
+  bool BaseWindow::SetLayout(Layout *layout)
   {
-    if (View::SetLayout (layout) == false)
+    if (View::SetLayout(layout) == false)
       return false;
 
     m_layout = layout;
     Geometry geo = GetGeometry();
-    Geometry layout_geo = Geometry (geo.x + m_Border, geo.y + m_TopBorder,
+    Geometry layout_geo = Geometry(geo.x + m_Border, geo.y + m_TopBorder,
                                     geo.GetWidth() - 2 * m_Border, geo.GetHeight() - m_Border - m_TopBorder);
-    m_layout->SetGeometry (layout_geo);
+    m_layout->SetGeometry(layout_geo);
 
     // When this call returns the layout computation is done.
-    ComputeChildLayout();
+    ComputeContentSize();
     // or use
     //GetWindowThread()->QueueObjectLayout(m_layout);
 
@@ -257,16 +187,16 @@
 
     if (m_configure_notify_callback)
     {
-      (*m_configure_notify_callback) (GetGraphicsDisplay()->GetWindowWidth(), GetGraphicsDisplay()->GetWindowHeight(), geo, m_configure_notify_callback_data);
+      (*m_configure_notify_callback)(GetGraphicsDisplay()->GetWindowWidth(), GetGraphicsDisplay()->GetWindowHeight(), geo, m_configure_notify_callback_data);
 
-      if (geo.IsNull() )
+      if (geo.IsNull())
       {
-        nuxDebugMsg (TEXT ("[BaseWindow::PreLayoutManagement] Received an invalid Geometry.") );
+        nuxDebugMsg("[BaseWindow::PreLayoutManagement] Received an invalid Geometry.");
         geo = GetGeometry();
       }
       else
       {
-        Area::SetGeometry (geo);
+        Area::SetGeometry(geo);
         // Get the geometry adjusted with respect to min and max dimension of this area.
         geo = GetGeometry();
       }
@@ -274,30 +204,30 @@
 
     if (m_layout)
     {
-      Geometry layout_geo = Geometry (m_Border, m_TopBorder,
+      Geometry layout_geo = Geometry(m_Border, m_TopBorder,
                                       geo.GetWidth() - 2 * m_Border, geo.GetHeight() - m_Border - m_TopBorder);
 
-      if (IsSizeMatchContent ())
-        m_layout->SetGeometry (Geometry (0, 0, 1, 1));
+      if (IsSizeMatchContent())
+        m_layout->SetGeometry(Geometry(0, 0, 1, 1));
       else
-        m_layout->SetGeometry (layout_geo);
+        m_layout->SetGeometry(layout_geo);
     }
   }
 
 // Get a change to do any work on an element.
 // Here we need to position the header by hand because it is not under the control of vlayout.
-  long BaseWindow::PostLayoutManagement (long LayoutResult)
+  long BaseWindow::PostLayoutManagement(long LayoutResult)
   {
     if (IsSizeMatchContent() && m_layout)
     {
       Geometry layout_geometry = m_layout->GetGeometry();
 
-      Geometry WindowGeometry = Geometry (GetGeometry().x,
+      Geometry WindowGeometry = Geometry(GetGeometry().x,
                                           GetGeometry().y,
                                           layout_geometry.GetWidth() + 2 * m_Border,
                                           layout_geometry.GetHeight() + m_Border + m_TopBorder);
 
-      Area::SetGeometry (WindowGeometry);
+      Area::SetGeometry(WindowGeometry);
     }
 
     // A BaseWindow must kill the result of the management and pass it to the parent Layout.
@@ -307,13 +237,13 @@
 
 // Get a change to do any work on an element.
 // Here we need to position the header by hand because it is not under the control of vlayout.
-  void BaseWindow::PositionChildLayout (float offsetX, float offsetY)
+  void BaseWindow::ComputeContentPosition(float offsetX, float offsetY)
   {
 
   }
   
   #if defined(NUX_OS_LINUX)
-  void BaseWindow::EnableInputWindow (bool        b,
+  void BaseWindow::EnableInputWindow(bool        b,
                                       const char* title,
                                       bool        take_focus,
                                       bool        override_redirect)
@@ -321,62 +251,62 @@
     if (b)
     {
       if (m_input_window == 0)
-        m_input_window = new XInputWindow (title, take_focus, override_redirect);
+        m_input_window = new XInputWindow(title, take_focus, override_redirect);
         
-      m_input_window->Show ();
-      m_input_window->SetGeometry (GetGeometry());
+      m_input_window->Show();
+      m_input_window->SetGeometry(GetGeometry());
       m_input_window_enabled = true;
     }
     else
     {
       if (m_input_window)
-        m_input_window->Hide ();
+        m_input_window->Hide();
       m_input_window_enabled = false;
     }
   }
 
-  bool BaseWindow::InputWindowEnabled ()
+  bool BaseWindow::InputWindowEnabled()
   {
     return m_input_window_enabled;
   }
   
-  void BaseWindow::InputWindowEnableStruts (bool enable)
-  {
-    if (m_input_window)
-      m_input_window->EnableStruts (enable);
-  }
-  
-  bool BaseWindow::InputWindowStrutsEnabled ()
-  {
-    return m_input_window_enabled && m_input_window->StrutsEnabled ();
-  }
-  
-  void BaseWindow::SetInputFocus ()
-  {
-    if (m_input_window)
-      m_input_window->SetInputFocus ();
+  void BaseWindow::InputWindowEnableStruts(bool enable)
+  {
+    if (m_input_window)
+      m_input_window->EnableStruts(enable);
+  }
+  
+  bool BaseWindow::InputWindowStrutsEnabled()
+  {
+    return m_input_window_enabled && m_input_window->StrutsEnabled();
+  }
+  
+  void BaseWindow::SetInputFocus()
+  {
+    if (m_input_window)
+      m_input_window->SetInputFocus();
   }
 
-  Window BaseWindow::GetInputWindowId ()
+  Window BaseWindow::GetInputWindowId()
   {
     if (m_input_window)
-      return m_input_window->GetWindow ();
+      return m_input_window->GetWindow();
     else
       return 0;
   }
 
   #endif
 
-  void BaseWindow::SetGeometry (const Geometry &geo)
+  void BaseWindow::SetGeometry(const Geometry &geo)
   {
-    Area::SetGeometry (geo);
+    Area::SetGeometry(geo);
     
     #if defined(NUX_OS_LINUX)
     if (m_input_window)
-      m_input_window->SetGeometry (geo);
+      m_input_window->SetGeometry(geo);
     #endif
     //LayoutWindowElements();
-    //ComputeChildLayout();
+    //ComputeContentSize();
   }
 
   void BaseWindow::LayoutWindowElements()
@@ -386,7 +316,7 @@
     Geometry base = GetGeometry();
   }
 
-  void BaseWindow::SetBorder (int border)
+  void BaseWindow::SetBorder(int border)
   {
     if (m_Border != border)
     {
@@ -394,7 +324,7 @@
     }
   }
 
-  void BaseWindow::SetTopBorder (int border)
+  void BaseWindow::SetTopBorder(int border)
   {
     if (m_TopBorder != border)
     {
@@ -432,7 +362,7 @@
       sigVisible.emit(this);
       GetWindowCompositor().sigVisibleViewWindow.emit(this);
 
-      ComputeChildLayout();
+      ComputeContentSize();
     }
     else
     {
@@ -459,7 +389,7 @@
     _is_visible = false;
     _is_modal = false;
     //ShowWindow(false);
-    GetWindowCompositor().StopModalWindow (ObjectWeakPtr<BaseWindow> (this));
+    GetWindowCompositor().StopModalWindow(ObjectWeakPtr<BaseWindow> (this));
   }
 
   bool BaseWindow::IsModal() const
@@ -467,7 +397,7 @@
     return _is_modal;
   }
 
-  void BaseWindow::NotifyConfigurationChange (int Width, int Height)
+  void BaseWindow::NotifyConfigurationChange(int Width, int Height)
   {
     Geometry geo = GetGeometry();
 
@@ -475,14 +405,14 @@
     {
       (*m_configure_notify_callback) (GetGraphicsDisplay()->GetWindowWidth(), GetGraphicsDisplay()->GetWindowHeight(), geo, m_configure_notify_callback_data);
 
-      if (geo.IsNull() )
+      if (geo.IsNull())
       {
-        nuxDebugMsg (TEXT ("[BaseWindow::NotifyConfigurationChange] Received an invalid Geometry.") );
+        nuxDebugMsg("[BaseWindow::NotifyConfigurationChange] Received an invalid Geometry.");
         geo = GetGeometry();
       }
       else
       {
-        Area::SetGeometry (geo);
+        Area::SetGeometry(geo);
         // Get the geometry adjusted with respect to min and max dimension of this area.
         geo = GetGeometry();
       }
@@ -493,68 +423,68 @@
     }
   }
 
-  void BaseWindow::SetBackgroundLayer (AbstractPaintLayer *layer)
+  void BaseWindow::SetBackgroundLayer(AbstractPaintLayer *layer)
   {
-    NUX_RETURN_IF_NULL (layer);
+    NUX_RETURN_IF_NULL(layer);
     _paint_layer.reset(layer->Clone());
   }
 
-  void BaseWindow::SetBackgroundColor (const Color &color)
+  void BaseWindow::SetBackgroundColor(const Color &color)
   {
     _paint_layer.reset(new ColorLayer(color));
   }
 
-  void BaseWindow::PushHigher (BaseWindow* floating_view)
-  {
-    GetWindowCompositor().PushHigher (this, floating_view);
-  }
-
-  void BaseWindow::PushToFront ()
-  {
-    GetWindowCompositor().PushToFront (this);
-  }
-
-  void BaseWindow::PushToBack ()
-  {
-    GetWindowCompositor().PushToBack (this);
-  }
-
-  bool BaseWindow::ChildNeedsRedraw ()
+  void BaseWindow::PushHigher(BaseWindow* floating_view)
+  {
+    GetWindowCompositor().PushHigher(this, floating_view);
+  }
+
+  void BaseWindow::PushToFront()
+  {
+    GetWindowCompositor().PushToFront(this);
+  }
+
+  void BaseWindow::PushToBack()
+  {
+    GetWindowCompositor().PushToBack(this);
+  }
+
+  bool BaseWindow::ChildNeedsRedraw()
   {
     return _child_need_redraw;
   }
 
-  void* BaseWindow::GetBackupTextureData (int &width, int &height, int &format)
+  void* BaseWindow::GetBackupTextureData(int &width, int &height, int &format)
   {
-    return GetWindowCompositor ().GetBackupTextureData (this, width, height, format);
+    return GetWindowCompositor().GetBackupTextureData(this, width, height, format);
   }
 
-  void BaseWindow::SetEnterFocusInputArea (InputArea *input_area)
+  void BaseWindow::SetEnterFocusInputArea(InputArea *input_area)
   {
     if (_enter_focus_input_area)
     {
-      _enter_focus_input_area->UnReference ();
+      _enter_focus_input_area->UnReference();
     }
 
     _enter_focus_input_area = input_area;
     if (_enter_focus_input_area)
-      _enter_focus_input_area->Reference ();
+      _enter_focus_input_area->Reference();
 
   }
 
-  void BaseWindow::SetOpacity (float opacity)
+  void BaseWindow::SetOpacity(float opacity)
   {
     if (_opacity == opacity)
       return;
 
     _opacity = opacity;
 
-    _opacity = CLAMP (_opacity, 0.0f, 1.0f);
+    _opacity = CLAMP(_opacity, 0.0f, 1.0f);
 
-    QueueDraw ();
+    QueueDraw();
   }
 
-  float BaseWindow::GetOpacity ()
+  float BaseWindow::GetOpacity()
   {
     return _opacity;
   }
 
=== modified file 'Nux/BaseWindow.h'
--- Nux/BaseWindow.h	2011-09-20 06:03:43 +0000
+++ Nux/BaseWindow.h	2011-10-25 21:32:25 +0000
@@ -58,7 +58,7 @@
       @param int          The height of the window.
       @param Geometry&    The tentative size of the window.
   */
-  typedef void (*ConfigureNotifyCallback) (int, int, Geometry &, void *);
+  typedef void(*ConfigureNotifyCallback) (int, int, Geometry &, void *);
 
   /*!
     A floating area on top of the main window.
@@ -66,23 +66,18 @@
   */
   class BaseWindow: public View
   {
-    NUX_DECLARE_OBJECT_TYPE (BaseWindow, View);
+    NUX_DECLARE_OBJECT_TYPE(BaseWindow, View);
   public:
-    BaseWindow (const TCHAR *WindowName = TEXT (""), NUX_FILE_LINE_PROTO);
+    BaseWindow(const char *WindowName = "", NUX_FILE_LINE_PROTO);
     virtual ~BaseWindow();
 
     nux::Property<bool> premultiply;
 
     virtual Area* FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type);
-    virtual long ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
-    virtual void Draw (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void DrawContent (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void PostDraw (GraphicsEngine &GfxContext, bool force_draw);
+    virtual void Draw(GraphicsEngine &graphics_engine, bool force_draw);
+    virtual void DrawContent(GraphicsEngine &graphics_engine, bool force_draw);
+    virtual void PostDraw(GraphicsEngine &graphics_engine, bool force_draw);
 
-    void AddWidget (View *ic);
-    void AddWidget (View *ic, int stretchfactor);
-    void AddWidget (std::list<View *> *ViewList);
-    
     virtual Layout* GetLayout();
     virtual bool SetLayout(Layout *layout);
 
@@ -90,37 +85,37 @@
     /*!
         Push this view one level up the ViewWindow stack. Does it even if the view is hidden.
     */
-    void PushHigher (BaseWindow* floating_view);
+    void PushHigher(BaseWindow* floating_view);
 
     //! Push the view one level down the ViewWindow stack.
     /*!
         Push this view one level down the ViewWindow stack. Does it even if the view is hidden.
     */
-    void PushLower (BaseWindow* floating_view);
+    void PushLower(BaseWindow* floating_view);
 
     //! Push the view to the front of the ViewWindow stack.
     /*!
         Push this view to the top of the ViewWindow stack. Does it even if the view is hidden.
         If a valid ViewWindow has been forced at the top of the stack with a call to WindowCompositor::SetAlwaysOnFrontWindow(),
         then this view will be positioned one level below that view.
-        \sa SetAlwaysOnFrontWindow ();
+        \sa SetAlwaysOnFrontWindow();
     */
-    void PushToFront ();
+    void PushToFront();
       
     //! Push the view to the back of the ViewWindow stack.
     /*!
         Push this view to the back of the ViewWindow stack. Does it even if the view is hidden.
     */
-    void PushToBack ();
+    void PushToBack();
 
     //! Set the window size to respect the layout container.
     /*!
         Set the window size to be such that the container layout size remains the same after ComputeSizeLayout2 is
-        called on the layout. The window elements (title bar, minimize and close buttons) are positioned accordingly.
+        called on the layout. The window elements(title bar, minimize and close buttons) are positioned accordingly.
         The size grip is not responding anymore.
         @param b If b is true, the window size respect the size the layout container.
     */
-    virtual void SetWindowSizeMatchLayout (bool b)
+    virtual void SetWindowSizeMatchLayout(bool b)
     {
       _size_match_layout = b;
     }
@@ -134,12 +129,12 @@
       return _size_match_layout;
     }
 
-    virtual void ShowWindow (bool b, bool StartModal = false);
-    void StopModal ();
-    bool IsModal () const;
-    bool IsVisible () const;
+    virtual void ShowWindow(bool b, bool StartModal = false);
+    void StopModal();
+    bool IsModal() const;
+    bool IsVisible() const;
 
-    virtual void SetGeometry (const Geometry &geo);
+    virtual void SetGeometry(const Geometry &geo);
 
     /*!
         Call this function to set a callback function that is called when this object is need to be resized or re-positioned.
@@ -147,24 +142,24 @@
         @param Data     The callback data.
     */
 
-    void SetConfigureNotifyCallback (ConfigureNotifyCallback Callback, void *Data);
-
-    void SetBackgroundLayer (AbstractPaintLayer *layer);
-    void SetBackgroundColor (const Color &color);
-
-    void  SetOpacity (float opacity);
-    float GetOpacity ();
+    void SetConfigureNotifyCallback(ConfigureNotifyCallback Callback, void *Data);
+
+    void SetBackgroundLayer(AbstractPaintLayer *layer);
+    void SetBackgroundColor(const Color &color);
+
+    void  SetOpacity(float opacity);
+    float GetOpacity();
 
     #if defined(NUX_OS_LINUX)
-    void EnableInputWindow (bool        b,
+    void EnableInputWindow(bool        b,
                             const char* title = "nux input window",
                             bool        take_focus = False,
                             bool        override_redirect = False);
-    bool InputWindowEnabled ();
-    void InputWindowEnableStruts (bool enable);
-    bool InputWindowStrutsEnabled ();
-    void SetInputFocus ();
-    Window GetInputWindowId ();
+    bool InputWindowEnabled();
+    void InputWindowEnableStruts(bool enable);
+    bool InputWindowStrutsEnabled();
+    void SetInputFocus();
+    Window GetInputWindowId();
     #endif
 
     //! Set an InputArea to receive the keyboard focus when the BaseWIndow receives the NUX_WINDOW_ENTER_FOCUS event.
@@ -172,18 +167,18 @@
         \sa _enter_focus_input_area.
         @param input_area An InputArea pointer object. Must be a child of this BaseWindow.
     */
-    void SetEnterFocusInputArea (InputArea *input_area);
+    void SetEnterFocusInputArea(InputArea *input_area);
 
 
     //! Get the backup texture data of this BaseWindow,
-    void* GetBackupTextureData (int &width, int &height, int &format);
+    void* GetBackupTextureData(int &width, int &height, int &format);
 
     //! Emit a signal when the BaseWindow becomes visible.
     sigc::signal<void, BaseWindow*> sigVisible;
     //! Emit a signal when the BaseWindow becomes hidden.
     sigc::signal<void, BaseWindow*> sigHidden;
 
-    NString GetWindowName ()
+    NString GetWindowName()
     {
       return _name;
     }
@@ -204,9 +199,9 @@
 
     friend class ComboBox_Logic_WindowView;
 
-    virtual void PreLayoutManagement ();
-    virtual long PostLayoutManagement (long LayoutResult);
-    virtual void PositionChildLayout (float offsetX, float offsetY);
+    virtual void PreLayoutManagement();
+    virtual long PostLayoutManagement(long LayoutResult);
+    virtual void ComputeContentPosition(float offsetX, float offsetY);
     //! Layout the window elements.
     /*!
         Layout elements such as button on the title bar, and the resize widget according to the current
@@ -220,12 +215,12 @@
         @param Width    New width of the window.
         @param Height   New height of the window.
     */
-    virtual void NotifyConfigurationChange (int Width, int Height);
+    virtual void NotifyConfigurationChange(int Width, int Height);
 
     int GetBorder() const;
     int GetTopBorder() const;
-    void SetBorder (int border);
-    void SetTopBorder (int border);
+    void SetBorder(int border);
+    void SetTopBorder(int border);
     int m_TopBorder;
     int m_Border;
     boost::scoped_ptr<AbstractPaintLayer> _paint_layer;
@@ -233,7 +228,7 @@
     bool _entering_visible_state;  //!< the window is about to be made visible during event processing
     bool _entering_hidden_state;   //!< the window is about to be made hidden during event processing
     
-    bool ChildNeedsRedraw ();
+    bool ChildNeedsRedraw();
 
     #if defined(NUX_OS_LINUX)
     bool m_input_window_enabled;
 
=== removed file 'Nux/BezierCurveControl.cpp'
--- Nux/BezierCurveControl.cpp	2011-09-20 06:03:43 +0000
+++ Nux/BezierCurveControl.cpp	1970-01-01 00:00:00 +0000
@@ -1,343 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-
-#include "Nux.h"
-#include "NuxCore/Math/Constants.h"
-#include "NuxCore/Math/Spline.h"
-#include "NuxCore/Math/Bezier.h"
-#include "BezierCurveControl.h"
-
-namespace nux
-{
-
-  const int KNOT_SIZE = 2;
-  const int KNOT_HIT_TEST = 4;
-
-  BezierCurveControl::BezierCurveControl (NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-    ,   m_minX (0.0f),
-    m_minY (0.0f),
-    m_maxX (1.0f),
-    m_maxY (1.0f),
-    m_FunctionCallback (0)
-  {
-    SetMinimumSize (400, 300);
-    SetBaseSize (400, 300);
-
-    m_control_knot.push_back (Knot (0.0f, 0.0f) );
-    m_control_knot.push_back (Knot (0.1f, 0.0f) );
-    m_control_knot.push_back (Knot (0.7f, 0.9f) );
-    m_control_knot.push_back (Knot (1.0f, 1.0f) );
-
-    mouse_down.connect (sigc::mem_fun (this, &BezierCurveControl::RecvMouseDown) );
-    mouse_up.connect (sigc::mem_fun (this, &BezierCurveControl::RecvMouseUp) );
-    mouse_drag.connect (sigc::mem_fun (this, &BezierCurveControl::RecvMouseDrag) );
-
-  }
-
-  BezierCurveControl::~BezierCurveControl()
-  {
-
-
-  }
-
-
-  long BezierCurveControl::ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
-  {
-    long ret = TraverseInfo;
-
-    if (ievent.e_event == NUX_MOUSE_PRESSED)
-    {
-      if (!GetGeometry().IsPointInside (ievent.e_x, ievent.e_y) )
-      {
-        //ProcEvInfo = eDoNotProcess;
-        //return TraverseInfo;
-      }
-    }
-
-    ret = PostProcessEvent2 (ievent, ret, 0);
-    return ret;
-  }
-
-
-  void BezierCurveControl::Draw (GraphicsEngine &GfxContext, bool force_draw)
-  {
-    Geometry base = GetGeometry();
-
-    GetPainter().PaintBackground (GfxContext, base);
-    GetPainter().Paint2DQuadWireframe (GfxContext, base, Color (COLOR_BACKGROUND_SECONDARY) );
-
-#define N 3
-    t_u32 i;
-    t_u32 nsample = 30;
-    double t;
-    t_u32 nbKnot = (t_u32) m_control_knot.size();
-
-    if (nbKnot > 0)
-    {
-      double *xcon = new double[nbKnot];
-      double xval;
-      double *ycon = new double[nbKnot];
-      double yval;
-
-
-      for (i = 0; i < nbKnot; i++)
-      {
-        xcon[i] = m_control_knot[i].m_X;
-        ycon[i] = m_control_knot[i].m_Y;
-      }
-
-      int W = GetBaseWidth() - 2;
-      int H = GetBaseHeight() - 2;
-      int X = GetBaseX() + 1;
-      int Y = GetBaseY() + 1;
-
-      double xprev, yprev;
-      Bezier_XY (N, 0.0, xcon, ycon, &xprev, &yprev);
-
-      //GetPainter().Draw2DLine(X, Y, X+W, Y+H, Color(0xFFFF0000));
-
-      base.OffsetPosition (1, 1);
-      base.OffsetSize (-2, -2);
-
-      GfxContext.PushClippingRectangle (base);
-
-      GfxContext.GetRenderStates().EnableLineSmooth (TRUE, 1, GL_FASTEST);
-      GfxContext.GetRenderStates().SetBlend (TRUE, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-      for (i = 1; i < nsample; i++)
-      {
-        t = ( double ) ( i ) / ( double ) ( nsample - 1 );
-        Bezier_XY ( N, t, xcon, ycon, &xval, &yval );
-
-        int X0, Y0, X1, Y1;
-        X0 = X + W * (xprev - m_minX) / (m_maxX - m_minX);
-        Y0 = Y + H * ( 1 - (yprev - m_minY) / (m_maxY - m_minY) );
-        X1 = X + W * (xval - m_minX) / (m_maxX - m_minX);
-        Y1 = Y + H * ( 1 - (yval - m_minY) / (m_maxY - m_minY) );
-
-        GetPainter().Draw2DLine (GfxContext, X0, Y0, X1, Y1, Color (0xFFFF0000) );
-
-        xprev = xval;
-        yprev = yval;
-      }
-
-      GfxContext.GetRenderStates().EnableLineSmooth (FALSE);
-      GfxContext.GetRenderStates().SetBlend (GL_FALSE);
-
-      for (i = 0; i < nbKnot - 1; i++)
-      {
-        int X0, Y0, X1, Y1;
-        X0 = X + W * (m_control_knot[i].m_X - m_minX) / (m_maxX - m_minX);
-        Y0 = Y + H * ( 1 - (m_control_knot[i].m_Y - m_minY) / (m_maxY - m_minY) );
-        X1 = X + W * (m_control_knot[i+1].m_X - m_minX) / (m_maxX - m_minX);
-        Y1 = Y + H * ( 1 - (m_control_knot[i+1].m_Y - m_minY) / (m_maxY - m_minY) );
-
-        GetPainter().Draw2DLine (GfxContext, X0, Y0, X1, Y1, Color (0xFF0000FF) );
-
-      }
-
-      for (i = 0; i < nbKnot; i++)
-      {
-        int X0, Y0;
-        X0 = X + W * (m_control_knot[i].m_X - m_minX) / (m_maxX - m_minX);
-        Y0 = Y + H * ( 1 - (m_control_knot[i].m_Y - m_minY) / (m_maxY - m_minY) );
-
-        if (m_control_knot[i].m_IsSelected)
-          GetPainter().Paint2DQuadColor (GfxContext, X0 - KNOT_SIZE, Y0 - KNOT_SIZE, 2 * KNOT_SIZE, 2 * KNOT_SIZE, Color (0xFF00FF00) );
-        else
-          GetPainter().Paint2DQuadColor (GfxContext, X0 - KNOT_SIZE, Y0 - KNOT_SIZE, 2 * KNOT_SIZE, 2 * KNOT_SIZE, Color (0xFF777777) );
-      }
-
-      delete[] xcon;
-      delete[] ycon;
-    }
-
-//    for(int i = 1; i < GetWidth(); i++)
-//    {
-//        float x1, y1;
-//
-//        x1 = x0 + dX;
-//        y1 = EvalFunction(x1);
-//
-//        int X0, Y0, X1, Y1;
-//        X0 = X + W * (x0 - m_minX) / (m_maxX - m_minX);
-//        Y0 = Y - H * (y0 + m_minY) / (m_maxY - m_minY);
-//        X1 = X + W * (x1 - m_minX) / (m_maxX - m_minX);
-//        Y1 = Y - H * (y1 + m_minY) / (m_maxY - m_minY);
-//        GetPainter().Draw2DLine(X0, Y0, X1, Y1, Color(0xFFFF0000));
-//
-//        x0 = x1;
-//        y0 = y1;
-//
-//    }
-    GfxContext.PopClippingRectangle();
-  }
-
-
-  void BezierCurveControl::DrawContent (GraphicsEngine &GfxContext, bool force_draw)
-  {
-
-  }
-
-  void BezierCurveControl::PostDraw (GraphicsEngine &GfxContext, bool force_draw)
-  {
-
-  }
-
-
-  void BezierCurveControl::SetXAxisBounds (float minX, float maxX)
-  {
-    m_minX = minX;
-    m_maxX = maxX;
-    QueueDraw();
-  }
-
-  void BezierCurveControl::SetYAxisBounds (float minY, float maxY)
-  {
-    m_minY = minY;
-    m_maxY = maxY;
-    QueueDraw();
-  }
-
-  void BezierCurveControl::SetFunctionCallback (FunctionCallback f)
-  {
-    m_FunctionCallback = f;
-    QueueDraw();
-  }
-
-  float BezierCurveControl::EvalFunction (float x)
-  {
-    if (m_FunctionCallback != 0)
-      return (*m_FunctionCallback) (x);
-
-    return 0;
-  }
-
-  void BezierCurveControl::UpdateGraph()
-  {
-    QueueDraw();
-  }
-
-
-// check if a value lies within a closed interval
-#ifndef INSIDE_BOUNDS
-#define INSIDE_BOUNDS( x, lo, hi ) ( (x) >= (lo) && (x) <= (hi) )
-#endif
-
-//check if a 2D point lies within a 2D box
-#ifndef PT_INSIDE_BOX
-#define PT_INSIDE_BOX( x, y, lo_x, hi_x, lo_y, hi_y ) ( INSIDE_BOUNDS(x,lo_x,hi_x) && INSIDE_BOUNDS(y,lo_y,hi_y) )
-#endif
-
-  void BezierCurveControl::RecvMouseUp (int x, int y, unsigned long button_flags, unsigned long key_flags)
-  {
-    QueueDraw();
-  }
-
-  void BezierCurveControl::RecvMouseDown (int x, int y, unsigned long button_flags, unsigned long key_flags)
-  {
-    t_u32 nbKnot = (t_u32) m_control_knot.size();
-
-    for (t_u32 i = 0; i < nbKnot; i++)
-    {
-      m_control_knot[i].m_IsSelected = false;
-    }
-
-    int W = GetBaseWidth() - 2;
-    int H = GetBaseHeight() - 2;
-    int X = GetBaseX() + 1;
-    int Y = GetBaseY() + 1;
-
-    bool b = PT_INSIDE_BOX (X + x, Y + y, X, X + W, Y, Y + H);
-
-    if (b == false)
-      return;
-
-    X = GetBaseX();
-    Y = GetBaseY();
-
-    for (t_u32 i = 0; i < nbKnot; i++)
-    {
-      int Xp, Yp;
-      Xp = X + W * (m_control_knot[i].m_X - m_minX) / (m_maxX - m_minX);
-      Yp = Y + H * ( 1 - (m_control_knot[i].m_Y - m_minY) / (m_maxY - m_minY) );
-
-      if (PT_INSIDE_BOX (X + x, Y + y, Xp - KNOT_HIT_TEST, Xp + KNOT_HIT_TEST, Yp - KNOT_HIT_TEST, Yp + KNOT_HIT_TEST) )
-      {
-        m_control_knot[i].m_IsSelected = true;
-        break;
-      }
-    }
-
-    QueueDraw();
-  }
-
-  void BezierCurveControl::RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
-  {
-    float xp, yp;
-
-    int W = GetBaseWidth();
-    int H = GetBaseHeight();
-    t_u32 nbKnot = (t_u32) m_control_knot.size();
-
-    xp = m_minX + (m_maxX - m_minX) * dx / W;
-    yp = m_minY + (m_maxY - m_minY) * dy / H;
-
-
-
-    for (t_u32 i = 0; i < nbKnot; i++)
-    {
-      if (m_control_knot[i].m_IsSelected)
-      {
-        m_control_knot[i].m_X += xp;
-        m_control_knot[i].m_Y -= yp;
-
-        if (m_control_knot[i].m_X < m_minX)
-        {
-          m_control_knot[i].m_X = m_minX;
-        }
-
-        if (m_control_knot[i].m_X > m_maxX)
-        {
-          m_control_knot[i].m_X = m_maxX;
-        }
-
-        if (m_control_knot[i].m_Y < m_minY)
-        {
-          m_control_knot[i].m_Y = m_minY;
-        }
-
-        if (m_control_knot[i].m_Y > m_maxY)
-        {
-          m_control_knot[i].m_Y = m_maxY;
-        }
-
-        break;
-      }
-    }
-
-    QueueDraw();
-  }
-
-
-}
 
=== removed file 'Nux/BezierCurveControl.h'
--- Nux/BezierCurveControl.h	2011-04-06 21:54:09 +0000
+++ Nux/BezierCurveControl.h	1970-01-01 00:00:00 +0000
@@ -1,105 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-
-#ifndef BEZIERCURVECONTROL_H
-#define BEZIERCURVECONTROL_H
-
-namespace nux
-{
-
-  class Knot
-  {
-  public :
-
-    float  m_X;
-    float  m_Y;
-
-    bool m_IsSelected;
-
-  public :
-
-    Knot()
-      :   m_X (0)
-      ,   m_Y (0)
-      ,   m_IsSelected (false)
-    {}	//Constructors
-    Knot (float ptX, float ptY)
-      :   m_X (ptX)
-      ,   m_Y (ptY)
-      ,   m_IsSelected (false)
-    {}
-
-    void setPoint (float x, float y)
-    {
-      m_X = x;  //Setting
-      m_Y = y;
-    }
-
-
-    //Operator overloading
-    void operator = (Knot knot)
-    {
-      m_X = knot.m_X;
-      m_Y = knot.m_Y;
-    }
-    bool operator != (Knot knot)
-    {
-      bool b;
-      b = ( (m_X != knot.m_X) || (m_Y != knot.m_Y) ) ? true : false;
-      return b;
-    }
-  };
-
-
-  typedef float (*FunctionCallback) (float);
-
-  class BezierCurveControl : public View
-  {
-  public:
-    BezierCurveControl (NUX_FILE_LINE_PROTO);
-    ~BezierCurveControl();
-    virtual long ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo);
-    virtual void Draw (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void DrawContent (GraphicsEngine &GfxContext, bool force_draw);
-    virtual void PostDraw (GraphicsEngine &GfxContext, bool force_draw);
-
-
-    void RecvMouseUp (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseDown (int x, int y, unsigned long button_flags, unsigned long key_flags);
-    void RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
-  private:
-    void SetXAxisBounds (float minX, float maxX);
-    void SetYAxisBounds (float minY, float maxY);
-    void SetFunctionCallback (FunctionCallback f);
-    float EvalFunction (float x);
-    void UpdateGraph();
-
-    std::vector<Knot> m_control_knot;
-
-    float m_minX, m_minY, m_maxX, m_maxY;
-    FunctionCallback m_FunctionCallback;
-  };
-
-
-}
-
-#endif // BEZIERCURVECONTROL_H
 
=== removed file 'Nux/BezierCurveControl2.cpp'
--- Nux/BezierCurveControl2.cpp	2011-09-20 06:03:43 +0000
+++ Nux/BezierCurveControl2.cpp	1970-01-01 00:00:00 +0000
@@ -1,1046 +0,0 @@
-/*
- * Copyright 2010 Inalogic® Inc.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * 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 along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Jay Taoko <[e-mail]>
- *
- */
-
-
-#include "Nux.h"
-
-#include "BezierCurveControl2.h"
-#include "NuxCore/Math/Bezier.h"
-
-namespace nux
-{
-
-  static const int KNOT_SIZE = 2;
-  static const int KNOT_HIT_TEST = 4;
-  static const int CURVE_DEGREE = 3;
-  static const int GRAPH_MARGIN = 2;
-  static const int UNIT_REFERENCE = 15;
-
-  unsigned long S_KEY = 0;
-
-  BezierCurveControl2::BezierCurveControl2 (NUX_FILE_LINE_DECL)
-    :   View (NUX_FILE_LINE_PARAM)
-    ,   m_minX (-0.10f),
-    m_minY (-0.100f),
-    m_maxX (1.100f),
-    m_maxY (1.100f),
-    m_FunctionCallback (0),
-    m_bControlPointSelected (0),
-    m_bPanningEnabled (true),
-    m_bZoomingEnabled (true)
-  {
-    SetMinimumSize (180, 180);
-
-    m_control_knot.push_back (Knot2 (0.0f, 0.0f) );
-    m_control_knot.push_back (Knot2 (0.1f, 0.0f) );
-    m_control_knot.push_back (Knot2 (0.7f, 0.9f) );
-    m_control_knot.push_back (Knot2 (1.0f, 1.0f) );
-
-    mouse_down.connect (sigc::mem_fun (this, &BezierCurveControl2::RecvMouseDown) );
-    mouse_up.connect (sigc::mem_fun (this, &BezierCurveControl2::RecvMouseUp) );
-    mouse_drag.connect (sigc::mem_fun (this, &BezierCurveControl2::RecvMouseDrag) );
-
-    key_down.connect (sigc::mem_fun (this, &BezierCurveControl2::RecvKeyEvent) );
-
-    NTextureData image;
-    MakeCheckBoardImage (image.GetSurface (0), 64, 64, Color (0xff323232), Color (0xff535353), 8, 8);
-    BaseTexture* m_CheckboardPattern = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableTexture ();
-    m_CheckboardPattern->Update (&image);
-
-    TexCoordXForm texxform;
-    texxform.SetTexCoordType (TexCoordXForm::OFFSET_COORD);
-    texxform.SetWrap (TEXWRAP_REPEAT, TEXWRAP_REPEAT);
-    m_Background = new TextureLayer (m_CheckboardPattern->GetDeviceTexture(), texxform, color::White);
-
-    m_CheckboardPattern->UnReference ();
-  }
-
-  BezierCurveControl2::~BezierCurveControl2()
-  {
-    delete m_Background;
-  }
-
-  long BezierCurveControl2::ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
-  {
-    long ret = TraverseInfo;
-
-    if (ievent.e_event == NUX_MOUSE_PRESSED)
-    {
-      if (!GetGeometry().IsPointInside (ievent.e_x, ievent.e_y) )
-      {
-        //ProcEvInfo = eDoNotProcess;
-        //return TraverseInfo;
-      }
-    }
-
-    S_KEY = ievent.GetVirtualKeyState (NUX_VK_S);
-    ret = PostProcessEvent2 (ievent, ret, ProcessEventInfo);
-    return ret;
-  }
-
-
-  void BezierCurveControl2::Draw (GraphicsEngine &GfxContext, bool force_draw)
-  {
-    Geometry base = GetGeometry();
-
-    GetPainter().PaintBackground (GfxContext, base);
-    GetPainter().Paint2DQuadColor (GfxContext, base, Color (COLOR_BACKGROUND_PRIMARY) );
-    base.OffsetPosition (GRAPH_MARGIN, GRAPH_MARGIN);
-    base.OffsetSize (-2 * GRAPH_MARGIN, -2 * GRAPH_MARGIN);
-
-    int W = GetBaseWidth() - 2 * GRAPH_MARGIN;
-    int H = GetBaseHeight() - 2 * GRAPH_MARGIN;
-    int X = GetBaseX() + GRAPH_MARGIN;
-    int Y = GetBaseY() + GRAPH_MARGIN;
-
-    t_u32 i;
-    int nsample = base.GetWidth();
-    double t;
-    t_u32 nbKnot = (t_u32) m_control_knot.size();
-
-    GfxContext.PushClippingRectangle (base);
-
-    GetPainter().PushDrawLayer (GfxContext, base, m_Background);
-    GetPainter().PopBackground();
-
-    //DrawGrid(GfxContext);
-    DrawCoordinateSystem (GfxContext);
-