Merge lp:~njpatel/nux/nux.redirected-views-3.0 into lp:nux/3.0

[Neil J. Patel]

This branch introduces "Redirected Views" in Nux. Redirected views allows a view to be rendered inside its own texture and that texture is latter composited inside the main rendering.
This branch contains the required changes for redirected views. The opportunty was also taken to fix minor issues and introduce API changes.

This branch introduces "Redirected Views" in Nux. Redirected views allows a view to be rendered inside its own texture and that texture is latter composited inside the main rendering.
This branch contains the required changes for redirected views. The opportunty was also taken to fix minor issues and introduce API changes.

== Core of the Redirected View
  Nux/Area.cpp
  Nux/Area.h
  Nux/Layout.cpp
  Nux/Layout.h
  Nux/View.cpp
  Nux/View.h

== Fixed ClientArea to work with RedirectedViews
  Nux/ClientArea.cpp
  Nux/ClientArea.h

== Concrete implementation of a view to replace InputArea in some locations
  Nux/BasicView.cpp
  Nux/BasicView.h

== Nux.h contains the Feature.h file of Nux
  Nux/Nux.h

== API change to frame buffer object architecture
  NuxGraphics/IOpenGLFrameBufferObject.cpp
  NuxGraphics/IOpenGLFrameBufferObject.h

== Added InitSlTexturePremultiplyShader shader
  NuxGraphics/RenderingPipeGLSL.cpp
  NuxGraphics/GraphicsEngine.cpp
  NuxGraphics/GraphicsEngine.h
  NuxGraphics/RenderingPipeAsm.cpp

== Fixed texture inversion
  NuxGraphics/RenderingPipe.cpp

[Neil J. Patel (njpatel)]

https://bugs.launchpad.net/ayatana-design/+bug/1049593 is the FFe

[Jay Taoko (jaytaoko)]

review: Approve

[Unity Merger (unity-merger)]

The prerequisite lp:~njpatel/nux/weak-ptrs-on-window-compostor-3.0 has not yet been merged into lp:nux/3.0.

[Unity Merger (unity-merger)]

The prerequisite lp:~njpatel/nux/weak-ptrs-on-window-compostor-3.0 has not yet been merged into lp:nux/3.0.

[Unity Merger (unity-merger)]

The prerequisite lp:~njpatel/nux/weak-ptrs-on-window-compostor-3.0 has not yet been merged into lp:nux/3.0.

[Unity Merger (unity-merger)]

No proposals found for merge of lp:~njpatel/nux/weak-ptrs-on-window-compostor-3.0 into lp:nux/3.0.

=== modified file 'Nux/AbstractCheckedButton.cpp'
--- Nux/AbstractCheckedButton.cpp	2011-10-18 20:00:59 +0000
+++ Nux/AbstractCheckedButton.cpp	2012-09-18 19:02:35 +0000
@@ -39,7 +39,7 @@
     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_   = new BasicView(NUX_TRACKER_LOCATION);
 
     check_area_->SetInputEventSensitivity(false);
     static_text_->SetInputEventSensitivity(false);

=== modified file 'Nux/AbstractComboBox.cpp'
--- Nux/AbstractComboBox.cpp	2011-10-10 01:52:00 +0000
+++ Nux/AbstractComboBox.cpp	2012-09-18 19:02:35 +0000
@@ -37,8 +37,8 @@
     ,   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);
+    _combo_box_area = new BasicView(NUX_TRACKER_LOCATION);
+    _combo_box_opening_area    = new BasicView(NUX_TRACKER_LOCATION);
 
     m_hlayout->AddView(_combo_box_area, 1);
     m_hlayout->AddView(_combo_box_opening_area, 0);

=== modified file 'Nux/AbstractComboBox.h'
--- Nux/AbstractComboBox.h	2011-10-10 01:52:00 +0000
+++ Nux/AbstractComboBox.h	2012-09-18 19:02:35 +0000
@@ -48,8 +48,8 @@
 
   protected:
     HLayout    *m_hlayout;
-    InputArea   *_combo_box_area;
-    InputArea   *_combo_box_opening_area;
+    BasicView   *_combo_box_area;
+    BasicView   *_combo_box_opening_area;
     StaticText  *_pango_static_text;
     bool        m_MenuIsActive;
     bool        m_IsOpeningMenu;

=== modified file 'Nux/Area.cpp'
--- Nux/Area.cpp	2012-09-18 19:02:34 +0000
+++ Nux/Area.cpp	2012-09-18 19:02:35 +0000
@@ -39,11 +39,15 @@
   NUX_IMPLEMENT_OBJECT_TYPE(Area);
 
   Area::Area(NUX_FILE_LINE_DECL)
-    :   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)
-    ,   layout_done_(true)
+    : InitiallyUnownedObject(NUX_FILE_LINE_PARAM)
+    , redirect_rendering_to_texture_(false)
+    , update_backup_texture_(false)
+    , present_redirected_view_(true)
+    , copy_previous_fbo_for_background_(true)
+    , 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)
+    , layout_done_(true)
   {
     window_thread_ = GetWindowThread();
     visible_ = true;
@@ -321,41 +325,76 @@
     return parent_area_;
   }
 
-  int Area::GetBaseX     () const
+  int Area::GetX() const
   {
     return geometry_.x;
   }
 
-  int Area::GetBaseY     () const
+  int Area::GetBaseX() const
+  {
+    return GetX();
+  }
+
+  int Area::GetY() const
   {
     return geometry_.y;
   }
 
-  int Area::GetBaseWidth    () const
+  int Area::GetBaseY() const
+  {
+    return GetY();
+  }
+
+  int Area::GetWidth() const
   {
     return geometry_.width;
   }
 
-  int Area::GetBaseHeight   () const
+  int Area::GetBaseWidth() const
+  {
+    return GetWidth();
+  }
+
+  int Area::GetHeight() const
   {
     return geometry_.height;
   }
 
+  int Area::GetBaseHeight() const
+  {
+    return GetHeight();
+  }
+
   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);
 
+    bool detected_size_change = false;
+    bool detected_position_change = false;
+
+    if (geometry_.x != x || geometry_.y != y)
+      detected_position_change = true;
+
+    if (geometry_.width != w || geometry_.height != h)
+      detected_size_change = true;
+
     nux::Geometry geometry(x, y, w, h);
     if (geometry_ == geometry)
       return;
 
-    GeometryChangePending();
+    GeometryChangePending(detected_position_change, detected_size_change);
     geometry_ = geometry;
     ReconfigureParentLayout();
-    GeometryChanged();
-
-    OnGeometryChanged.emit(this, geometry_);
+    GeometryChanged(detected_position_change, detected_size_change);
+
+    geometry_changed.emit(this, geometry_);
+
+    if (detected_position_change)
+      position_changed.emit(this, x, y);
+
+    if (detected_size_change)
+      size_changed.emit(this, w, h);
   }
 
   void Area::SetGeometry(const Geometry &geo)
@@ -368,40 +407,64 @@
     return geometry_;
   }
 
-  void Area::SetBaseX(int x)
+  void Area::SetX(int x)
   {
     SetGeometry(x, geometry_.y, geometry_.width, geometry_.height);
   }
 
-  void Area::SetBaseY    (int y)
+  void Area::SetY    (int y)
   {
     SetGeometry(geometry_.x, y, geometry_.width, geometry_.height);
   }
 
-  void Area::SetBaseXY    (int x, int y)
+  void Area::SetBaseX(int x)
+  {
+    SetX(x);
+  }
+
+  void Area::SetBaseY(int y)
+  {
+    SetY(y);
+  }
+
+  void Area::SetXY(int x, int y)
   {
     SetGeometry(x, y, geometry_.width, geometry_.height);
   }
 
+  void Area::SetBaseXY(int x, int y)
+  {
+    SetXY(x, y);
+  }
+
+  void Area::SetSize(int w, int h)
+  {
+    SetGeometry(geometry_.x, geometry_.y, w, h);
+  }
+
   void Area::SetBaseSize(int w, int h)
   {
-    SetGeometry(geometry_.x, geometry_.y, w, h);
+    SetSize(w, h);
+  }
+
+  void Area::SetWidth(int w)
+  {
+    SetGeometry(geometry_.x, geometry_.y, w, geometry_.height);
   }
 
   void Area::SetBaseWidth(int w)
   {
-    SetGeometry(geometry_.x, geometry_.y, w, geometry_.height);
+    SetWidth(w);
+  }
+
+  void Area::SetHeight(int h)
+  {
+    SetGeometry(geometry_.x, geometry_.y, geometry_.width, h);
   }
 
   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 );
+    SetHeight(h);
   }
 
   long Area::ComputeContentSize()
@@ -1043,6 +1106,129 @@
     return false;
   }
 
+  /*** Support for redirected rendering ***/
+  void Area::SetRedirectRenderingToTexture(bool redirect)
+  {
+    if (redirect_rendering_to_texture_ == redirect)
+    {
+      return;
+    }
+
+    if ((redirect_rendering_to_texture_ == false) && redirect)
+    {
+      update_backup_texture_ = true;
+    }
+
+    redirect_rendering_to_texture_ = redirect;
+    if (redirect == false)
+    {
+      // Free the texture of this view
+      backup_fbo_.Release();
+      backup_texture_.Release();
+      backup_depth_texture_.Release();
+      prev_fbo_.Release();
+    }
+  }
+
+  bool Area::RedirectRenderingToTexture() const
+  {
+    return redirect_rendering_to_texture_;
+  }
+
+  void Area::SetUpdateBackupTextureForChildRendering(bool update)
+  {
+    update_backup_texture_ = update;
+  }
+
+  ObjectPtr<IOpenGLBaseTexture> Area::BackupTexture() const
+  {
+    // if RedirectRenderingToTexture() is false, then backup_texture_ is not a valid smart pointer.
+    return backup_texture_;
+  }
+
+  bool Area::UpdateBackupTextureForChildRendering() const
+  {
+    return update_backup_texture_;
+  }
+
+  void Area::PrepareParentRedirectedView()
+  {
+    Area* parent = GetParentObject();
+
+    while (parent)
+    {
+      if (parent->RedirectRenderingToTexture() && (parent->UpdateBackupTextureForChildRendering() == false))
+      {
+        parent->SetUpdateBackupTextureForChildRendering(true);
+        parent->PrepareParentRedirectedView();
+      }
+      else if (parent->RedirectRenderingToTexture() && (parent->UpdateBackupTextureForChildRendering() == true))
+      {
+        break;
+      }
+      else
+      {
+        parent->PrepareParentRedirectedView();
+        break;
+      }
+    }
+  }
+
+  bool Area::HasParentRedirectedView()
+  {
+    Area* parent = GetParentObject();
+
+    while (parent && !parent->Type().IsDerivedFromType(View::StaticObjectType))
+    {
+      parent = parent->GetParentObject();
+    }
+
+    if (parent)
+    {
+      View* view = static_cast<View*>(parent);
+      if (view->RedirectRenderingToTexture())
+      {
+        return true;
+      }
+      else
+      {
+        return view->HasParentRedirectedView();
+      }
+    }
+    return false;
+  }
+
+  Area* Area::RedirectedAncestor()
+  {
+    Area* parent = GetParentObject();
+
+    while (parent)
+    {
+      if (parent->RedirectRenderingToTexture())
+      {
+        return parent;
+      }
+      parent = parent->GetParentObject();
+    }
+
+    return NULL;
+  }
+
+  void Area::SetCopyPreviousFboTexture(bool copy_background)
+  {
+    copy_previous_fbo_for_background_ = copy_background;
+  }
+
+  void Area::SetPresentRedirectedView(bool present_redirected_view)
+  {
+    present_redirected_view_ = present_redirected_view;
+  }
+
+  bool Area::PresentRedirectedView() const
+  {
+    return present_redirected_view_;
+  }
+
 #ifdef NUX_GESTURES_SUPPORT
   Area* Area::GetInputAreaHitByGesture(const GestureEvent &event)
   {

=== modified file 'Nux/Area.h'
--- Nux/Area.h	2012-05-31 21:50:05 +0000
+++ Nux/Area.h	2012-09-18 19:02:35 +0000
@@ -24,7 +24,6 @@
 #define BASEOBJECT_H
 
 #include <sigc++/sigc++.h>
-#include "Features.h"
 #include "NuxCore/InitiallyUnownedObject.h"
 #include "NuxGraphics/Events.h"
 #include "Utils.h"
@@ -34,6 +33,9 @@
 {
   class WindowThread;
   class GraphicsEngine;
+  class IOpenGLBaseTexture;
+  class IOpenGLFrameBufferObject;
+
 #ifdef NUX_GESTURES_SUPPORT
   class GestureEvent;
 #endif // NUX_GESTURES_SUPPORT
@@ -155,6 +157,17 @@
     Area(NUX_FILE_LINE_DECL);
     virtual ~Area();
 
+    int GetX() const;
+    int GetY() const;
+    int GetWidth() const;
+    int GetHeight() const;
+
+    void SetX(int x);
+    void SetY(int y);
+    void SetXY(int x, int y);
+    void SetWidth(int w);
+    void SetHeight(int h);
+
     int GetBaseX() const;
     int GetBaseY() const;
     int GetBaseWidth() const;
@@ -171,6 +184,7 @@
         The size is adjusted to respect the min and max size policy
         \sa SetWidth(), SetHeight(), SetMinimumSize(), SetMaximumSize().
     */
+    virtual void SetSize(int w, int h);
     virtual void SetBaseSize(int w, int h);
 
     virtual void SetMinimumSize(int w, int h);
@@ -212,7 +226,7 @@
 
         \sa SetBaseWidth(), SetBaseHeight(), SetBaseX(), SetBaseY().
     */
-    void SetGeometry(int x, int y, int w, int h);
+    virtual void SetGeometry(int x, int y, int w, int h);
 
     //! Set the geometry of the object.
     /*!
@@ -222,13 +236,12 @@
         @param geo Geometry object.
         \sa SetWidth(), SetHeight(), SetX(), SetY().
     */
-    void SetGeometry(const Geometry &geo);
-
-    void IncreaseSize(int x, int y);
 
     void SetBaseString(const char *Caption);
     const NString &GetBaseString() const;
 
+    virtual void SetGeometry(const Geometry& geo);
+
     //! Deprecated. Use GetToplevel.
     Area* GetToplevel();
 
@@ -460,7 +473,17 @@
         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;
+    sigc::signal<void, Area*, Geometry&> geometry_changed;
+
+    /*!
+        This signal emitted when the size of the area has changed. It is emitted after geometry_changed.
+    */
+    sigc::signal<void, Area*, int, int> size_changed;
+
+    /*!
+        This signal emitted when the position of the area has changed. It is emitted after geometry_changed.
+    */
+    sigc::signal<void, Area*, int, int> position_changed;
 
     /*!
         SetParentObject/UnParentObject are protected API. They are not meant to be used directly by users.
@@ -587,13 +610,13 @@
         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() {}
+    virtual void GeometryChangePending(bool position_about_to_change, bool size_about_to_change) {}
     
     /*!
         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() {}
+    virtual void GeometryChanged(bool position_has_changed, bool size_has_changed) {}
 
     //! Request a Layout recompute after a change of size
     /*
@@ -627,6 +650,88 @@
     //! If this variable is not NULL, then this area is part of the keyboard focus chain.
     Area* next_object_to_key_focus_area_;
 
+    
+    /**********************************************/
+    /*** Begin support for redirected rendering ***/
+    /**********************************************/
+public:
+    //! Redirect the rendering of this view to a texture.
+    /*!
+        Redirect the rendering of this view to a texture. \sa BackupTexture().
+        @param redirect If true, redirect the rendering of this view to a texture.
+    */
+    virtual void SetRedirectRenderingToTexture(bool redirect);
+
+    /*!
+        @return True if the rendering of this view is done in a texture.
+    */
+    virtual bool RedirectRenderingToTexture() const;
+
+    //! Return the texture of this View if RedirectRenderingToTexture is enabled.
+    /*
+        Return the texture of this View if RedirectRenderingToTexture is enabled.
+        If RedirectRenderingToTexture() is false, then backup_texture_ is not a valid smart pointer.
+
+        @return the device texture that contains the rendering of this view.
+    */
+    ObjectPtr<IOpenGLBaseTexture> BackupTexture() const;
+
+    /*!
+        The use of this function is a bit arcan but it gives more rendering
+        options to redirected areas.
+    */
+    void SetCopyPreviousFboTexture(bool copy);
+
+    /*!
+        Activate/Deactivate the presentation of the redirected texture in the rendering tree.
+    */
+    void SetPresentRedirectedView(bool present_redirected_view);
+
+    /*!
+        @return True if the redirected texture is displayed in the rendering tree.
+    */
+    bool PresentRedirectedView() const;
+
+protected:
+    //! Redirect the rendering of the view to a texture.
+    bool redirect_rendering_to_texture_;
+    bool update_backup_texture_;
+    bool present_redirected_view_;
+    //! The texture that holds the rendering of this view.
+    ObjectPtr<IOpenGLBaseTexture> backup_texture_;
+    ObjectPtr<IOpenGLBaseTexture> backup_depth_texture_;
+    ObjectPtr<IOpenGLBaseTexture> background_texture_;
+    ObjectPtr<IOpenGLFrameBufferObject> backup_fbo_;
+    ObjectPtr<IOpenGLFrameBufferObject> prev_fbo_;
+    Geometry prev_viewport_;
+    Matrix4 model_view_matrix_;
+    Matrix4 perspective_matrix_;
+    /*!
+        If true, copy the area in the previous fbo texture
+        into background_texture_.
+    */
+    bool copy_previous_fbo_for_background_;
+
+    /*!
+        Implemented in nux::View and nux::Layout.
+        Report to a parent view with redirect_rendering_to_texture_ set to true that one of its children
+        needs to be redrawn.
+    */
+    virtual void PrepareParentRedirectedView();
+
+    virtual bool HasParentRedirectedView();
+    Area* RedirectedAncestor();
+
+    /*!
+        Inform this view that one of its children has requested a draw. This view must have its rendering redirected to a texture.
+        @param update True if this view is redirected and one of its children has requested a draw.
+    */
+    virtual void SetUpdateBackupTextureForChildRendering(bool update);
+    virtual bool UpdateBackupTextureForChildRendering() const;
+
+    /********************************************/
+    /*** End support for redirected rendering ***/
+    /********************************************/
 
 #ifdef NUX_GESTURES_SUPPORT
     //! Returns the InputArea hit by the given gesture

=== modified file 'Nux/BaseWindow.h'
--- Nux/BaseWindow.h	2012-05-31 21:50:05 +0000
+++ Nux/BaseWindow.h	2012-09-18 19:02:35 +0000
@@ -26,7 +26,6 @@
 
 #include <boost/scoped_ptr.hpp>
 #include "ScrollView.h"
-#include "Features.h"
 
 #if defined(NUX_OS_WINDOWS)
 #include "NuxGraphics/Events.h"

=== added file 'Nux/BasicView.cpp'
--- Nux/BasicView.cpp	1970-01-01 00:00:00 +0000
+++ Nux/BasicView.cpp	2012-09-18 19:02:35 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2012 Inalogic Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *
+ */
+
+#include "Nux/Nux.h"
+#include "BasicView.h"
+
+
+namespace nux {
+NUX_IMPLEMENT_OBJECT_TYPE(BasicView);
+
+BasicView::BasicView(NUX_FILE_LINE_DECL)
+: nux::View(NUX_FILE_LINE_PARAM)
+{
+
+}
+
+BasicView::~BasicView()
+{
+
+}
+
+void BasicView::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+{
+  // Draw nothing
+  // For debug only:
+  // graphics_engine.QRP_Color(GetBaseX(), GetBaseY(), GetBaseWidth(), GetBaseHeight(), nux::color::Pink);
+}
+
+}

=== added file 'Nux/BasicView.h'
--- Nux/BasicView.h	1970-01-01 00:00:00 +0000
+++ Nux/BasicView.h	2012-09-18 19:02:35 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012 Inalogic Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *
+ */
+
+#ifndef BASIC_VIEW_H
+#define BASIC_VIEW_H
+
+
+namespace nux {
+
+//! A very basic View object with no rendering.
+class BasicView: public nux::View
+{
+  NUX_DECLARE_OBJECT_TYPE(BasicView, View);
+public:
+  BasicView(NUX_FILE_LINE_PROTO);
+  ~BasicView();
+
+  
+protected:
+  void Draw(nux::GraphicsEngine& graphics_engine, bool force_draw);
+};
+
+}
+#endif // BASIC_VIEW_H
+

=== modified file 'Nux/Button.cpp'
--- Nux/Button.cpp	2011-10-22 06:17:42 +0000
+++ Nux/Button.cpp	2012-09-18 19:02:35 +0000
@@ -344,20 +344,36 @@
     Geometry base = GetGeometry();
 
     graphics_engine.PushClippingRectangle(base);
-    GetPainter().PaintBackground(graphics_engine, base);
+
+    UXStyleImageRef ref_style = eIMAGE_STYLE_NONE;
 
     if (visual_state_ == VISUAL_STATE_PRESSED)
     {
-      GetPainter().PaintTextureShape(graphics_engine, base, eBUTTON_FOCUS);
+      ref_style = eBUTTON_FOCUS;
     }
     else if (visual_state_ == VISUAL_STATE_PRELIGHT)
     {
-      GetPainter().PaintTextureShape(graphics_engine, base, eBUTTON_PRELIGHT);
+      ref_style = eBUTTON_PRELIGHT;
     }
     else
     {
-      GetPainter().PaintTextureShape(graphics_engine, base, eBUTTON_NORMAL);
-    }
+      ref_style = eBUTTON_NORMAL;
+    }
+
+    const PainterImage *pimage = GetTheme().GetImage(ref_style);
+    BaseTexture* texture = NULL;
+    if (pimage != NULL)
+    {
+      texture = pimage->texture;
+    }
+
+    TexCoordXForm texxform;
+    ROPConfig rop;
+    rop.Blend = true;
+    rop.SrcBlend = GL_ONE;
+    rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+    GetPainter().PushDrawSliceScaledTextureLayer(graphics_engine, base, ref_style, color::White, eAllCorners, true, rop);
 
     if (GetCompositionLayout())
     {
@@ -368,13 +384,14 @@
         clip_geo.OffsetSize(-left_clip_ - right_clip_, -top_clip_ - bottom_clip_);
 
         graphics_engine.PushClippingRectangle(clip_geo);
-        GetPainter().PushPaintLayerStack();
-        GetCompositionLayout()->ProcessDraw(graphics_engine, force_draw);
-        GetPainter().PopPaintLayerStack();
+
+        GetCompositionLayout()->ProcessDraw(graphics_engine, true);
+
         graphics_engine.PopClippingRectangle();
       }
       GetPainter().PopPaintLayerStack();
     }
+    GetPainter().PopPaintLayer();
     graphics_engine.PopClippingRectangle();
   }
 

=== modified file 'Nux/CheckBox.cpp'
--- Nux/CheckBox.cpp	2011-10-18 20:00:59 +0000
+++ Nux/CheckBox.cpp	2012-09-18 19:02:35 +0000
@@ -43,8 +43,6 @@
     Geometry base = GetGeometry();
     graphics_engine.PushClippingRectangle(base);
 
-    GetPainter().PaintBackground(graphics_engine, base);
-
     InteractState is;
     is.is_on = active_;
 

=== modified file 'Nux/ClientArea.cpp'
--- Nux/ClientArea.cpp	2012-02-04 23:19:44 +0000
+++ Nux/ClientArea.cpp	2012-09-18 19:02:35 +0000
@@ -46,36 +46,38 @@
     mouse_drag.connect(sigc::mem_fun(this, &ClientArea::RecvMouseDrag));
     mouse_move.connect(sigc::mem_fun(this, &ClientArea::RecvMouseMove));
     key_down.connect(sigc::mem_fun(this, &ClientArea::RecvKeyEvent));
-
-    if (GetWindowThread()->GetGraphicsDisplay().HasFrameBufferSupport())
-    {
-      m_FrameBufferObject = GetGraphicsDisplay()->GetGpuDevice()->CreateFrameBufferObject();
-      m_MainColorRT = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(2, 2, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
-      m_MainDepthRT = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(2, 2, 1, BITFMT_D24S8, NUX_TRACKER_LOCATION);
-    }
   }
 
   ClientArea::~ClientArea()
   {
   }
 
-  void ClientArea::BeginDraw(GraphicsEngine &graphics_engine, bool force_draw)
+  void ClientArea::BeginDraw(GraphicsEngine& graphics_engine, bool force_draw)
   {
-    if ((IsRedrawNeeded() == false) && (force_draw == false))
-      return;
+    // if ((IsRedrawNeeded() == false) && (force_draw == false))
+    //   return;
+
+    // Save blend states
+    unsigned int current_alpha_blend;
+    unsigned int current_src_blend_factor;
+    unsigned int current_dest_blend_factor;
+    graphics_engine.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+
+    ObjectPtr<IOpenGLFrameBufferObject> prev_fbo_ = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
+    Geometry prev_viewport_ = graphics_engine.GetViewportRect();
 
     if (GetWindowThread()->GetGraphicsDisplay().HasFrameBufferSupport())
     {
-      int buffer_width = GetBaseWidth();
-      int buffer_height = GetBaseHeight();
+      int width = GetWidth();
+      int height = GetHeight();
       int window_width, window_height;
-      window_width = graphics_engine.GetViewportWidth();
-      window_height = graphics_engine.GetViewportHeight();
+      window_width = prev_viewport_.width;
+      window_height = prev_viewport_.height;
 
-      m_ctx.x = GetBaseX();
-      m_ctx.y = GetBaseY();
-      m_ctx.width  = GetBaseWidth();
-      m_ctx.height = GetBaseHeight();
+      m_ctx.x = GetX();
+      m_ctx.y = GetY();
+      m_ctx.width  = width;
+      m_ctx.height = height;
 
       // A is obtained from graphics_engine. So A dimension's are in relative window coordinates.
       Rect A = graphics_engine.GetClippingRegion();
@@ -87,102 +89,62 @@
       m_ctx.width_clipregion  = C.GetWidth();
       m_ctx.height_clipregion = C.GetHeight();
 
-      ObjectPtr<IOpenGLFrameBufferObject> prevFBO = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
-
-      if ((m_FrameBufferObject->GetWidth() != buffer_width) || (m_FrameBufferObject->GetHeight() != buffer_height))
-      {
-        m_FrameBufferObject->FormatFrameBufferObject(buffer_width, buffer_height, BITFMT_R8G8B8A8);
-        m_MainColorRT = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(buffer_width, buffer_height, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
-        m_MainDepthRT = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(buffer_width, buffer_height, 1, BITFMT_D24S8, NUX_TRACKER_LOCATION);
-      }
-
-      m_FrameBufferObject->SetRenderTarget(0, m_MainColorRT->GetSurfaceLevel(0));
-      m_FrameBufferObject->SetDepthSurface(m_MainDepthRT->GetSurfaceLevel(0));
+      //ObjectPtr<IOpenGLFrameBufferObject> prevFBO = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
+
+      if (m_FrameBufferObject.IsNull())
+      {
+        // Create the fbo before using it for the first time.
+        m_FrameBufferObject = GetGraphicsDisplay()->GetGpuDevice()->CreateFrameBufferObject();
+      }
+
+      if (!m_MainColorRT.IsValid() || (m_MainColorRT->GetWidth() != width) || (m_MainColorRT->GetHeight() != height))
+      {
+        // Create or resize the color and depth textures before using them.
+        m_MainColorRT = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(width, height, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
+        m_MainDepthRT = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(width, height, 1, BITFMT_D24S8, NUX_TRACKER_LOCATION);
+      }
+
+      m_FrameBufferObject->FormatFrameBufferObject(width, height, BITFMT_R8G8B8A8);
+      m_FrameBufferObject->EmptyClippingRegion();
+      m_FrameBufferObject->SetTextureAttachment(0, m_MainColorRT, 0);
+      m_FrameBufferObject->SetDepthTextureAttachment(m_MainDepthRT, 0);
       m_FrameBufferObject->Activate();
 
-      graphics_engine.SetViewport(0, 0, buffer_width, buffer_height);
-      m_FrameBufferObject->EmptyClippingRegion();
-
-      ClientDraw(graphics_engine, m_ctx, force_draw);
-
-      // Restore the main frame buffer object
-      prevFBO->Activate();
-
-      Area* view_window = GetTopLevelViewWindow();
-      if (view_window)
-      {
-        graphics_engine.SetViewport(0, 0, view_window->GetBaseWidth(), view_window->GetBaseHeight());
-        graphics_engine.ApplyClippingRectangle();
-        graphics_engine.ApplyModelViewMatrix();
-        graphics_engine.SetOrthographicProjectionMatrix(view_window->GetBaseWidth(), view_window->GetBaseHeight());
-
-      }
-      else
-      {
-        graphics_engine.SetViewport(0, 0, window_width, window_height);
-        graphics_engine.ApplyClippingRectangle();
-        graphics_engine.ApplyModelViewMatrix();
-        graphics_engine.SetOrthographicProjectionMatrix(window_width, window_height);
-      }
-            
-      // Copy the client frame buffer into the main frame buffer.
-      {
-        unsigned int w, h;
-        w = m_MainColorRT->GetWidth();
-        h = m_MainColorRT->GetHeight();
-        int x = m_ctx.x;
-        int y = m_ctx.y;
-
-        TexCoordXForm texxform0;
-        texxform0.uwrap = TEXWRAP_CLAMP;
-        texxform0.vwrap = TEXWRAP_CLAMP;
-        texxform0.FlipVCoord(true);
-        GetGraphicsDisplay()->GetGraphicsEngine()->QRP_1Tex(x, y, w, h, m_MainColorRT, texxform0, Color(color::White));
-      }
-    }
-    else
-    {
-      int x = graphics_engine.GetContextX();
-      int y = graphics_engine.GetContextY();
-
-      // The clientarea is in absolute window coordinates. It needs to be offset so that it is in relative window coordinates.
-      m_ctx.x = GetBaseX() + x;
-      m_ctx.y = GetBaseY() + y;
-      m_ctx.width  = GetBaseWidth();
-      m_ctx.height = GetBaseHeight();
-
-      // A is obtained from graphics_engine. So A dimension's are in relative window coordinates.
-      Rect A = graphics_engine.GetClippingRegion();
-
-      Rect B = Rect(m_ctx.x, m_ctx.y, m_ctx.width, m_ctx.height);
-      Rect C = A.Intersect(B);
-
-      m_ctx.x_clipregion = C.x;
-      m_ctx.y_clipregion = C.y;
-      m_ctx.width_clipregion  = C.GetWidth();
-      m_ctx.height_clipregion = C.GetHeight();
-
-      int window_width, window_height;
-      window_width = graphics_engine.GetViewportWidth();
-      window_height = graphics_engine.GetViewportHeight();
-
-      SetClientViewport(graphics_engine);
-//         graphics_engine.SetViewport(
-//             m_ctx.x, window_height - m_ctx.y - m_ctx.height, m_ctx.width, m_ctx.height);
-//
-//         graphics_engine.SetOpenGLClippingRectangle(
-//             m_ctx.x_clipregion,
-//             window_height - m_ctx.y_clipregion - m_ctx.height_clipregion,
-//             m_ctx.width_clipregion,
-//             m_ctx.height_clipregion);
-
-      ClientDraw(graphics_engine, m_ctx, force_draw);
-
-      // go back to 2D in case that was changed by the client.
-      graphics_engine.SetViewport(0, 0, window_width, window_height);
-      graphics_engine.ApplyClippingRectangle();
-      graphics_engine.Push2DWindow(window_width, window_height);
-    }
+      graphics_engine.SetViewport(0, 0, width, height);
+
+
+      ClientDraw(graphics_engine, m_ctx, force_draw);
+    }
+
+    if (prev_fbo_.IsValid())
+    {
+      // Restore the previous fbo
+      prev_fbo_->Activate();
+
+      prev_fbo_->ApplyClippingRegion();
+    }
+
+    // Restore the matrices and the view port.
+    graphics_engine.ApplyModelViewMatrix();
+    graphics_engine.SetOrthographicProjectionMatrix(prev_viewport_.width, prev_viewport_.height);
+    graphics_engine.SetViewport(prev_viewport_.x, prev_viewport_.y, prev_viewport_.width, prev_viewport_.height);    
+
+    {
+      unsigned int w, h;
+      w = m_MainColorRT->GetWidth();
+      h = m_MainColorRT->GetHeight();
+      int x = m_ctx.x;
+      int y = m_ctx.y;
+
+      TexCoordXForm texxform0;
+      texxform0.uwrap = TEXWRAP_CLAMP;
+      texxform0.vwrap = TEXWRAP_CLAMP;
+      texxform0.FlipVCoord(true);
+      GetGraphicsDisplay()->GetGraphicsEngine()->QRP_1Tex(x, y, w, h, m_MainColorRT, texxform0, Color(color::White));
+    }
+
+    // restore blend states
+    graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
   }
 
   void ClientArea::Draw(GraphicsEngine &graphics_engine, bool force_draw)
@@ -270,19 +232,6 @@
 
   }
 
-  void ClientArea::QueueDraw()
-  {
-    //GetWindowCompositor()..AddToDrawList(this);
-    WindowThread* application = GetWindowThread();
-    if (application)
-    {
-      application->AddToDrawList(this);
-      application->RequestRedraw();
-      //GetWindowCompositor().AddToDrawList(this);
-    }
-    draw_cmd_queued_ = true;
-  }
-
   bool ClientArea::AcceptKeyNavFocus()
   {
     return false;

=== modified file 'Nux/ClientArea.h'
--- Nux/ClientArea.h	2011-11-10 17:28:44 +0000
+++ Nux/ClientArea.h	2012-09-18 19:02:35 +0000
@@ -49,7 +49,6 @@
     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);
-    virtual void QueueDraw();
 
     void EnableClientDraw(bool b)
     {

=== modified file 'Nux/ColorEditor.cpp'
--- Nux/ColorEditor.cpp	2012-02-06 01:06:09 +0000
+++ Nux/ColorEditor.cpp	2012-09-18 19:02:35 +0000
@@ -207,9 +207,9 @@
     m_Validator.SetMaximum(1.0);
     m_Validator.SetDecimals(2);
 
-    picker_area_        = new InputArea(NUX_TRACKER_LOCATION);
-    channel_area_   = new InputArea(NUX_TRACKER_LOCATION);
-    selected_color_area_       = new InputArea(NUX_TRACKER_LOCATION);
+    picker_area_        = new BasicView(NUX_TRACKER_LOCATION);
+    channel_area_   = new BasicView(NUX_TRACKER_LOCATION);
+    selected_color_area_       = new BasicView(NUX_TRACKER_LOCATION);
     m_hlayout           = new HLayout(NUX_TRACKER_LOCATION);
 
     channel_area_->mouse_down.connect(sigc::mem_fun(this, &ColorEditor::RecvMouseDown));
@@ -316,18 +316,6 @@
     ctrllayout->SetHorizontalExternalMargin(2);
     ctrllayout->SetVerticalInternalMargin(2);
 
-//     //ctrllayout->AddView(new SpaceLayout(20,20,20,40), 1);
-//     OkButton = new ToggleButton("OK", NUX_TRACKER_LOCATION);
-//     OkButton->SetMinimumWidth(60);
-//     OkButton->SetMinimumHeight(20);
-//
-//     CancelButton = new ToggleButton("Cancel", NUX_TRACKER_LOCATION);
-//     CancelButton->SetMinimumWidth(60);
-//     CancelButton->SetMinimumHeight(20);
-//
-// //    ctrllayout->AddView(OkButton, 1);
-// //    ctrllayout->AddView(CancelButton, 1);
-
     m_hlayout->AddLayout(ctrllayout, 0);
 
     radiogroup = new RadioButtonGroup(NUX_TRACKER_LOCATION);
@@ -379,13 +367,11 @@
   {
     Geometry base = GetGeometry();
 
-    GetPainter().PaintBackground(graphics_engine, base);
-    //GetPainter().Paint2DQuadWireframe(graphics_engine, base, Color(COLOR_BACKGROUND_SECONDARY));
-
     base.OffsetPosition(1, 1);
     base.OffsetSize(-2, -2);
 
     graphics_engine.PushClippingRectangle(base);
+    GetPainter().PushDrawShapeLayer(graphics_engine, base, eSHAPE_CORNER_ROUND4, Color(0xFF000000), eAllCorners, true);
 
     if (m_ColorModel == color::RGB)
     {
@@ -396,26 +382,33 @@
       DrawHSV(graphics_engine, force_draw);
     }
 
-    redcheck->QueueDraw();
-    redtext->QueueDraw();
-    greencheck->QueueDraw();
-    greentext->QueueDraw();
-    bluecheck->QueueDraw();
-    bluetext->QueueDraw();
-
-    huecheck->QueueDraw();
-    hue_text_entry_->QueueDraw();
-    saturationcheck->QueueDraw();
-    saturation_text_entry_->QueueDraw();
-    valuecheck->QueueDraw();
-    value_text_entry_->QueueDraw();
-
-//     OkButton->QueueDraw();
-//     CancelButton->QueueDraw();
-
+    GetPainter().PopBackground();
     graphics_engine.PopClippingRectangle();
   }
 
+  void ColorEditor::DrawContent(GraphicsEngine &graphics_engine, bool force_draw)
+  {
+    Geometry base = GetGeometry();
+    GetPainter().PushShapeLayer(graphics_engine, base, eSHAPE_CORNER_ROUND4, Color(0xFF000000), eAllCorners, true);
+
+    bool force = force_draw || IsFullRedraw();
+    redcheck->ProcessDraw(graphics_engine, force);
+    redtext->ProcessDraw(graphics_engine, force);
+    greencheck->ProcessDraw(graphics_engine, force);
+    greentext->ProcessDraw(graphics_engine, force);
+    bluecheck->ProcessDraw(graphics_engine, force);
+    bluetext->ProcessDraw(graphics_engine, force);
+
+    huecheck->ProcessDraw(graphics_engine, force);
+    hue_text_entry_->ProcessDraw(graphics_engine, force);
+    saturationcheck->ProcessDraw(graphics_engine, force);
+    saturation_text_entry_->ProcessDraw(graphics_engine, force);
+    valuecheck->ProcessDraw(graphics_engine, force);
+    value_text_entry_->ProcessDraw(graphics_engine, force);
+
+    GetPainter().PopBackground();
+  }
+
 // Draw Marker on Base Chanel Area
   void ColorEditor::DrawBaseChannelMarker(GraphicsEngine &graphics_engine)
   {
@@ -621,23 +614,6 @@
     }
   }
 
-  void ColorEditor::DrawContent(GraphicsEngine &graphics_engine, bool force_draw)
-  {
-    redcheck->ProcessDraw(graphics_engine, force_draw);
-    redtext->ProcessDraw(graphics_engine, force_draw);
-    greencheck->ProcessDraw(graphics_engine, force_draw);
-    greentext->ProcessDraw(graphics_engine, force_draw);
-    bluecheck->ProcessDraw(graphics_engine, force_draw);
-    bluetext->ProcessDraw(graphics_engine, force_draw);
-
-    huecheck->ProcessDraw(graphics_engine, force_draw);
-    hue_text_entry_->ProcessDraw(graphics_engine, force_draw);
-    saturationcheck->ProcessDraw(graphics_engine, force_draw);
-    saturation_text_entry_->ProcessDraw(graphics_engine, force_draw);
-    valuecheck->ProcessDraw(graphics_engine, force_draw);
-    value_text_entry_->ProcessDraw(graphics_engine, force_draw);
-  }
-
   void ColorEditor::RecvMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
     float BaseValue;
@@ -958,7 +934,7 @@
   {
     rgb_ = color::RedGreenBlue(Clamp<double>(r, 0.0, 1.0),
                                Clamp<double>(g, 0.0, 1.0),
-                               Clamp<double> (b, 0.0, 1.0));
+                               Clamp<double>(b, 0.0, 1.0));
     hsv_ = color::HueSaturationValue(rgb_);
     RecvCheckColorModel(true, m_ColorModel, color_channel_);
     sigChange.emit(this);

=== modified file 'Nux/ColorPreview.cpp'
--- Nux/ColorPreview.cpp	2012-07-04 16:36:46 +0000
+++ Nux/ColorPreview.cpp	2012-09-18 19:02:35 +0000
@@ -38,7 +38,7 @@
   {
     //setSize(200, 100);
     m_hlayout           = new HLayout(NUX_TRACKER_LOCATION);
-    m_ColorArea         = new InputArea(NUX_TRACKER_LOCATION);
+    m_ColorArea         = new BasicView(NUX_TRACKER_LOCATION);
     m_ColorValue        = new StaticTextBox("", NUX_TRACKER_LOCATION);
     m_DialogThreadProxy = new ColorDialogProxy(true);
 

=== modified file 'Nux/ComboBoxSimple.cpp'
--- Nux/ComboBoxSimple.cpp	2011-12-14 02:01:43 +0000
+++ Nux/ComboBoxSimple.cpp	2012-09-18 19:02:35 +0000
@@ -55,7 +55,7 @@
     _combo_box_area->SetMinimumSize(2 * DEFAULT_WIDGET_WIDTH, PRACTICAL_WIDGET_HEIGHT);
     _combo_box_area->SetGeometry(Geometry(0, 0, 3 * DEFAULT_WIDGET_WIDTH, PRACTICAL_WIDGET_HEIGHT));
     //_pango_static_text->SetClipping(_combo_box_area->GetBaseWidth());
-    _combo_box_area->OnGeometryChanged.connect(sigc::mem_fun(this, &ComboBoxSimple::RecvGeometryChanged));
+    _combo_box_area->geometry_changed.connect(sigc::mem_fun(this, &ComboBoxSimple::RecvGeometryChanged));
 
     //m_CurrentMenu = new MenuPage;
     m_CurrentMenu->SetParentMenu(0);

=== modified file 'Nux/Coverflow.cpp'
--- Nux/Coverflow.cpp	2012-08-20 18:43:15 +0000
+++ Nux/Coverflow.cpp	2012-09-18 19:02:35 +0000
@@ -224,7 +224,7 @@
     parent_->mouse_up.connect(sigc::mem_fun(this, &Impl::HandleMouseUp));
     parent_->mouse_down.connect(sigc::mem_fun(this, &Impl::HandleMouseDown));
     parent_->mouse_wheel.connect(sigc::mem_fun(this, &Impl::HandleMouseWheel));
-    parent_->OnGeometryChanged.connect(sigc::mem_fun(this, &Impl::HandleGeometryChange));
+    parent_->geometry_changed.connect(sigc::mem_fun(this, &Impl::HandleGeometryChange));
 
 
     camera_position_.x = 0.0f;
@@ -286,7 +286,8 @@
 
     text_loader_.font_size = 10;
 
-    BaseTexture* texture = LoadTextureFromFile(PKGDATADIR"/UITextures/coverflow.oval-shadow.png");
+    NString resource_path = NUX_FIND_RESOURCE_LOCATION_NOFAIL("UITextures/coverflow.oval-shadow.png");
+    BaseTexture* texture = LoadTextureFromFile(resource_path.GetTCharPtr());
     drop_shadow_texture_ = texture->GetDeviceTexture();
     texture->UnReference();
 
@@ -1087,7 +1088,6 @@
     graphics_engine.GetRenderStates().SetPremultipliedBlend(SRC_OVER);
     graphics_engine.GetRenderStates().SetColorMask(true, true, true, true);
 
-    nux::GetPainter().PaintBackground(graphics_engine, GetGeometry());
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT  | GL_STENCIL_BUFFER_BIT);
 
     glViewport(0, 0, ctx.width, ctx.height);

=== modified file 'Nux/Coverflow.h'
--- Nux/Coverflow.h	2012-02-13 05:26:32 +0000
+++ Nux/Coverflow.h	2012-09-18 19:02:35 +0000
@@ -20,9 +20,9 @@
 #ifndef COVERFLOWVIEW_H
 #define COVERFLOWVIEW_H
 
-#include "Nux/ClientArea.h"
 #include "NuxCore/Math/Vector4.h"
 #include "CoverflowModel.h"
+#include "ClientArea.h"
 
 #if defined(NUX_OS_WINDOWS)
   #define PKGDATADIR "../../data/"

=== modified file 'Nux/CoverflowItem.h'
--- Nux/CoverflowItem.h	2012-08-20 18:43:15 +0000
+++ Nux/CoverflowItem.h	2012-09-18 19:02:35 +0000
@@ -23,7 +23,7 @@
 #include <memory>
 #include <string>
 
-#include <Nux/Nux.h>
+#include "Nux.h"
 #include <sigc++/sigc++.h>
 
 namespace nux

=== modified file 'Nux/EditTextBox.cpp'
--- Nux/EditTextBox.cpp	2012-07-04 16:36:46 +0000
+++ Nux/EditTextBox.cpp	2012-09-18 19:02:35 +0000
@@ -94,7 +94,7 @@
   void EditTextBox::ScrollTimerInterrupt(void *v)
   {
     Geometry base = GetGeometry();
-    Event &event = GetGraphicsDisplay()->GetCurrentEvent();
+    const Event& event = GetGraphicsDisplay()->GetCurrentEvent();
 
     int X = event.x;
     m_KeyboardHandler.CaretAutoScroll(event.x, event.y, base);

=== modified file 'Nux/FloatingWindow.cpp'
--- Nux/FloatingWindow.cpp	2011-12-07 07:04:38 +0000
+++ Nux/FloatingWindow.cpp	2012-09-18 19:02:35 +0000
@@ -52,27 +52,27 @@
     _resize_handle_height       = 20;
     _title_bar_height           = 20;
 
-    _minimize_button    = new InputArea(NUX_TRACKER_LOCATION);
+    _minimize_button    = new BasicView(NUX_TRACKER_LOCATION);
     _minimize_button->SetParentObject(this);
 
-    _resize_handle      = new InputArea(NUX_TRACKER_LOCATION);
+    _resize_handle      = new BasicView(NUX_TRACKER_LOCATION);
     _resize_handle->SinkReference();
     _resize_handle->SetParentObject(this);
 
-    _title_bar          = new InputArea(NUX_TRACKER_LOCATION);
+    _title_bar          = new BasicView(NUX_TRACKER_LOCATION);
     _title_bar->SinkReference();
     _title_bar->SetParentObject(this);
 
-    _close_button       = new InputArea(NUX_TRACKER_LOCATION);
+    _close_button       = new BasicView(NUX_TRACKER_LOCATION);
     _window_title_bar   = new StaticTextBox("", NUX_TRACKER_LOCATION);
 
     _title_bar_layout   = new HLayout(NUX_TRACKER_LOCATION);
     _title_bar_layout->Reference();
     
     _minimize_button->SetMinMaxSize(20, 20);
-    _minimize_button->SetGeometry(0, 0, 20, 20);
+    _minimize_button->SetGeometry(Geometry(0, 0, 20, 20));
     _close_button->SetMinimumSize(20, 20);
-    _close_button->SetGeometry(0, 0, 20, 20);
+    _close_button->SetGeometry(Geometry(0, 0, 20, 20));
     _resize_handle->SetMinimumSize(_resize_handle_width, _resize_handle_height);
     _resize_handle->SetGeometry(Geometry(0, 0, _resize_handle_width, _resize_handle_height));
 
@@ -322,7 +322,7 @@
     // No need to compute the window layout elements [LayoutWindowElements()]. They haven't changed.
     // No need to compute the layout [ComputeContentSize()]. It hasn't changed.
 
-    _title_bar->SetGeometry(0, 0, geo.GetWidth(), _title_bar_height);
+    _title_bar->SetGeometry(Geometry(0, 0, geo.GetWidth(), _title_bar_height));
 
 #if defined(NUX_OS_LINUX)
     if (m_input_window != 0)
@@ -371,7 +371,7 @@
     // Drag Bar Geometry
     if (HasTitleBar())
     {
-      _title_bar->SetGeometry(0, 0, geo.GetWidth(), _title_bar_height);
+      _title_bar->SetGeometry(Geometry(0, 0, geo.GetWidth(), _title_bar_height));
     }
 
     // Size grip Geometry
@@ -408,7 +408,7 @@
     // Drag Bar Geometry
     if (HasTitleBar())
     {
-      _title_bar->SetGeometry(0, 0, geo.GetWidth(), _title_bar_height);
+      _title_bar->SetGeometry(Geometry(0, 0, geo.GetWidth(), _title_bar_height));
     }
 
     // Size grip Geometry
@@ -436,7 +436,7 @@
     // Drag Bar Geometry
     if (HasTitleBar())
     {
-      _title_bar->SetGeometry(0, 0, geo.GetWidth(), _title_bar_height);
+      _title_bar->SetGeometry(Geometry(0, 0, geo.GetWidth(), _title_bar_height));
     }
 
     // Size grip Geometry
@@ -455,7 +455,7 @@
     // Define the geometry of some of the component of the window. Otherwise, if the composition layout is not set,
     // then the component won't be correctly placed after a SetGeometry. This can be redundant if the composition layout is set.
     Geometry base = GetGeometry();
-    _title_bar->SetGeometry(0, 0, base.GetWidth(), _title_bar_height);
+    _title_bar->SetGeometry(Geometry(0, 0, base.GetWidth(), _title_bar_height));
 
     _title_bar_layout->SetGeometry(_title_bar->GetGeometry());
     GetWindowThread()->ComputeElementLayout(_title_bar_layout);

=== modified file 'Nux/FloatingWindow.h'
--- Nux/FloatingWindow.h	2011-12-14 02:01:43 +0000
+++ Nux/FloatingWindow.h	2012-09-18 19:02:35 +0000
@@ -27,7 +27,7 @@
 
 #include "ScrollView.h"
 #include "BaseWindow.h"
-#include "InputArea.h"
+#include "BasicView.h"
 #include "Layout.h"
 #include "HLayout.h"
 #include "VLayout.h"
@@ -112,12 +112,12 @@
     int _resize_handle_height;
     int _title_bar_height;
 
-    InputArea *_resize_handle;
-    InputArea *_title_bar;
+    BasicView *_resize_handle;
+    BasicView *_title_bar;
     Point _title_bar_mouse_down_location;
 
-    InputArea *_minimize_button;
-    InputArea *_close_button;
+    BasicView *_minimize_button;
+    BasicView *_close_button;
     StaticTextBox *_window_title_bar;
     bool m_hasTitleBar;
 

=== modified file 'Nux/GridHLayout.cpp'
--- Nux/GridHLayout.cpp	2012-07-25 20:10:56 +0000
+++ Nux/GridHLayout.cpp	2012-09-18 19:02:35 +0000
@@ -579,7 +579,7 @@
     graphics_engine.PopClippingRectangle();
     graphics_engine.PopModelViewMatrix();
 
-    _queued_draw = false;
+    draw_cmd_queued_ = false;
   }
 
   Area* GridHLayout::KeyNavIterationRowOrder(KeyNavDirection direction)

=== modified file 'Nux/GridVLayout.cpp'
--- Nux/GridVLayout.cpp	2011-10-21 22:06:35 +0000
+++ Nux/GridVLayout.cpp	2012-09-18 19:02:35 +0000
@@ -348,7 +348,7 @@
     graphics_engine.PopClippingRectangle();
     graphics_engine.PopModelViewMatrix();
 
-    _queued_draw = false;
+    draw_cmd_queued_ = false;
   }
 
   Area* GridVLayout::KeyNavIteration(KeyNavDirection direction)

=== modified file 'Nux/GroupBox.h'
--- Nux/GroupBox.h	2011-10-17 21:23:50 +0000
+++ Nux/GroupBox.h	2012-09-18 19:02:35 +0000
@@ -55,7 +55,7 @@
     virtual void ComputeContentPosition(float offsetX, float offsetY);
 
     bool bCaptionAvailable;
-    InputArea m_CaptionArea;
+    BasicView m_CaptionArea;
     Layout *m_layout;
   };
 }

=== modified file 'Nux/GroupBox2.cpp'
--- Nux/GroupBox2.cpp	2011-10-17 21:23:50 +0000
+++ Nux/GroupBox2.cpp	2012-09-18 19:02:35 +0000
@@ -39,7 +39,7 @@
     ,   bCaptionAvailable(false)
     ,   m_layout(0)
   {
-    m_CaptionArea = new InputArea(NUX_TRACKER_LOCATION);
+    m_CaptionArea = new BasicView(NUX_TRACKER_LOCATION);
     SetMinimumSize(DEFAULT_WIDGET_WIDTH + 5, PRACTICAL_WIDGET_HEIGHT + 5);
     SetBaseSize(DEFAULT_WIDGET_WIDTH + 5, PRACTICAL_WIDGET_HEIGHT + 5);
     SetCaption(Caption);

=== modified file 'Nux/GroupBox2.h'
--- Nux/GroupBox2.h	2011-10-17 21:23:50 +0000
+++ Nux/GroupBox2.h	2012-09-18 19:02:35 +0000
@@ -54,7 +54,7 @@
     virtual void ComputeContentPosition(float offsetX, float offsetY);
 
     bool        bCaptionAvailable;
-    InputArea   *m_CaptionArea;
+    BasicView   *m_CaptionArea;
     Layout     *m_layout;
 
     static int CAPTION_X_MARGIN;

=== modified file 'Nux/HScrollBar.cpp'
--- Nux/HScrollBar.cpp	2012-07-04 16:36:46 +0000
+++ Nux/HScrollBar.cpp	2012-09-18 19:02:35 +0000
@@ -52,10 +52,10 @@
     m_RightTimerHandler = 0;
 
     hlayout = new HLayout(NUX_TRACKER_LOCATION);
-    _scroll_left_button = new InputArea(NUX_TRACKER_LOCATION);
-    _track = new InputArea(NUX_TRACKER_LOCATION);
-    _scroll_right_button = new InputArea(NUX_TRACKER_LOCATION);
-    _slider = new InputArea(NUX_TRACKER_LOCATION);
+    _scroll_left_button = new BasicView(NUX_TRACKER_LOCATION);
+    _track = new BasicView(NUX_TRACKER_LOCATION);
+    _scroll_right_button = new BasicView(NUX_TRACKER_LOCATION);
+    _slider = new BasicView(NUX_TRACKER_LOCATION);
     _slider->SetParentObject(this);
 
     // Set Original State

=== modified file 'Nux/HScrollBar.h'
--- Nux/HScrollBar.h	2011-10-10 01:52:00 +0000
+++ Nux/HScrollBar.h	2012-09-18 19:02:35 +0000
@@ -99,10 +99,10 @@
     bool AtMaximum();
 
     HLayout *hlayout;
-    InputArea *_slider;
-    InputArea *_scroll_left_button;
-    InputArea *_scroll_right_button;
-    InputArea *_track;
+    BasicView *_slider;
+    BasicView *_scroll_left_button;
+    BasicView *_scroll_right_button;
+    BasicView *_track;
 
     int content_width_;
     int content_height_;

=== modified file 'Nux/HSplitter.cpp'
--- Nux/HSplitter.cpp	2011-12-06 16:29:06 +0000
+++ Nux/HSplitter.cpp	2012-09-18 19:02:35 +0000
@@ -143,11 +143,6 @@
           View *ic = static_cast<View *>(*it);
           ic->ProcessDraw(graphics_engine, true);
         }
-        else if ((*it)->Type().IsObjectType(InputArea::StaticObjectType))
-        {
-          InputArea *base_area = static_cast<InputArea *>(*it);
-          base_area->OnDraw(graphics_engine, true);
-        }
         else if ((*it)->Type().IsObjectType(HLayout::StaticObjectType))
         {
           HLayout *layout = static_cast<HLayout *>(*it);
@@ -166,11 +161,6 @@
           View *ic = static_cast<View *>(*it);
           ic->ProcessDraw(graphics_engine, false);
         }
-        else if ((*it)->Type().IsObjectType(InputArea::StaticObjectType))
-        {
-          InputArea *base_area = static_cast<InputArea *>(*it);
-          base_area->OnDraw(graphics_engine, false);
-        }
         else if ((*it)->Type().IsObjectType(HLayout::StaticObjectType))
         {
           HLayout *layout = static_cast<HLayout *>(*it);
@@ -359,11 +349,6 @@
         // ComputeElementLayout to force the computing of this element layout.
         GetWindowThread()->ComputeElementLayout(ic);
       }
-      else if (m_InterfaceObject[i]->Type().IsObjectType(InputArea::StaticObjectType))
-      {
-        InputArea *base_area = static_cast<InputArea *>(m_InterfaceObject[i]);
-        base_area->SetGeometry(Geometry(x, accheight, w, splitter_geo.y - accheight));
-      }
       else if (m_InterfaceObject[i]->Type().IsDerivedFromType(Layout::StaticObjectType))
       {
         Layout *layout = static_cast<Layout *>(m_InterfaceObject[i]);
@@ -566,11 +551,6 @@
         View *ic = static_cast<View *>(*it);
         ic->DoneRedraw();
       }
-
-      else if ((*it)->Type().IsObjectType(InputArea::StaticObjectType))
-      {
-        //InputArea* base_area = NUX_STATIC_CAST(InputArea*, (*it));
-      }
     }
   }
 

=== modified file 'Nux/HSplitter.h'
--- Nux/HSplitter.h	2011-10-21 22:06:35 +0000
+++ Nux/HSplitter.h	2012-09-18 19:02:35 +0000
@@ -80,7 +80,7 @@
     virtual Area* KeyNavIteration(KeyNavDirection direction);
 
   private:
-    typedef InputArea MySplitter;
+    typedef BasicView MySplitter;
     std::vector<Area *> m_InterfaceObject;
     std::vector<MySplitter *> m_SplitterObject;
     std::vector<float> m_SplitConfig;

=== modified file 'Nux/InputArea.cpp'
--- Nux/InputArea.cpp	2012-09-18 19:02:34 +0000
+++ Nux/InputArea.cpp	2012-09-18 19:02:35 +0000
@@ -27,7 +27,6 @@
 
 #include "NuxCore/Logger.h"
 
-#include "Features.h"
 #include "Nux.h"
 #include "InputArea.h"
 #include "NuxGraphics/GraphicsEngine.h"
@@ -73,7 +72,10 @@
 
   void InputArea::OnDraw(GraphicsEngine &graphics_engine, bool force_draw)
   {
-    graphics_engine.QRP_Color(GetBaseX(), GetBaseY(), GetBaseWidth(), GetBaseHeight(), area_color_);
+    // Draw Nothing!
+
+    // For debug Only:
+    // graphics_engine.QRP_Color(GetBaseX(), GetBaseY(), GetBaseWidth(), GetBaseHeight(), area_color_);
   }
 
   void InputArea::SetBaseString(const char *Caption)

=== modified file 'Nux/InputArea.h'
--- Nux/InputArea.h	2012-06-26 13:38:50 +0000
+++ Nux/InputArea.h	2012-09-18 19:02:35 +0000
@@ -23,8 +23,6 @@
 #ifndef INPUTAREA_H
 #define INPUTAREA_H
 
-#include "Features.h"
-
 #include "Area.h"
 
 #if defined(NUX_OS_WINDOWS)

=== modified file 'Nux/LayeredLayout.cpp'
--- Nux/LayeredLayout.cpp	2012-04-10 00:58:09 +0000
+++ Nux/LayeredLayout.cpp	2012-09-18 19:02:35 +0000
@@ -59,7 +59,7 @@
     m_child_draw_queued(false)
   {
     m_ContentStacking = eStackLeft;
-    OnChildQueueDraw.connect(sigc::mem_fun(this, &LayeredLayout::ChildQueueDraw));
+    child_queue_draw.connect(sigc::mem_fun(this, &LayeredLayout::ChildQueueDraw));
   }
 
   LayeredLayout::~LayeredLayout()
@@ -163,11 +163,6 @@
       Layout *layout = NUX_STATIC_CAST(Layout *, _area);
       layout->ProcessDraw(graphics_engine, force_draw);
     }
-    else if (_area->IsArea())
-    {
-      InputArea *area = NUX_STATIC_CAST(InputArea *, _area);
-      area->OnDraw(graphics_engine, force_draw);
-    }
   }
 
   void LayeredLayout::ProcessDraw(GraphicsEngine &graphics_engine, bool force_draw)
@@ -204,7 +199,7 @@
     }
 
     graphics_engine.PopClippingRectangle();
-    _queued_draw = false;
+    draw_cmd_queued_ = false;
   }
 
   Area* LayeredLayout::FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type)

=== modified file 'Nux/Layout.cpp'
--- Nux/Layout.cpp	2012-05-31 21:50:05 +0000
+++ Nux/Layout.cpp	2012-09-18 19:02:35 +0000
@@ -41,7 +41,8 @@
     m_contentWidth      = 0;
     m_contentHeight     = 0;
     m_ContentStacking   = eStackExpand;
-    _queued_draw        = false;
+    draw_cmd_queued_        = false;
+    child_draw_cmd_queued_  = false;
 
     SetMinimumSize(1, 1);
   }
@@ -146,13 +147,13 @@
     left_padding_ = left < 0 ? 0 : left;
   }
 
-  //! Deprecated. Use SetLeftRightPadding.
+  //! Deprecated. Use SetLeftAndRightPadding.
   void Layout::SetHorizontalExternalMargin(int padding)
   {
     SetLeftAndRightPadding(padding);
   }
 
-  //! Deprecated. Use SetTopBottomPadding,
+  //! Deprecated. Use SetTopAndBottomPadding,
   void Layout::SetVerticalExternalMargin(int padding)
   {
     SetTopAndBottomPadding(padding);
@@ -229,8 +230,8 @@
 
     layout->SetParentObject(this);
 
-    layout->OnChildQueueDraw.connect(sigc::mem_fun(this, &Layout::ChildLayoutChildQueuedDraw));
-    layout->OnQueueDraw.connect(sigc::mem_fun(this, &Layout::ChildLayoutQueuedDraw));
+    layout->child_queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
+    layout->queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
 
     if (index < 0)
       index = NUX_LAYOUT_BEGIN;
@@ -283,6 +284,9 @@
     nuxAssertMsg(bo != 0, "[Layout::AddView] Invalid parameter.");
     NUX_RETURN_IF_TRUE(bo == 0);
 
+    if (!bo->IsView())
+      return;
+
     Area *parent = bo->GetParentObject();
     nuxAssertMsg(parent == 0, "[Layout::AddView] Trying to add an object that already has a parent.");
     NUX_RETURN_IF_TRUE(parent != 0);
@@ -309,7 +313,10 @@
     bo->SetParentObject(this);
 
     if (bo->IsView())
-      static_cast<View *> (bo)->OnQueueDraw.connect(sigc::mem_fun(this, &Layout::ChildViewQueuedDraw));
+    {
+      static_cast<View*> (bo)->queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
+      static_cast<View*> (bo)->child_queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
+    }
 
     //if(HasFocusControl() && HasFocusableEntries() == false)
     //{
@@ -492,77 +499,272 @@
   void Layout::ProcessDraw(GraphicsEngine &graphics_engine, bool force_draw)
   {
     std::list<Area *>::iterator it;
-    graphics_engine.PushModelViewMatrix(Get2DMatrix());
-
-    // Clip against the padding region.
-    Geometry clip_geo = GetGeometry();
-    clip_geo.OffsetPosition(left_padding_, top_padding_);
-    clip_geo.OffsetSize(-left_padding_ - right_padding_, -top_padding_ - bottom_padding_);
-
-    graphics_engine.PushClippingRectangle(clip_geo);
-
-    for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
-    {
-      if (!(*it)->IsVisible())
-        continue;
-
-      if ((*it)->IsView())
-      {
-        View *ic = NUX_STATIC_CAST(View*, (*it));
-        ic->ProcessDraw(graphics_engine, force_draw);
-      }
-      else if ((*it)->IsLayout())
-      {
-        Layout *layout = NUX_STATIC_CAST(Layout*, (*it));
-        layout->ProcessDraw(graphics_engine, force_draw);
-      }
-      // InputArea should be tested last
-      else if ((*it)->IsInputArea())
-      {
-        InputArea *input_area = NUX_STATIC_CAST(InputArea*, (*it));
-        input_area->OnDraw(graphics_engine, force_draw);
-      }
-    }
-
-    graphics_engine.PopClippingRectangle();
+
+    if (RedirectRenderingToTexture())
+    {
+      if (update_backup_texture_ || force_draw || draw_cmd_queued_)
+      {
+        GetPainter().PushPaintLayerStack();
+        BeginBackupTextureRendering(graphics_engine, force_draw);
+        {
+          graphics_engine.PushModelViewMatrix(Get2DMatrix());
+
+          for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+          {
+            if (!(*it)->IsVisible())
+              continue;
+
+            if ((*it)->IsView())
+            {
+              View* view = static_cast<View*>(*it);
+              view->ProcessDraw(graphics_engine, force_draw);
+            }
+            else if ((*it)->IsLayout())
+            {
+              Layout* layout = static_cast<Layout*>(*it);
+              layout->ProcessDraw(graphics_engine, force_draw);
+            }
+          }
+          graphics_engine.PopModelViewMatrix();
+        }
+        EndBackupTextureRendering(graphics_engine, force_draw);
+        GetPainter().PopPaintLayerStack();
+      }
+
+      if (PresentRedirectedView())
+      {
+        unsigned int current_alpha_blend;
+        unsigned int current_src_blend_factor;
+        unsigned int current_dest_blend_factor;
+        // Be a good citizen, get a copy of the current GPU sates according to Nux
+        graphics_engine.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+
+        TexCoordXForm texxform;
+        //Geometry xform_geo = GetGraphicsDisplay()->GetGraphicsEngine()->ModelViewXFormRect(GetGeometry());
+        if ((force_draw || draw_cmd_queued_) && background_texture_.IsValid())
+        {
+          graphics_engine.GetRenderStates().SetBlend(false);
+          texxform.FlipVCoord(true);
+          // Draw the background of this view.
+          GetGraphicsDisplay()->GetGraphicsEngine()->QRP_1Tex(GetX(), GetY(), background_texture_->GetWidth(), background_texture_->GetHeight(), background_texture_, texxform, color::White);
+        }
+
+        texxform.uwrap = TEXWRAP_CLAMP;
+        texxform.vwrap = TEXWRAP_CLAMP;
+        texxform.FlipVCoord(true);
+
+        graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+        GetGraphicsDisplay()->GetGraphicsEngine()->QRP_1Tex(GetX(), GetY(), GetWidth(), GetHeight(), backup_texture_, texxform, Color(color::White));
+        // Be a good citizen, restore the Nux blending states.
+        graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+      }
+    }
+    else
+    {
+      graphics_engine.PushModelViewMatrix(Get2DMatrix());
+
+      // Clip against the padding region.
+      Geometry clip_geo = GetGeometry();
+      clip_geo.OffsetPosition(left_padding_, top_padding_);
+      clip_geo.OffsetSize(-left_padding_ - right_padding_, -top_padding_ - bottom_padding_);
+
+      graphics_engine.PushClippingRectangle(clip_geo);
+
+      for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+      {
+        if (!(*it)->IsVisible())
+          continue;
+
+        if ((*it)->IsView())
+        {
+          View* view = static_cast<View*>(*it);
+          view->ProcessDraw(graphics_engine, force_draw);
+        }
+        else if ((*it)->IsLayout())
+        {
+          Layout* layout = static_cast<Layout*>(*it);
+          layout->ProcessDraw(graphics_engine, force_draw);
+        }
+      }
+
+      graphics_engine.PopClippingRectangle();
+      graphics_engine.PopModelViewMatrix();
+    }
+
+    ResetQueueDraw();
+  }
+
+  void Layout::BeginBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw)
+  {
+    ObjectPtr<IOpenGLBaseTexture> active_fbo_texture;
+    if (force_draw || draw_cmd_queued_)
+    {
+      // Get the active fbo color texture
+      active_fbo_texture = GetGraphicsDisplay()->GetGpuDevice()->ActiveFboTextureAttachment(0);
+    }
+
+    Geometry xform_geo;
+    // Compute position in the active fbo texture.
+    xform_geo = graphics_engine.ModelViewXFormRect(GetGeometry());
+
+    // Get the current fbo...
+    prev_fbo_ = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
+    // ... and the size of the view port rectangle.
+    prev_viewport_ = graphics_engine.GetViewportRect();
+
+    const int width = GetWidth();
+    const int height = GetHeight();
+
+    // Compute intersection with active fbo.
+    Geometry intersection = xform_geo;
+    if (active_fbo_texture.IsValid())
+    {
+      Geometry active_fbo_geo(0, 0, active_fbo_texture->GetWidth(), active_fbo_texture->GetHeight());
+      intersection = active_fbo_geo.Intersect(xform_geo);
+    }
+
+    if (backup_fbo_.IsNull())
+    {
+      // Create the fbo before using it for the first time.
+      backup_fbo_ = GetGraphicsDisplay()->GetGpuDevice()->CreateFrameBufferObject();
+    }
+
+    if (!backup_texture_.IsValid() || (backup_texture_->GetWidth() != width) || (backup_texture_->GetHeight() != height))
+    {
+      // Create or resize the color and depth textures before using them.
+      backup_texture_ = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(width, height, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
+      backup_depth_texture_ = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(width, height, 1, BITFMT_D24S8, NUX_TRACKER_LOCATION);
+    }
+
+    if (!background_texture_.IsValid() || (background_texture_->GetWidth() != intersection.width) || (background_texture_->GetHeight() != intersection.height))
+    {
+      background_texture_ = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(intersection.width, intersection.height, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
+    }
+
+    // Draw the background on the previous fbo texture
+    if ((force_draw || draw_cmd_queued_) && background_texture_.IsValid())
+    {
+      backup_fbo_->FormatFrameBufferObject(intersection.width, intersection.height, BITFMT_R8G8B8A8);
+      backup_fbo_->EmptyClippingRegion();
+
+      graphics_engine.SetViewport(0, 0, intersection.width, intersection.height);
+      graphics_engine.SetOrthographicProjectionMatrix(intersection.width, intersection.height);
+
+      // Set the background texture in the fbo
+      backup_fbo_->SetTextureAttachment(0, background_texture_, 0);
+      backup_fbo_->SetDepthTextureAttachment(ObjectPtr<IOpenGLBaseTexture>(0), 0);
+      backup_fbo_->Activate();
+      graphics_engine.SetViewport(0, 0, background_texture_->GetWidth(), background_texture_->GetHeight());
+
+      // Clear surface
+      CHECKGL(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
+      CHECKGL(glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT));
+
+      TexCoordXForm texxform;
+      texxform.uoffset = xform_geo.x / (float) active_fbo_texture->GetWidth();
+      texxform.voffset = xform_geo.y / (float) active_fbo_texture->GetHeight();
+      texxform.SetTexCoordType(TexCoordXForm::OFFSET_COORD);
+      texxform.flip_v_coord = true;
+
+      // Temporarily change the model-view matrix to copy the texture background texture.
+      // This way we are not affceted by the regular model-view matrix.
+      graphics_engine.SetModelViewMatrix(Matrix4::IDENTITY());
+      // Copy the texture from the previous fbo attachment into our background texture.
+      if (copy_previous_fbo_for_background_)
+      {
+        graphics_engine.QRP_1Tex(0, 0, intersection.width, intersection.height, active_fbo_texture, texxform, color::White);
+      }
+      else
+      {
+        graphics_engine.QRP_Color(0, 0, intersection.width, intersection.height, Color(0.0f, 0.0f, 0.0f, 0.0f));
+      }
+      // Restore the model-view matrix.
+      graphics_engine.ApplyModelViewMatrix();
+    }
+
+    backup_fbo_->FormatFrameBufferObject(width, height, BITFMT_R8G8B8A8);
+    backup_fbo_->EmptyClippingRegion();
+    backup_fbo_->SetTextureAttachment(0, backup_texture_, 0);
+    backup_fbo_->SetDepthTextureAttachment(backup_depth_texture_, 0);
+    backup_fbo_->Activate();
+
+    if (force_draw || draw_cmd_queued_)
+    {
+      CHECKGL(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
+      CHECKGL(glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT));
+    }
+
+    graphics_engine.SetViewport(0, 0, width, height);
+    graphics_engine.SetOrthographicProjectionMatrix(width, height);
+    // Transform the geometry of this area through the current model view matrix. This gives the
+    // the position of the view in the active fbo texture.
+    Geometry offset_rect = graphics_engine.ModelViewXFormRect(GetGeometry());
+    int x_offset = -offset_rect.x;
+    int y_offset = -offset_rect.y;
+    graphics_engine.PushModelViewMatrix(Matrix4::TRANSLATE(x_offset, y_offset, 0));
+  }
+
+  void Layout::EndBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw)
+  {
     graphics_engine.PopModelViewMatrix();
 
-    //graphics_engine.PopClipOffset();
-
-    _queued_draw = false;
+    if (prev_fbo_.IsValid())
+    {
+      // Restore the previous fbo
+      prev_fbo_->Activate();
+
+      prev_fbo_->ApplyClippingRegion();
+    }
+
+    // Release the reference on the previous fbo
+    prev_fbo_.Release();
+
+    // Restore the matrices and the view port.
+    graphics_engine.ApplyModelViewMatrix();
+    graphics_engine.SetOrthographicProjectionMatrix(prev_viewport_.width, prev_viewport_.height);
+    graphics_engine.SetViewport(prev_viewport_.x, prev_viewport_.y, prev_viewport_.width, prev_viewport_.height);
   }
 
   void Layout::QueueDraw()
   {
-    if (_queued_draw)
+    if (draw_cmd_queued_)
     {
       // A draw has already been scheduled.
       return;
     }
 
-    std::list<Area *>::iterator it;
+    // Report to a parent view with redirect_rendering_to_texture_ set to true that one of its children
+    // needs to be redrawn.
+    PrepareParentRedirectedView();
+
+    std::list<Area*>::iterator it;
 
     for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
     {
       if ((*it)->IsView())
       {
-        View *ic = NUX_STATIC_CAST(View *, (*it));
-        ic->QueueDraw();
+        View* view = static_cast<View*>(*it);
+        view->QueueDraw();
       }
       else if ((*it)->IsLayout())
       {
-        Layout *layout = NUX_STATIC_CAST(Layout *, (*it));
+        Layout* layout = static_cast<Layout*>(*it);
         layout->QueueDraw();
       }
     }
 
-    _queued_draw = true;
-    OnQueueDraw.emit(this);
+    draw_cmd_queued_ = true;
+    queue_draw.emit(this);
   }
 
   bool Layout::IsQueuedForDraw()
   {
-    return _queued_draw;
+    return draw_cmd_queued_;
+  }
+
+  bool Layout::ChildQueuedForDraw()
+  {
+    return child_draw_cmd_queued_;
   }
 
   void Layout::SetContentDistribution(LayoutContentDistribution stacking)
@@ -580,19 +782,12 @@
 
   }
 
-  void Layout::ChildViewQueuedDraw(View *view)
-  {
-    OnChildQueueDraw.emit(view);
-  }
-
-  void Layout::ChildLayoutQueuedDraw(Layout *layout)
-  {
-    OnChildQueueDraw.emit(layout);
-  }
-
-  void Layout::ChildLayoutChildQueuedDraw(Area *area)
-  {
-    OnChildQueueDraw.emit(area);
+  void Layout::ChildQueueDraw(Area* area)
+  {
+    if (child_draw_cmd_queued_)
+      return;
+    child_draw_cmd_queued_ = true;
+    child_queue_draw.emit(area);
   }
 
   bool Layout::AcceptKeyNavFocus()
@@ -600,6 +795,54 @@
     return false;
   }
 
+  void Layout::ResetQueueDraw()
+  {
+    std::list<Area*>::iterator it;
+    for (it = _layout_element_list.begin(); it != _layout_element_list.end(); it++)
+    {
+      if ((*it)->IsLayout())
+      {
+        Layout* layout = NUX_STATIC_CAST(Layout*, (*it));
+        if (layout->ChildQueuedForDraw())
+        {
+          layout->ResetQueueDraw();
+        }
+      }
+      else if ((*it)->IsView())
+      {
+        View* view = NUX_STATIC_CAST(View*, (*it));
+        if (view->GetLayout())
+        {
+          view->GetLayout()->ResetQueueDraw();
+          view->draw_cmd_queued_ = false;
+          view->child_draw_cmd_queued_ = false;
+        }
+      }
+    }
+
+    draw_cmd_queued_ = false;
+    child_draw_cmd_queued_ = false;
+    update_backup_texture_ = false;
+  }
+
+  void Layout::GeometryChangePending(bool position_about_to_change, bool size_about_to_change)
+  {
+    if (IsLayoutDone())
+      QueueDraw();
+  }
+
+  void Layout::GeometryChanged(bool position_has_changed, bool size_has_changed)
+  {
+    if (RedirectedAncestor())
+    {
+      if (size_has_changed)
+        QueueDraw();
+      return;
+    }
+    if (IsLayoutDone())
+      QueueDraw();
+  }
+
 #ifdef NUX_GESTURES_SUPPORT
   Area* Layout::GetInputAreaHitByGesture(const GestureEvent &event)
   {

=== modified file 'Nux/Layout.h'
--- Nux/Layout.h	2012-05-31 21:50:05 +0000
+++ Nux/Layout.h	2012-09-18 19:02:35 +0000
@@ -137,10 +137,10 @@
     };
 
 
-    //! Deprecated. Use SetLeftRightPadding.
+    //! Deprecated. Use SetLeftAndRightPadding.
     void SetHorizontalExternalMargin(int m);
 
-    //! Deprecated. Use SetTopBottomPadding,
+    //! Deprecated. Use SetTopAndBottomPadding,
     void SetVerticalExternalMargin(int m);
 
     //! Set the left/right/top/bottom padding of the layout.
@@ -199,7 +199,7 @@
     /*!
         Mark all element in the layout as dirty. This will also mark all sub elements as dirty.
         InputArea element are not marked as dirty(they don't have the flags).
-        Emits the signal \i OnQueueDraw.
+        Emits the signal \i queue_draw.
     */
     virtual void QueueDraw();
 
@@ -209,6 +209,12 @@
     */
     bool IsQueuedForDraw();
 
+    //! Return true if a draw has been scheduled for a child of this layout
+    /*!
+        @return True if a draw has been scheduled for a child of this layout.
+    */
+    bool ChildQueuedForDraw();
+
     //! Define how elements are spread out inside the layout.
     /*!
         Typically, a layout stacks it elements from left to right(HLayout) or top to bottom(VLayout).
@@ -240,23 +246,34 @@
       return _layout_element_list;
     }
 
-    virtual void ChildViewQueuedDraw(View *view);
-    virtual void ChildLayoutQueuedDraw(Layout *layout);
-    virtual void ChildLayoutChildQueuedDraw(Area *area);
+    virtual void ChildQueueDraw(Area* area);
 
-    sigc::signal<void, Layout*> OnQueueDraw;  //!< Signal emitted when a layout is scheduled for a draw.
-    sigc::signal<void, Area*>   OnChildQueueDraw;
+    sigc::signal<void, Layout*> queue_draw;  //!< Signal emitted when a layout is scheduled for a draw.
+    sigc::signal<void, Area*>   child_queue_draw;
     sigc::signal<void, Layout*, Area*> ViewAdded;
     sigc::signal<void, Layout*, Area*> ViewRemoved;
 
 #ifdef NUX_GESTURES_SUPPORT
     virtual Area* GetInputAreaHitByGesture(const GestureEvent &event);
 #endif
+    
+    /*!
+        When a layout goes through Layout::ProcessDraw, this call isn't necessary. Otherwise, call it
+        to set the value of draw_cmd_queued_ to false. 
+    */
+    virtual void ResetQueueDraw(); 
 
   protected:
+    void BeginBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw);
+    void EndBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw);
+
+    virtual void GeometryChangePending(bool position_about_to_change, bool size_about_to_change);
+    virtual void GeometryChanged(bool position_has_changed, bool size_has_changed);
+
     virtual bool AcceptKeyNavFocus();
     
-    bool _queued_draw; //<! The rendering of the layout needs to be refreshed.
+    bool draw_cmd_queued_; //<! The rendering of the layout needs to be refreshed.
+    bool child_draw_cmd_queued_; //<! A child of this layout has requested a draw.
 
     Size m_ContentSize;
     int m_contentWidth;

=== modified file 'Nux/LinearLayout.cpp'
--- Nux/LinearLayout.cpp	2011-10-17 20:57:35 +0000
+++ Nux/LinearLayout.cpp	2012-09-18 19:02:35 +0000
@@ -73,8 +73,8 @@
 
     layout->SetParentObject(this);
 
-    layout->OnChildQueueDraw.connect(sigc::mem_fun(this, &Layout::ChildLayoutChildQueuedDraw));
-    layout->OnQueueDraw.connect(sigc::mem_fun(this, &Layout::ChildLayoutQueuedDraw));
+    layout->child_queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
+    layout->queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
 
     if (index < 0)
       index = NUX_LAYOUT_BEGIN;
@@ -153,7 +153,7 @@
     bo->SetParentObject(this);
 
     if (bo->IsView())
-      static_cast<View *> (bo)->OnQueueDraw.connect(sigc::mem_fun(this, &Layout::ChildViewQueuedDraw));
+      (static_cast<View *> (bo))->queue_draw.connect(sigc::mem_fun(this, &Layout::ChildQueueDraw));
 
     //if(HasFocusControl() && HasFocusableEntries() == false)
     //{

=== modified file 'Nux/MainLoopGLib.cpp'
--- Nux/MainLoopGLib.cpp	2012-05-31 21:40:37 +0000
+++ Nux/MainLoopGLib.cpp	2012-09-18 19:02:35 +0000
@@ -1,4 +1,3 @@
-#include "Features.h"
 #include "Nux.h"
 #include "Layout.h"
 #include "NuxCore/Logger.h"

=== modified file 'Nux/Makefile.am'
--- Nux/Makefile.am	2012-07-27 19:40:40 +0000
+++ Nux/Makefile.am	2012-09-18 19:02:35 +0000
@@ -41,6 +41,7 @@
   $(srcdir)/InputArea.cpp \
   $(srcdir)/Area.cpp \
   $(srcdir)/BaseWindow.cpp \
+  $(srcdir)/BasicView.cpp \
   $(srcdir)/Button.cpp \
   $(srcdir)/Canvas.cpp \
   $(srcdir)/CairoWrapper.cpp \
@@ -135,6 +136,7 @@
   $(srcdir)/InputArea.h \
   $(srcdir)/Area.h \
   $(srcdir)/BaseWindow.h \
+  $(srcdir)/BasicView.h \
   $(srcdir)/Button.h \
   $(srcdir)/Canvas.h \
   $(srcdir)/CairoWrapper.h \
@@ -171,6 +173,7 @@
   $(srcdir)/MouseAreaCtrl.h \
   $(srcdir)/NumericValuator.h \
   $(srcdir)/Nux.h \
+  $(srcdir)/NuxTimerTickSource.h \
   $(srcdir)/NuxGlobalInitializer.h \
   $(srcdir)/Painter.h \
   $(srcdir)/Panel.h \

=== modified file 'Nux/MenuBar.cpp'
--- Nux/MenuBar.cpp	2011-12-06 16:29:06 +0000
+++ Nux/MenuBar.cpp	2012-09-18 19:02:35 +0000
@@ -41,7 +41,7 @@
     :   Object(true, NUX_FILE_LINE_PARAM)
   {
     // This area is added to the layout of the MenuBar. The Menubar will will ref/unref it.
-    area = new InputArea(NUX_TRACKER_LOCATION);
+    area = new BasicView(NUX_TRACKER_LOCATION);
     icon = 0;
   }
 
@@ -97,7 +97,7 @@
 
     for (it = m_MenuBarItemList.begin(); it != m_MenuBarItemList.end(); it++)
     {
-      InputArea *area = (*it)->area;
+      BasicView *area = (*it)->area;
       item_geometry = area->GetGeometry();
 
       if (area->IsMouseInside())
@@ -151,7 +151,7 @@
 
     if (m_MenuIsActive)
     {
-      InputArea *area = m_CurrentMenu->area;
+      BasicView *area = m_CurrentMenu->area;
       item_geometry = area->GetGeometry();
       GetPainter().PaintBackground(graphics_engine, item_geometry);
       GetPainter().Paint2DQuadColor(graphics_engine, item_geometry, Color(0xFF000000));
@@ -342,7 +342,7 @@
 // 
 //         for (it = m_MenuBarItemList.begin(); it != m_MenuBarItemList.end(); it++)
 //         {
-//           InputArea *area = (*it)->area;
+//           BasicView *area = (*it)->area;
 //           Geometry geometry = area->GetGeometry();
 // 
 //           if (geometry.IsPointInside(winx, winy))
@@ -407,7 +407,7 @@
 
     for (it = m_MenuBarItemList.begin(); it != m_MenuBarItemList.end(); it++)
     {
-      InputArea *area = (*it)->area;
+      BasicView *area = (*it)->area;
       geometry = area->GetGeometry();
 
       if (geometry.IsPointInside(x, y))

=== modified file 'Nux/MenuBar.h'
--- Nux/MenuBar.h	2011-10-17 21:23:50 +0000
+++ Nux/MenuBar.h	2012-09-18 19:02:35 +0000
@@ -45,7 +45,7 @@
     MenuBarItem(NUX_FILE_LINE_PROTO);
     ~MenuBarItem();
   private:
-    InputArea   *area;
+    BasicView   *area;
     MenuPage   *menu;
     BaseTexture   *icon; // should be 24x24
 

=== modified file 'Nux/MouseAreaCtrl.cpp'
--- Nux/MouseAreaCtrl.cpp	2011-10-10 01:52:00 +0000
+++ Nux/MouseAreaCtrl.cpp	2012-09-18 19:02:35 +0000
@@ -31,7 +31,7 @@
   {
     // Set Original State
     m_vlayout   = new VLayout(NUX_TRACKER_LOCATION);
-    m_Area      = new InputArea(NUX_TRACKER_LOCATION);
+    m_Area      = new BasicView(NUX_TRACKER_LOCATION);
 
     // Set Signals
     m_Area->mouse_down.connect(sigc::mem_fun(this, &MouseAreaCtrl::MouseDown));

=== modified file 'Nux/MouseAreaCtrl.h'
--- Nux/MouseAreaCtrl.h	2011-10-10 01:52:00 +0000
+++ Nux/MouseAreaCtrl.h	2012-09-18 19:02:35 +0000
@@ -64,7 +64,7 @@
 
   private:
     VLayout    *m_vlayout;
-    InputArea   *m_Area;
+    BasicView   *m_Area;
 
   public:
     virtual void SetGeometry(const Geometry &geo)

=== modified file 'Nux/Nux.cpp'
--- Nux/Nux.cpp	2011-12-29 18:06:53 +0000
+++ Nux/Nux.cpp	2012-09-18 19:02:35 +0000
@@ -172,6 +172,7 @@
     w->user_exit_func_ = 0;
     w->initialization_data_ = data;
     w->window_style_ = WINDOWSTYLE_NORMAL;
+    w->embedded_window_ = true;
     w->ThreadCtor(WindowHandle, WindowDCHandle, OpenGLRenderingContext);
     return w;
   }

=== modified file 'Nux/Nux.h'
--- Nux/Nux.h	2012-02-19 00:02:14 +0000
+++ Nux/Nux.h	2012-09-18 19:02:35 +0000
@@ -52,6 +52,10 @@
 #define NUX_USE_GLIB_LOOP_ON_WINDOWS
 //#define NUX_DISABLE_GLIB_LOOP
 
+#if defined(NUX_OS_LINUX)
+#include "Features.h"
+#endif
+
 #include "Utils.h"
 #include "WidgetMetrics.h"
 #include "Area.h"
@@ -59,6 +63,7 @@
 #include "Theme.h"
 #include "Painter.h"
 #include "View.h"
+#include "BasicView.h"
 #include "AbstractThread.h"
 #include "WindowThread.h"
 #include "WindowCompositor.h"

=== added file 'Nux/NuxTimerTickSource.h'
--- Nux/NuxTimerTickSource.h	1970-01-01 00:00:00 +0000
+++ Nux/NuxTimerTickSource.h	2012-09-18 19:02:35 +0000
@@ -0,0 +1,54 @@
+#ifndef NUX_TIMER_TICK_SOURCE_H
+#define NUX_TIMER_TICK_SOURCE_H
+
+#include "NuxCore/Animation.h"
+#include "NuxCore/AnimationController.h"
+#include "Nux/Nux.h"
+#include "Nux/TimerProc.h"
+
+namespace nux
+{
+
+// Everything inline, but should be extracted.
+class NuxTimerTickSource: public animation::TickSource
+{
+public:
+  NuxTimerTickSource()
+    : foo(0)
+    {
+      timer_.tick.connect(sigc::mem_fun(this, &NuxTimerTickSource::Tick));
+      timer_.expired.connect(sigc::mem_fun(this, &NuxTimerTickSource::TimerExpired));
+      unsigned int period = 16; // ms
+      int duration = -1; // run forever
+      timer_handle_ = nux::GetTimer().AddDurationTimer(period, duration, &timer_, NULL);
+    }
+
+  ~NuxTimerTickSource()
+    {
+      if (timer_handle_.Activated())
+        nux::GetTimer().RemoveTimerHandler(timer_handle_);
+    }
+
+private:
+  void Tick(void*)
+    {
+      tick.emit(g_get_monotonic_time());
+      if (++foo % 60 == 0)
+      {
+        // LOG_WARN(logger) << "tick...";
+      }
+    }
+  void TimerExpired(void*)
+    {
+      //LOG_WARN(logger) << "Timer expired.";
+    }
+
+private:
+  int foo;
+  TimerFunctor timer_;
+  TimerHandle timer_handle_;
+};
+
+}
+
+#endif // NUX_TIMER_TICK_SOURCE_H

=== modified file 'Nux/PaintLayer.cpp'
--- Nux/PaintLayer.cpp	2012-03-13 02:50:57 +0000
+++ Nux/PaintLayer.cpp	2012-09-18 19:02:35 +0000
@@ -117,7 +117,16 @@
 
   void SliceScaledTextureLayer::Renderlayer(GraphicsEngine& graphics_engine)
   {
+    unsigned int current_alpha_blend;
+    unsigned int current_src_blend_factor;
+    unsigned int current_dest_blend_factor;
+
+    // Get the current blend states. They will be restored later.
+    graphics_engine.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+
     GetPainter().PaintTextureShape(graphics_engine, geometry_, m_image_style);
+
+    graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
   }
 
   AbstractPaintLayer* SliceScaledTextureLayer::Clone() const

=== modified file 'Nux/Painter.cpp'
--- Nux/Painter.cpp	2012-03-13 02:50:57 +0000
+++ Nux/Painter.cpp	2012-09-18 19:02:35 +0000
@@ -797,7 +797,7 @@
     graphics_engine.GetRenderStates().SetBlend(false);
   }
 
-  void BasePainter::PaintBackground(GraphicsEngine &graphics_engine, const Geometry &geo)
+  void BasePainter::PaintActivePaintLayerStack(GraphicsEngine &graphics_engine, const Geometry &geo)
   {
     if (active_paint_layer_stack_.empty())
     {
@@ -806,7 +806,12 @@
 
     std::list<AbstractPaintLayer *>::const_reverse_iterator rev_it;
 
-    bool first = true;
+    bool clear_background = false;
+    if (pushed_paint_layer_stack_.size() == 0)
+    {
+      // This is the first stack of layers. Clear the background
+      clear_background = true;
+    }
 
     for (rev_it = active_paint_layer_stack_.rbegin(); rev_it != active_paint_layer_stack_.rend(); rev_it++)
     {
@@ -817,10 +822,10 @@
       graphics_engine.PushClippingRectangle(geo);
       graphics_engine.SetModelViewMatrix(layer->GetModelViewMatrix());
 
-      if (first)
+      if (clear_background)
       {
         Paint2DQuadColor(graphics_engine, layer_geo, Color(0x0));
-        first = false;
+        clear_background = false;
       }
 
       RenderSinglePaintLayer(graphics_engine, layer_geo, layer);
@@ -831,6 +836,39 @@
     }
   }
 
+  void BasePainter::PaintBackground(GraphicsEngine& graphics_engine, const Geometry& geo)
+  {
+    PaintActivePaintLayerStack(graphics_engine, geo);
+  }
+
+  void BasePainter::PaintAllLayerStack(GraphicsEngine& graphics_engine, const Geometry& geo)
+  {
+    std::list<std::list<AbstractPaintLayer*> >::const_iterator stack_it;
+    std::list<AbstractPaintLayer *>::const_reverse_iterator rev_layer_it;
+
+    bool clear_background = true;
+
+    for (stack_it = pushed_paint_layer_stack_.begin(); stack_it != pushed_paint_layer_stack_.end(); stack_it++)
+    {
+      std::list<AbstractPaintLayer*> stack = (*stack_it);
+      for (rev_layer_it = stack.rbegin(); rev_layer_it != stack.rend(); rev_layer_it++)
+      {
+        AbstractPaintLayer* layer = (*rev_layer_it);
+        Geometry layer_geo = layer->GetGeometry();
+
+        graphics_engine.PushClippingRectangle(geo);
+        if (clear_background)
+        {
+          Paint2DQuadColor(graphics_engine, layer_geo, Color(0x0));
+          clear_background = false;
+        }
+
+        RenderSinglePaintLayer(graphics_engine, layer_geo, layer);
+        graphics_engine.PopClippingRectangle();
+      }
+    }
+  }
+
   void BasePainter::RenderSinglePaintLayer(GraphicsEngine &graphics_engine, Geometry geo, AbstractPaintLayer *paint_layer)
   {
     paint_layer->Renderlayer(graphics_engine);

=== modified file 'Nux/Painter.h'
--- Nux/Painter.h	2012-03-13 02:50:57 +0000
+++ Nux/Painter.h	2012-09-18 19:02:35 +0000
@@ -420,6 +420,13 @@
     */
     void PaintActivePaintLayerStack(GraphicsEngine &graphics_engine, const Geometry &geo);
 
+    //! Paint all layers in all stacks
+    /*
+        Paint all layers in all stacks with the current model-view and projection matrices.
+        This is useful for redirected rendering to textures.
+    */
+    void PaintAllLayerStack(GraphicsEngine& graphics_engine, const Geometry& geo);
+
     //! Deprecated. Use PushPaintLayerStack.
     void PushBackgroundStack();
 

=== modified file 'Nux/RGBValuator.cpp'
--- Nux/RGBValuator.cpp	2011-10-17 20:57:35 +0000
+++ Nux/RGBValuator.cpp	2012-09-18 19:02:35 +0000
@@ -120,16 +120,16 @@
     blue_caption_       = new EditTextBox("", NUX_TRACKER_LOCATION);
     alpha_caption_      = new EditTextBox("", NUX_TRACKER_LOCATION);
 
-    red_valuator_       = new InputArea(NUX_TRACKER_LOCATION);
-    green_valuator_     = new InputArea(NUX_TRACKER_LOCATION);
-    blue_valuator_      = new InputArea(NUX_TRACKER_LOCATION);
-    alpha_valuator_     = new InputArea(NUX_TRACKER_LOCATION);
-    color_square_       = new InputArea(NUX_TRACKER_LOCATION);
+    red_valuator_       = new BasicView(NUX_TRACKER_LOCATION);
+    green_valuator_     = new BasicView(NUX_TRACKER_LOCATION);
+    blue_valuator_      = new BasicView(NUX_TRACKER_LOCATION);
+    alpha_valuator_     = new BasicView(NUX_TRACKER_LOCATION);
+    color_square_       = new BasicView(NUX_TRACKER_LOCATION);
 
-    m_ComponentLabel0   = new InputArea(NUX_TRACKER_LOCATION);
-    m_ComponentLabel1   = new InputArea(NUX_TRACKER_LOCATION);
-    m_ComponentLabel2   = new InputArea(NUX_TRACKER_LOCATION);
-    m_ComponentAlpha    = new InputArea(NUX_TRACKER_LOCATION);
+    m_ComponentLabel0   = new BasicView(NUX_TRACKER_LOCATION);
+    m_ComponentLabel1   = new BasicView(NUX_TRACKER_LOCATION);
+    m_ComponentLabel2   = new BasicView(NUX_TRACKER_LOCATION);
+    m_ComponentAlpha    = new BasicView(NUX_TRACKER_LOCATION);
   }
 
   void RGBValuator::InitializeWidgets()
@@ -152,10 +152,6 @@
     alpha_valuator_->mouse_drag.connect(sigc::mem_fun(this, &RGBValuator::OnReceiveMouseDrag_Alpha));
     m_ColorModel->click.connect(sigc::mem_fun(this, &RGBValuator::OnChangeColorModel));
     m_ColorFormat->click.connect(sigc::mem_fun(this, &RGBValuator::OnChangeColorFormat));
-//    m_ColorModel->mouse_down.connect(sigc::mem_fun(this, &RGBValuator::RecvColorModelEvent));
-//    m_ColorModel->mouse_up.connect(sigc::mem_fun(this, &RGBValuator::RecvColorModelEvent));
-//    m_ColorModel->mouse_enter.connect(sigc::mem_fun(this, &RGBValuator::RecvColorModelEvent));
-
 
     m_ColorModel->SetFont(GetSysBoldFont());
     m_ColorFormat->SetFont(GetSysBoldFont());
@@ -403,7 +399,7 @@
     Geometry base = GetGeometry();
 
     graphics_engine.PushClippingRectangle(base);
-    GetPainter().PushDrawShapeLayer(graphics_engine, vlayout->GetGeometry(), eSHAPE_CORNER_ROUND4, Color(0xFF000000), eAllCorners);
+    GetPainter().PushDrawShapeLayer(graphics_engine, vlayout->GetGeometry(), eSHAPE_CORNER_ROUND4, Color(0xFF000000), eAllCorners, true);
 
     if (m_color_model == color::RGB)
     {
@@ -428,13 +424,6 @@
     DrawBlueMarker(graphics_engine);
     DrawAlphaMarker(graphics_engine);
 
-    red_caption_->QueueDraw();
-    green_caption_->QueueDraw();
-    blue_caption_->QueueDraw();
-    alpha_caption_->QueueDraw();
-    m_ColorModel->QueueDraw();
-    m_ColorFormat->QueueDraw();
-
     GetPainter().PopBackground();
     graphics_engine.PopClippingRectangle();
   }

=== modified file 'Nux/RGBValuator.h'
--- Nux/RGBValuator.h	2011-10-18 20:00:59 +0000
+++ Nux/RGBValuator.h	2012-09-18 19:02:35 +0000
@@ -148,16 +148,16 @@
     EditTextBox *green_caption_;
     EditTextBox *blue_caption_;
     EditTextBox *alpha_caption_;
-    InputArea *red_valuator_;
-    InputArea *green_valuator_;
-    InputArea *blue_valuator_;
-    InputArea *alpha_valuator_;
-    InputArea *color_square_;
+    BasicView *red_valuator_;
+    BasicView *green_valuator_;
+    BasicView *blue_valuator_;
+    BasicView *alpha_valuator_;
+    BasicView *color_square_;
 
-    InputArea *m_ComponentLabel0;
-    InputArea *m_ComponentLabel1;
-    InputArea *m_ComponentLabel2;
-    InputArea *m_ComponentAlpha;
+    BasicView *m_ComponentLabel0;
+    BasicView *m_ComponentLabel1;
+    BasicView *m_ComponentLabel2;
+    BasicView *m_ComponentAlpha;
 
     TextureLayer *m_CheckboardLayer;
 

=== modified file 'Nux/RadioButton.cpp'
--- Nux/RadioButton.cpp	2012-01-17 04:34:19 +0000
+++ Nux/RadioButton.cpp	2012-09-18 19:02:35 +0000
@@ -56,8 +56,6 @@
     Geometry base = GetGeometry();
     graphics_engine.PushClippingRectangle(base);
 
-    GetPainter().PaintBackground(graphics_engine, base);
-
     InteractState is;
     is.is_on = active_;
 
@@ -81,7 +79,7 @@
       static_text_->ProcessDraw(graphics_engine, true);
     }
     GetPainter().PopPaintLayerStack();
-
+  
     graphics_engine.PopClippingRectangle();
   }
 

=== modified file 'Nux/RangeValue.cpp'
--- Nux/RangeValue.cpp	2012-01-17 04:34:19 +0000
+++ Nux/RangeValue.cpp	2012-09-18 19:02:35 +0000
@@ -85,7 +85,7 @@
   void RangeValue::InitializeLayout()
   {
     hlayout         = new HLayout(NUX_TRACKER_LOCATION);
-    m_Percentage    = new InputArea(NUX_TRACKER_LOCATION);
+    m_Percentage    = new BasicView(NUX_TRACKER_LOCATION);
     m_ValueString   = new EditTextBox("", NUX_TRACKER_LOCATION);
   }
 

=== modified file 'Nux/RangeValue.h'
--- Nux/RangeValue.h	2012-01-17 04:34:19 +0000
+++ Nux/RangeValue.h	2012-09-18 19:02:35 +0000
@@ -114,7 +114,7 @@
   protected:
     HLayout        *hlayout;
     EditTextBox    *m_ValueString;
-    InputArea       *m_Percentage;
+    BasicView       *m_Percentage;
     Color m_StartColor;
     Color m_EndColor;
     Color m_ProgressColor;

=== modified file 'Nux/RangeValueInteger.cpp'
--- Nux/RangeValueInteger.cpp	2011-10-10 01:52:00 +0000
+++ Nux/RangeValueInteger.cpp	2012-09-18 19:02:35 +0000
@@ -87,7 +87,7 @@
   void RangeValueInteger::InitializeLayout()
   {
     hlayout         = new HLayout(NUX_TRACKER_LOCATION);
-    m_Percentage    = new InputArea(NUX_TRACKER_LOCATION);
+    m_Percentage    = new BasicView(NUX_TRACKER_LOCATION);
     m_ValueString   = new EditTextBox("", NUX_TRACKER_LOCATION);
   }
 

=== modified file 'Nux/RangeValueInteger.h'
--- Nux/RangeValueInteger.h	2011-10-10 01:52:00 +0000
+++ Nux/RangeValueInteger.h	2012-09-18 19:02:35 +0000
@@ -118,7 +118,7 @@
   protected:
     HLayout        *hlayout;
     EditTextBox    *m_ValueString;
-    InputArea       *m_Percentage;
+    BasicView       *m_Percentage;
     Color m_StartColor;
     Color m_EndColor;
     Color m_ProgressColor;

=== modified file 'Nux/ScrollView.cpp'
--- Nux/ScrollView.cpp	2012-08-23 08:40:45 +0000
+++ Nux/ScrollView.cpp	2012-09-18 19:02:35 +0000
@@ -289,14 +289,12 @@
   void ScrollView::EnableVerticalScrollBar(bool b)
   {
     m_vertical_scrollbar_enable = b;
-    _delta_y = 0;
     ComputeContentSize();
   }
 
   void ScrollView::EnableHorizontalScrollBar(bool b)
   {
     m_horizontal_scrollbar_enable = b;
-    _delta_x = 0;
     ComputeContentSize();
   }
 

=== modified file 'Nux/SpinBox_Logic.cpp'
--- Nux/SpinBox_Logic.cpp	2012-07-04 16:36:46 +0000
+++ Nux/SpinBox_Logic.cpp	2012-09-18 19:02:35 +0000
@@ -32,8 +32,8 @@
     ,   m_UpTimerHandler(0)
     ,   m_DownTimerHandler(0)
   {
-    m_SpinnerUpBtn      = new InputArea(NUX_TRACKER_LOCATION);
-    m_SpinnerDownBtn    = new InputArea(NUX_TRACKER_LOCATION);
+    m_SpinnerUpBtn      = new BasicView(NUX_TRACKER_LOCATION);
+    m_SpinnerDownBtn    = new BasicView(NUX_TRACKER_LOCATION);
     m_EditLine          = new EditTextBox("", NUX_TRACKER_LOCATION);
 
     // Set Original State

=== modified file 'Nux/SpinBox_Logic.h'
--- Nux/SpinBox_Logic.h	2011-10-10 01:52:00 +0000
+++ Nux/SpinBox_Logic.h	2012-09-18 19:02:35 +0000
@@ -74,8 +74,8 @@
 
   protected:
     EditTextBox    *m_EditLine;
-    InputArea       *m_SpinnerUpBtn;
-    InputArea       *m_SpinnerDownBtn;
+    BasicView       *m_SpinnerUpBtn;
+    BasicView       *m_SpinnerDownBtn;
 
     TimerFunctor *m_UpTimerCallback;
     TimerFunctor *m_DownTimerCallback;

=== modified file 'Nux/TabView.cpp'
--- Nux/TabView.cpp	2012-07-04 16:36:46 +0000
+++ Nux/TabView.cpp	2012-09-18 19:02:35 +0000
@@ -45,7 +45,7 @@
     _index = 0;
     _tab_name = TabName;
     _tab_content_layout = TabLayout;
-    _tab_area = new InputArea(NUX_TRACKER_LOCATION);
+    _tab_area = new BasicView(NUX_TRACKER_LOCATION);
 
     _tab_content_layout->Reference();
     _tab_area->Reference();
@@ -100,8 +100,8 @@
     //_tabview_heads_layout->SetParentObject(this);
     _tabview_scroll_button_layout  = new HLayout(NUX_TRACKER_LOCATION);
     _tabview_scroll_button_layout->SetParentObject(this);
-    _scroll_right           = new InputArea(NUX_TRACKER_LOCATION);
-    _scroll_left           = new InputArea(NUX_TRACKER_LOCATION);
+    _scroll_right           = new BasicView(NUX_TRACKER_LOCATION);
+    _scroll_left           = new BasicView(NUX_TRACKER_LOCATION);
 
     _scroll_right->SetMinimumSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);
     _scroll_left->SetMinimumSize(TAB_BUTTON_WIDTH, TAB_BUTTON_HEIGHT);

=== modified file 'Nux/TabView.h'
--- Nux/TabView.h	2011-10-10 01:52:00 +0000
+++ Nux/TabView.h	2012-09-18 19:02:35 +0000
@@ -74,7 +74,7 @@
 
       NString     _tab_name;
       Layout     *_tab_content_layout;
-      InputArea  *_tab_area;
+      BasicView  *_tab_area;
       int         _index;
     };
 
@@ -103,8 +103,8 @@
     void TranslateRight(int x, int y, unsigned long button_flags, unsigned long key_flags);
     void TranslateTabLayout(int offset);
 
-    InputArea   *_scroll_right;
-    InputArea   *_scroll_left;
+    BasicView   *_scroll_right;
+    BasicView   *_scroll_left;
 
     Layout     *_visible_tab_content_layout;
     HLayout    *_tabview_heads_layout;

=== modified file 'Nux/TextEntry.cpp'
--- Nux/TextEntry.cpp	2012-08-28 21:30:51 +0000
+++ Nux/TextEntry.cpp	2012-09-18 19:02:35 +0000
@@ -27,9 +27,9 @@
 #include "NuxGraphics/CairoGraphics.h"
 
 #include "TextEntry.h"
+
+#if defined(NUX_OS_LINUX)
 #include "TextEntryComposeSeqs.h"
-
-#if defined(NUX_OS_LINUX)
 #include <X11/cursorfont.h>
 #include "InputMethodIBus.h"
 #endif
@@ -187,6 +187,7 @@
 
     SetAcceptKeyboardEvent(true);
     EnableDoubleClick(true);
+    SetPasswordChar("*");
   }
 
   TextEntry::~TextEntry()
@@ -220,10 +221,8 @@
 
   void TextEntry::GeometryChanged()
   {
-
       update_canvas_ = true;
-      View::GeometryChanged();
-
+      View::GeometryChanged(true, true);
   }
 
   Area* TextEntry::FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type)
@@ -633,6 +632,7 @@
   {
     SearchState search_state = SearchState::NO_MATCH;
 
+#if defined(NUX_OS_LINUX)
     if (input.size() >= ComposeSequence::MAX_SYMBOLS)
       return search_state;
 
@@ -670,6 +670,7 @@
         }
       }
     }
+#endif
 
     return search_state;
   }
@@ -2555,12 +2556,10 @@
   {
     if (c == NULL || *c == 0 || !IsLegalUTF8Char(c, GetUTF8CharLength(c)))
     {
-      SetVisibility(true);
       password_char_.clear();
     }
     else
     {
-      SetVisibility(false);
       password_char_.assign(c, GetUTF8CharLength(c));
     }
     QueueRefresh(true, true);

=== modified file 'Nux/TextEntry.h'
--- Nux/TextEntry.h	2012-08-28 21:30:51 +0000
+++ Nux/TextEntry.h	2012-09-18 19:02:35 +0000
@@ -237,7 +237,7 @@
     /**
      * Enum used for the search state of the compose list
      */
-    enum class SearchState {
+    enum SearchState {
       NO_MATCH,
       PARTIAL,
       MATCH

=== modified file 'Nux/Theme.cpp'
--- Nux/Theme.cpp	2012-07-26 00:17:42 +0000
+++ Nux/Theme.cpp	2012-09-18 19:02:35 +0000
@@ -22,7 +22,7 @@
 #include "Nux.h"
 #include "Theme.h"
 #if defined(NUX_OS_WINDOWS)
-  #include "NuxCore/TinyXML/tinyxml.h"
+  #include "tinyxml/tinyxml.h"
 #endif
 
 namespace nux

=== modified file 'Nux/VScrollBar.cpp'
--- Nux/VScrollBar.cpp	2012-07-04 16:36:46 +0000
+++ Nux/VScrollBar.cpp	2012-09-18 19:02:35 +0000
@@ -52,10 +52,10 @@
     m_DownTimerHandler  = 0;
 
     vlayout         = new VLayout(NUX_TRACKER_LOCATION);
-    _scroll_up_button      = new InputArea(NUX_TRACKER_LOCATION);
-    _track         = new InputArea(NUX_TRACKER_LOCATION);
-    _scroll_down_button   = new InputArea(NUX_TRACKER_LOCATION);
-    _slider      = new InputArea(NUX_TRACKER_LOCATION);
+    _scroll_up_button      = new BasicView(NUX_TRACKER_LOCATION);
+    _track         = new BasicView(NUX_TRACKER_LOCATION);
+    _scroll_down_button   = new BasicView(NUX_TRACKER_LOCATION);
+    _slider      = new BasicView(NUX_TRACKER_LOCATION);
     _slider->SetParentObject(this);
 
     // Set Original State

=== modified file 'Nux/VScrollBar.h'
--- Nux/VScrollBar.h	2012-01-02 20:39:31 +0000
+++ Nux/VScrollBar.h	2012-09-18 19:02:35 +0000
@@ -98,10 +98,10 @@
     bool AtMaximum();
 
     VLayout *vlayout;
-    InputArea *_slider;
-    InputArea *_scroll_up_button;
-    InputArea *_scroll_down_button;
-    InputArea *_track;
+    BasicView *_slider;
+    BasicView *_scroll_up_button;
+    BasicView *_scroll_down_button;
+    BasicView *_track;
 
     int content_width_;
     int content_height_;

=== modified file 'Nux/VSplitter.cpp'
--- Nux/VSplitter.cpp	2012-07-30 21:07:40 +0000
+++ Nux/VSplitter.cpp	2012-09-18 19:02:35 +0000
@@ -139,11 +139,6 @@
           View *ic = NUX_STATIC_CAST(View *, (*it));
           ic->ProcessDraw(graphics_engine, true);
         }
-        else if ((*it)->Type().IsObjectType(InputArea::StaticObjectType))
-        {
-          InputArea *base_area = NUX_STATIC_CAST(InputArea *, (*it));
-          base_area->OnDraw(graphics_engine, true);
-        }
         else if ((*it)->Type().IsObjectType(HLayout::StaticObjectType))
         {
           HLayout *layout = NUX_STATIC_CAST(HLayout *, (*it));
@@ -162,11 +157,6 @@
           View *ic = NUX_STATIC_CAST(View *, (*it));
           ic->ProcessDraw(graphics_engine, false);
         }
-        else if ((*it)->Type().IsObjectType(InputArea::StaticObjectType))
-        {
-          InputArea *base_area = NUX_STATIC_CAST(InputArea *, (*it));
-          base_area->OnDraw(graphics_engine, false);
-        }
         else if ((*it)->Type().IsObjectType(HLayout::StaticObjectType))
         {
           HLayout *layout = NUX_STATIC_CAST(HLayout *, (*it));
@@ -355,11 +345,6 @@
         // ComputeElementLayout to force the computing of this element layout.
         GetWindowThread()->ComputeElementLayout(ic);
       }
-      else if (m_InterfaceObject[i]->Type().IsObjectType(InputArea::StaticObjectType))
-      {
-        InputArea *base_area = NUX_STATIC_CAST(InputArea *, m_InterfaceObject[i]);
-        base_area->SetGeometry(Geometry(accwidth, y, splitter_geo.x - accwidth, h));
-      }
       else if (m_InterfaceObject[i]->Type().IsDerivedFromType(Layout::StaticObjectType))
       {
         Layout *layout = NUX_STATIC_CAST(Layout *, m_InterfaceObject[i]);
@@ -562,10 +547,6 @@
         View *ic = NUX_STATIC_CAST(View *, (*it));
         ic->DoneRedraw();
       }
-      else if ((*it)->Type().IsObjectType(InputArea::StaticObjectType))
-      {
-        //InputArea* base_area = NUX_STATIC_CAST(InputArea*, (*it));
-      }
     }
   }
 

=== modified file 'Nux/VSplitter.h'
--- Nux/VSplitter.h	2011-10-21 22:06:35 +0000
+++ Nux/VSplitter.h	2012-09-18 19:02:35 +0000
@@ -80,7 +80,7 @@
 
   private:
 
-    typedef InputArea MySplitter;
+    typedef BasicView MySplitter;
     std::vector<Area *> m_InterfaceObject;
     std::vector<MySplitter *> m_SplitterObject;
     std::vector<float> m_SplitConfig;

=== modified file 'Nux/View.cpp'
--- Nux/View.cpp	2012-05-31 21:50:05 +0000
+++ Nux/View.cpp	2012-09-18 19:02:35 +0000
@@ -27,19 +27,25 @@
 
 namespace nux
 {
-
   NUX_IMPLEMENT_OBJECT_TYPE(View);
 
   View::View(NUX_FILE_LINE_DECL)
-    :   InputArea(NUX_FILE_LINE_PARAM)
+  : InputArea(NUX_FILE_LINE_PARAM)
+//   , redirect_rendering_to_texture_(false)
+//   , update_backup_texture_(false)
   {
-    view_layout_ = NULL;
-    draw_cmd_queued_        = false;
-    m_TextColor         = Color(1.0f, 1.0f, 1.0f, 1.0f);
+    view_layout_      = NULL;
+    draw_cmd_queued_  = false;
+    m_TextColor       = Color(1.0f, 1.0f, 1.0f, 1.0f);
   }
 
   View::~View()
   {
+    backup_fbo_.Release();
+    backup_texture_.Release();
+    backup_depth_texture_.Release();
+    background_texture_.Release();
+    
     // It is possible that the window thread has been deleted before the view
     // itself, so check prior to calling.
     WindowThread* wt = GetWindowThread();
@@ -157,46 +163,264 @@
   {
     full_view_draw_cmd_ = false;
 
-    graphics_engine.PushModelViewMatrix(Get2DMatrix());
-
-    if (force_draw)
+    if (RedirectRenderingToTexture())
     {
-      GetPainter().PaintBackground(graphics_engine, GetGeometry());
-      GetPainter().PushPaintLayerStack();
-
-      draw_cmd_queued_ = true;
-      full_view_draw_cmd_ = true;
-      Draw(graphics_engine, force_draw);
-      DrawContent(graphics_engine, force_draw);
-      PostDraw(graphics_engine, force_draw);
-
-      GetPainter().PopPaintLayerStack();
+      if (update_backup_texture_ || force_draw || draw_cmd_queued_)
+      {
+        GetPainter().PushPaintLayerStack();        
+        BeginBackupTextureRendering(graphics_engine, force_draw);
+        {
+          graphics_engine.PushModelViewMatrix(Get2DMatrix());
+
+          Geometry translated_geo = GetGeometry();
+          translated_geo.x = 0;
+          translated_geo.y = 0;
+          if (force_draw)
+          {
+            draw_cmd_queued_ = true;
+            full_view_draw_cmd_ = true;
+            Draw(graphics_engine, force_draw);
+            DrawContent(graphics_engine, force_draw);
+            PostDraw(graphics_engine, force_draw);
+          }
+          else
+          {
+            if (draw_cmd_queued_)
+            {
+              full_view_draw_cmd_ = true;
+              Draw(graphics_engine, false);
+              DrawContent(graphics_engine, false);
+              PostDraw(graphics_engine, false);
+            }
+            else if (update_backup_texture_)
+            {
+              DrawContent(graphics_engine, false);
+              PostDraw(graphics_engine, false);
+            }
+          }
+          graphics_engine.PopModelViewMatrix();
+        }
+        EndBackupTextureRendering(graphics_engine, force_draw);
+        GetPainter().PopPaintLayerStack();
+      }
+
+      if (PresentRedirectedView())
+      {
+        unsigned int current_alpha_blend;
+        unsigned int current_src_blend_factor;
+        unsigned int current_dest_blend_factor;
+        // Be a good citizen, get a copy of the current GPU sates according to Nux
+        graphics_engine.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+
+        TexCoordXForm texxform;
+
+        if ((force_draw || draw_cmd_queued_) && (background_texture_.IsValid()))
+        {
+          graphics_engine.GetRenderStates().SetBlend(false);
+          texxform.FlipVCoord(true);
+          // Draw the background of this view.
+          GetGraphicsDisplay()->GetGraphicsEngine()->QRP_1Tex(GetX(), GetY(), background_texture_->GetWidth(), background_texture_->GetHeight(), background_texture_, texxform, color::White);
+        }
+
+        texxform.uwrap = TEXWRAP_CLAMP;
+        texxform.vwrap = TEXWRAP_CLAMP;
+        texxform.FlipVCoord(true);
+
+        graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+        GetGraphicsDisplay()->GetGraphicsEngine()->QRP_1Tex(GetX(), GetY(), GetWidth(), GetHeight(), backup_texture_, texxform, Color(color::White));
+        // Be a good citizen, restore the Nux blending states.
+        graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+      }
     }
     else
     {
-      if (draw_cmd_queued_)
+      graphics_engine.PushModelViewMatrix(Get2DMatrix());
+
+      if (force_draw)
       {
         GetPainter().PaintBackground(graphics_engine, GetGeometry());
         GetPainter().PushPaintLayerStack();
 
+        draw_cmd_queued_ = true;
         full_view_draw_cmd_ = true;
-        Draw(graphics_engine, false);
-        DrawContent(graphics_engine, false);
-        PostDraw(graphics_engine, false);
+        Draw(graphics_engine, force_draw);
+        DrawContent(graphics_engine, force_draw);
+        PostDraw(graphics_engine, force_draw);
 
         GetPainter().PopPaintLayerStack();
       }
       else
       {
-        DrawContent(graphics_engine, false);
-        PostDraw(graphics_engine, false);
-      }
-    }
-
+        if (draw_cmd_queued_)
+        {
+          GetPainter().PaintBackground(graphics_engine, GetGeometry());
+          GetPainter().PushPaintLayerStack();
+
+          full_view_draw_cmd_ = true;
+          Draw(graphics_engine, false);
+          DrawContent(graphics_engine, false);
+          PostDraw(graphics_engine, false);
+
+          GetPainter().PopPaintLayerStack();
+        }
+        else
+        {
+          DrawContent(graphics_engine, false);
+          PostDraw(graphics_engine, false);
+        }
+      }
+
+      graphics_engine.PopModelViewMatrix();
+    }
+
+    if (view_layout_)
+    {
+      view_layout_->ResetQueueDraw();
+    }
+
+    draw_cmd_queued_ = false;
+    child_draw_cmd_queued_ = false;
+    full_view_draw_cmd_ = false;
+    update_backup_texture_ = false;
+  }
+
+  void View::BeginBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw)
+  {
+    ObjectPtr<IOpenGLBaseTexture> active_fbo_texture;
+    if (force_draw || draw_cmd_queued_)
+    {
+      // Get the active fbo color texture
+      active_fbo_texture = GetGraphicsDisplay()->GetGpuDevice()->ActiveFboTextureAttachment(0);
+    }
+
+    Geometry xform_geo;
+    // Compute position in the active fbo texture.
+    xform_geo = graphics_engine.ModelViewXFormRect(GetGeometry());
+
+    // Get the active fbo...
+    prev_fbo_ = GetGraphicsDisplay()->GetGpuDevice()->GetCurrentFrameBufferObject();
+    // ... and the size of the view port rectangle.
+    prev_viewport_ = graphics_engine.GetViewportRect();
+    
+    const int width = GetWidth();
+    const int height = GetHeight();
+
+    // Compute intersection with active fbo.
+    Geometry intersection = xform_geo;
+    if (active_fbo_texture.IsValid())
+    {
+      Geometry active_fbo_geo(0, 0, active_fbo_texture->GetWidth(), active_fbo_texture->GetHeight());
+      intersection = active_fbo_geo.Intersect(xform_geo);
+    }
+
+    if (backup_fbo_.IsNull())
+    {
+      // Create the fbo before using it for the first time.
+      backup_fbo_ = GetGraphicsDisplay()->GetGpuDevice()->CreateFrameBufferObject();
+    }
+
+    if (!backup_texture_.IsValid() || (backup_texture_->GetWidth() != width) || (backup_texture_->GetHeight() != height))
+    {
+      // Create or resize the color and depth textures before using them.
+      backup_texture_ = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(width, height, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
+      backup_depth_texture_ = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(width, height, 1, BITFMT_D24S8, NUX_TRACKER_LOCATION);
+    }
+
+    if (!background_texture_.IsValid() || (background_texture_->GetWidth() != intersection.width) || (background_texture_->GetHeight() != intersection.height))
+    {
+      background_texture_ = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(intersection.width, intersection.height, 1, BITFMT_R8G8B8A8, NUX_TRACKER_LOCATION);
+    }
+
+    backup_fbo_->FormatFrameBufferObject(width, height, BITFMT_R8G8B8A8);
+    backup_fbo_->EmptyClippingRegion();
+
+    graphics_engine.SetViewport(0, 0, width, height);
+    graphics_engine.SetOrthographicProjectionMatrix(width, height);
+
+    // Draw the background on the previous fbo texture
+    if ((force_draw || draw_cmd_queued_) && background_texture_.IsValid())
+    {
+      backup_fbo_->FormatFrameBufferObject(intersection.width, intersection.height, BITFMT_R8G8B8A8);
+      backup_fbo_->EmptyClippingRegion();
+
+      graphics_engine.SetViewport(0, 0, intersection.width, intersection.height);
+      graphics_engine.SetOrthographicProjectionMatrix(intersection.width, intersection.height);
+
+      // Set the background texture in the fbo
+      backup_fbo_->SetTextureAttachment(0, background_texture_, 0);
+      backup_fbo_->SetDepthTextureAttachment(ObjectPtr<IOpenGLBaseTexture>(0), 0);
+      backup_fbo_->Activate();
+      graphics_engine.SetViewport(0, 0, background_texture_->GetWidth(), background_texture_->GetHeight());
+      
+      // Clear surface
+      // Clear surface
+      CHECKGL(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
+      CHECKGL(glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT));
+
+      TexCoordXForm texxform;
+      texxform.uoffset = xform_geo.x / (float) active_fbo_texture->GetWidth();
+      texxform.voffset = xform_geo.y / (float) active_fbo_texture->GetHeight();
+      texxform.SetTexCoordType(TexCoordXForm::OFFSET_COORD);
+      texxform.flip_v_coord = true;
+
+      // Temporarily change the model-view matrix to copy the texture background texture.
+      // This way we are not affceted by the regular model-view matrix.
+      graphics_engine.SetModelViewMatrix(Matrix4::IDENTITY());
+      // Copy the texture from the previous fbo attachment into our background texture.
+      if (copy_previous_fbo_for_background_)
+      {
+        graphics_engine.QRP_1Tex(0, 0, intersection.width, intersection.height, active_fbo_texture, texxform, color::White);
+      }
+      else
+      {
+        graphics_engine.QRP_Color(0, 0, intersection.width, intersection.height, Color(0.0f, 0.0f, 0.0f, 0.0f));
+      }
+      // Restore the model-view matrix.
+      graphics_engine.ApplyModelViewMatrix();
+    }
+
+    backup_fbo_->FormatFrameBufferObject(width, height, BITFMT_R8G8B8A8);
+    backup_fbo_->EmptyClippingRegion();
+    backup_fbo_->SetTextureAttachment(0, backup_texture_, 0);
+    backup_fbo_->SetDepthTextureAttachment(backup_depth_texture_, 0);
+    backup_fbo_->Activate();
+
+    if (force_draw || draw_cmd_queued_)
+    {
+      CHECKGL(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
+      CHECKGL(glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT));
+    }
+
+    graphics_engine.SetViewport(0, 0, width, height);
+    graphics_engine.SetOrthographicProjectionMatrix(width, height);
+    // Transform the geometry of this area through the current model view matrix. This gives the
+    // the position of the view in the active fbo texture.
+    Geometry offset_rect = graphics_engine.ModelViewXFormRect(GetGeometry());
+    int x_offset = -offset_rect.x;
+    int y_offset = -offset_rect.y;
+    graphics_engine.PushModelViewMatrix(Matrix4::TRANSLATE(x_offset, y_offset, 0));
+
+  }
+
+  void View::EndBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw)
+  {
     graphics_engine.PopModelViewMatrix();
 
-    draw_cmd_queued_ = false;
-    full_view_draw_cmd_ = false;
+    if (prev_fbo_.IsValid())
+    {
+      // Restore the previous fbo
+      prev_fbo_->Activate();
+
+      prev_fbo_->ApplyClippingRegion();
+    }
+
+    // Release the reference on the previous fbo
+    prev_fbo_.Release();
+
+    // Restore the matrices and the view port.
+    graphics_engine.ApplyModelViewMatrix();
+    graphics_engine.SetOrthographicProjectionMatrix(prev_viewport_.width, prev_viewport_.height);
+    graphics_engine.SetViewport(prev_viewport_.x, prev_viewport_.y, prev_viewport_.width, prev_viewport_.height);
   }
 
   void View::Draw(GraphicsEngine &graphics_engine, bool force_draw)
@@ -219,19 +443,26 @@
     if (draw_cmd_queued_)
       return;
 
-    //GetWindowCompositor()..AddToDrawList(this);
     WindowThread* application = GetWindowThread();
     if (application)
     {
       application->AddToDrawList(this);
       application->RequestRedraw();
-      //GetWindowCompositor().AddToDrawList(this);
     }
+    
+    // Report to a parent view with redirect_rendering_to_texture_ set to true that one of its children
+    // needs to be redrawn.
+    PrepareParentRedirectedView();
+
     if (view_layout_)
+    {
+      // If this view has requested a draw, then all of it children in the view_layout_
+      // need to be redrawn as well.
       view_layout_->QueueDraw();
+    }
 
     draw_cmd_queued_ = true;
-    OnQueueDraw.emit(this);
+    queue_draw.emit(this);
   }
 
   void View::NeedSoftRedraw()
@@ -310,9 +541,19 @@
 
     LayoutAdded.emit(this, view_layout_);
 
+    view_layout_->queue_draw.connect(sigc::mem_fun(this, &View::ChildViewQueuedDraw));
+    view_layout_->child_queue_draw.connect(sigc::mem_fun(this, &View::ChildViewQueuedDraw));
     return true;
   }
 
+  void View::ChildViewQueuedDraw(Area* area)
+  {
+    if (child_draw_cmd_queued_)
+      return;
+    child_draw_cmd_queued_ = true;
+    child_queue_draw.emit(area);
+  }
+
   void View::OnChildFocusChanged(/*Area *parent,*/ Area *child)
   {
     ChildFocusChanged.emit(/*parent,*/ child);
@@ -354,9 +595,16 @@
     return false;
   }
 
-  void View::SetGeometry(const Geometry &geo)
+//   void View::SetGeometry(int x, int y, int w, int h)
+//   {
+//     Area::SetGeometry(x, y, w, h);
+//     ComputeContentSize();
+//     PostResizeGeometry();
+//   }
+
+  void View::SetGeometry(const Geometry& geo)
   {
-    Area::SetGeometry(geo);
+    Area::SetGeometry(geo.x, geo.y, geo.width, geo.height);
     ComputeContentSize();
     PostResizeGeometry();
   }
@@ -410,14 +658,20 @@
     return view_enabled_;
   }
 
-  void View::GeometryChangePending()
+  void View::GeometryChangePending(bool position_about_to_change, bool size_about_to_change)
   {
     if (IsLayoutDone())
       QueueDraw();
   }
 
-  void View::GeometryChanged()
+  void View::GeometryChanged(bool position_has_changed, bool size_has_changed)
   {
+    if (RedirectedAncestor())
+    {
+      if (size_has_changed)
+        QueueDraw();
+      return;
+    }
     if (IsLayoutDone())
       QueueDraw();
   }

=== modified file 'Nux/View.h'
--- Nux/View.h	2012-05-31 21:50:05 +0000
+++ Nux/View.h	2012-09-18 19:02:35 +0000
@@ -23,7 +23,6 @@
 #ifndef ABSTRACTOBJECTBASE_H
 #define ABSTRACTOBJECTBASE_H
 
-#include "Features.h"
 #include "Nux.h"
 #include "NuxCore/Property.h"
 
@@ -48,7 +47,6 @@
     /*
         If ComputeContentSize is called while outside of the layout process (\sa IsInsideLayoutCycle) then the parents of 
         this object maybe added to the layout queue if this view size changes. \sa Area::ReconfigureParentLayout.
-
     */
     virtual long ComputeContentSize();
     virtual void ComputeContentPosition(float offsetX, float offsetY);
@@ -85,7 +83,7 @@
     virtual void ProcessDraw(GraphicsEngine &graphics_engine, bool force_draw);
     //! Causes a redraw. The widget parameter draw_cmd_queued_ is set to true. The widget Draw(), DrawContent() and PostDraw() are called.
     /*!
-        Emits the signal \i OnQueueDraw.
+        Emits the signal \i queue_draw.
     */
     virtual void QueueDraw();
 
@@ -101,6 +99,9 @@
     bool SearchInAllSubNodes(Area *bo);
     bool SearchInFirstSubNodes(Area *bo);
 
+    
+/*    void SetGeometry(int x, int y, int w, int h);*/
+
     //! Set Geometry
     /*
         Set the Geometry of the View and the geometry of the Default Background Area.
@@ -144,18 +145,28 @@
     void SetFont(ObjectPtr<FontTexture> font);
     ObjectPtr<FontTexture> GetFont();
 
-    sigc::signal<void, View*> OnQueueDraw;  //!< Signal emitted when a view is scheduled for a draw.
+    sigc::signal<void, View*> queue_draw;       //!< Signal emitted when a view is scheduled for a draw.
+    sigc::signal<void, Area*> child_queue_draw; //!< Signal emitted when a child of this view is scheduled for a draw.
 
     virtual Area* KeyNavIteration(KeyNavDirection direction);
     virtual bool AcceptKeyNavFocus();
 
-    void IsHitDetectionSkipingChildren(bool skip_children);
+    virtual Area* FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type);
+
+    virtual Area* FindKeyFocusArea(unsigned int key_symbol,
+      unsigned long x11_key_code,
+      unsigned long special_keys_state);
 
 #ifdef NUX_GESTURES_SUPPORT
     virtual Area* GetInputAreaHitByGesture(const nux::GestureEvent &event);
 #endif
 
   protected:
+    virtual void ChildViewQueuedDraw(Area* area);
+
+    void BeginBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw);
+
+    void EndBackupTextureRendering(GraphicsEngine& graphics_engine, bool force_draw);
 
     void OnChildFocusChanged(/*Area *parent,*/ Area *child);
     sigc::connection _on_focus_changed_handler;
@@ -191,18 +202,13 @@
     */
     bool IsFullRedraw() const;
 
-    virtual void GeometryChangePending();
-    virtual void GeometryChanged();
-
-    virtual Area* FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type);
-
-    virtual Area* FindKeyFocusArea(unsigned int key_symbol,
-                          unsigned long x11_key_code,
-                          unsigned long special_keys_state);
+    virtual void GeometryChangePending(bool position_about_to_change, bool size_about_to_change);
+    virtual void GeometryChanged(bool position_has_changed, bool size_has_changed);
 
     Layout *view_layout_;
 
     bool draw_cmd_queued_; //<! The rendering of the view needs to be refreshed.
+    bool child_draw_cmd_queued_; //<! A child of this view has requested a draw.
 
     bool full_view_draw_cmd_; //<! True if Draw is called before ContentDraw. It is read-only and can be accessed by calling IsFullRedraw();
 
@@ -213,8 +219,10 @@
     friend class Layout;
     friend class Area;
     friend class LayeredLayout;
+    friend class Canvas;
+    friend class VSplitter;
+    friend class HSplitter;
   };
-
 }
 
 #endif // ABSTRACTOBJECTBASE_H

=== modified file 'Nux/WindowCompositor.cpp'
--- Nux/WindowCompositor.cpp	2012-09-18 19:02:34 +0000
+++ Nux/WindowCompositor.cpp	2012-09-18 19:02:35 +0000
@@ -1428,8 +1428,8 @@
             }
 
             m_FrameBufferObject->FormatFrameBufferObject(buffer_width, buffer_height, BITFMT_R8G8B8A8);
-            m_FrameBufferObject->SetRenderTarget( 0, rt.color_rt->GetSurfaceLevel(0));
-            m_FrameBufferObject->SetDepthSurface( rt.depth_rt->GetSurfaceLevel(0));
+            m_FrameBufferObject->SetTextureAttachment(0, rt.color_rt, 0);
+            m_FrameBufferObject->SetDepthTextureAttachment(rt.depth_rt, 0);
             m_FrameBufferObject->Activate();
             graphics_engine.SetViewport(0, 0, buffer_width, buffer_height);
             graphics_engine.SetOrthographicProjectionMatrix(buffer_width, buffer_height);
@@ -1496,8 +1496,8 @@
     }
 
     m_FrameBufferObject->FormatFrameBufferObject(buffer_width, buffer_height, BITFMT_R8G8B8A8);
-    m_FrameBufferObject->SetRenderTarget(0, m_MainColorRT->GetSurfaceLevel(0));
-    m_FrameBufferObject->SetDepthSurface(m_MainDepthRT->GetSurfaceLevel(0));
+    m_FrameBufferObject->SetTextureAttachment(0, m_MainColorRT, 0);
+    m_FrameBufferObject->SetDepthTextureAttachment(m_MainDepthRT, 0);
     m_FrameBufferObject->Activate();
 
     window_thread_->GetGraphicsEngine().EmptyClippingRegion();
@@ -1573,8 +1573,8 @@
       nuxAssert(m_MainColorRT->GetWidth() == window_width);
       nuxAssert(m_MainColorRT->GetHeight() == window_height);
       m_FrameBufferObject->FormatFrameBufferObject(window_width, window_height, BITFMT_R8G8B8A8);
-      m_FrameBufferObject->SetRenderTarget( 0, m_MainColorRT->GetSurfaceLevel(0));
-      m_FrameBufferObject->SetDepthSurface( m_MainDepthRT->GetSurfaceLevel(0));
+      m_FrameBufferObject->SetTextureAttachment(0, m_MainColorRT, 0);
+      m_FrameBufferObject->SetDepthTextureAttachment(m_MainDepthRT, 0);
       m_FrameBufferObject->Activate();
     }
     else
@@ -1923,8 +1923,8 @@
 
     // Clear the buffer the first time...
     m_FrameBufferObject->FormatFrameBufferObject(buffer_width, buffer_height, BITFMT_R8G8B8A8);
-    m_FrameBufferObject->SetRenderTarget(0, m_MainColorRT->GetSurfaceLevel(0));
-    m_FrameBufferObject->SetDepthSurface(m_MainDepthRT->GetSurfaceLevel(0));
+    m_FrameBufferObject->SetTextureAttachment(0, m_MainColorRT, 0);
+    m_FrameBufferObject->SetDepthTextureAttachment(m_MainDepthRT, 0);
     m_FrameBufferObject->Activate();
 
     CHECKGL(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
@@ -1966,8 +1966,8 @@
       }
 
       m_FrameBufferObject->FormatFrameBufferObject(buffer_width, buffer_height, BITFMT_R8G8B8A8);
-      m_FrameBufferObject->SetRenderTarget(0, rt.color_rt->GetSurfaceLevel(0));
-      m_FrameBufferObject->SetDepthSurface(rt.depth_rt->GetSurfaceLevel(0));
+      m_FrameBufferObject->SetTextureAttachment(0, rt.color_rt, 0);
+      m_FrameBufferObject->SetDepthTextureAttachment(rt.depth_rt, 0);
       m_FrameBufferObject->Activate();
 
       window_thread_->GetGraphicsEngine().SetViewport(0, 0, buffer_width, buffer_height);
@@ -1984,8 +1984,8 @@
       nuxAssert(buffer_height >= 1);
       // Restore Main Frame Buffer
       m_FrameBufferObject->FormatFrameBufferObject(buffer_width, buffer_height, BITFMT_R8G8B8A8);
-      m_FrameBufferObject->SetRenderTarget(0, m_MainColorRT->GetSurfaceLevel(0));
-      m_FrameBufferObject->SetDepthSurface(m_MainDepthRT->GetSurfaceLevel(0));
+      m_FrameBufferObject->SetTextureAttachment(0, m_MainColorRT, 0);
+      m_FrameBufferObject->SetDepthTextureAttachment(m_MainDepthRT, 0);
       m_FrameBufferObject->Activate();
 
       window_thread_->GetGraphicsEngine().SetViewport(0, 0, buffer_width, buffer_height);

=== modified file 'Nux/WindowCompositor.h'
--- Nux/WindowCompositor.h	2012-09-18 19:02:34 +0000
+++ Nux/WindowCompositor.h	2012-09-18 19:02:35 +0000
@@ -23,7 +23,6 @@
 #ifndef WINDOWCOMPOSITOR_H
 #define WINDOWCOMPOSITOR_H
 
-#include "Features.h"
 #include "BaseWindow.h"
 
 #include <sigc++/trackable.h>

=== modified file 'Nux/WindowThread.cpp'
--- Nux/WindowThread.cpp	2012-08-02 17:46:47 +0000
+++ Nux/WindowThread.cpp	2012-09-18 19:02:35 +0000
@@ -19,7 +19,6 @@
  *
  */
 
-#include "Features.h"
 #include "Nux.h"
 #include "Layout.h"
 #include "NuxCore/Logger.h"

=== modified file 'Nux/WindowThread.h'
--- Nux/WindowThread.h	2012-05-31 21:40:37 +0000
+++ Nux/WindowThread.h	2012-09-18 19:02:35 +0000
@@ -24,7 +24,6 @@
 #define WINDOWTHREAD_H
 
 #include "TimerProc.h"
-#include "Features.h"
 
 #ifdef NUX_GESTURES_SUPPORT
 #include "GeisAdapter.h"

=== modified file 'NuxCore/Animation.cpp'
--- NuxCore/Animation.cpp	2012-07-13 04:58:08 +0000
+++ NuxCore/Animation.cpp	2012-09-18 19:02:35 +0000
@@ -20,8 +20,9 @@
  *
  */
 
-#include <Animation.h>
-#include <AnimationController.h>
+#include "NuxCore.h"
+#include "Animation.h"
+#include "AnimationController.h"
 
 namespace na = nux::animation;
 

=== modified file 'NuxCore/AnimationController.cpp'
--- NuxCore/AnimationController.cpp	2012-07-13 04:58:08 +0000
+++ NuxCore/AnimationController.cpp	2012-09-18 19:02:35 +0000
@@ -20,6 +20,7 @@
  *
  */
 
+#include "NuxCore.h"
 #include "AnimationController.h"
 #include "Animation.h"
 

=== modified file 'NuxCore/AnimationController.h'
--- NuxCore/AnimationController.h	2012-07-12 23:55:40 +0000
+++ NuxCore/AnimationController.h	2012-09-18 19:02:35 +0000
@@ -59,8 +59,13 @@
   virtual void RemoveAnimation(Animation* animation) = 0;
 
 private:
+#if defined(NUX_OS_WINDOWS) && !defined(NUX_VISUAL_STUDIO_VC11)
+  Controller(Controller const&);
+  Controller& operator = (Controller const&);
+#else
   Controller(Controller const&) = delete;
-  Controller& operator=(Controller const&) = delete;
+  Controller& operator = (Controller const&) = delete;
+#endif
 };
 
 class AnimationController : public Controller, public sigc::trackable

=== modified file 'NuxCore/Color.cpp'
--- NuxCore/Color.cpp	2012-05-24 18:08:18 +0000
+++ NuxCore/Color.cpp	2012-09-18 19:02:35 +0000
@@ -139,7 +139,7 @@
     return (((std::rand() % 255) << 24) |
             ((std::rand() % 255) << 16) |
             ((std::rand() % 255) << 8) |
-            (std::rand() % 255));
+            (255));
   }
 
   Color operator + (Color const& lhs, Color const& rhs)

=== modified file 'NuxCore/EasingCurve.cpp'
--- NuxCore/EasingCurve.cpp	2012-07-17 04:01:54 +0000
+++ NuxCore/EasingCurve.cpp	2012-09-18 19:02:35 +0000
@@ -20,6 +20,7 @@
  *
  */
 
+#include "NuxCore.h"
 #include "EasingCurve.h"
 
 namespace na = nux::animation;
@@ -122,6 +123,15 @@
   return in_out(progress, bounce_out);
 }
 
+double expo_ease_in(double progress)
+{
+  return (progress == 0) ? 0.0 : 1.0 * std::pow (2, 10 * (progress / 1.0 - 1) ) + 0.0;
+}
+
+double expo_ease_out(double progress)
+{
+  return reverse(progress, expo_ease_in);
+}
 
 na::EasingCurve::EasingFunction GetEasingFunction(na::EasingCurve::Type type)
 {
@@ -145,6 +155,10 @@
     return bounce_out;
   case na::EasingCurve::Type::BounceInOut:
     return bounce_in_out;
+  case na::EasingCurve::Type::ExpoEaseIn:
+    return expo_ease_in;
+  case na::EasingCurve::Type::ExpoEaseOut:
+    return expo_ease_out;
   case na::EasingCurve::Type::Linear:
   default:
     return linear;

=== modified file 'NuxCore/EasingCurve.h'
--- NuxCore/EasingCurve.h	2012-07-17 04:01:54 +0000
+++ NuxCore/EasingCurve.h	2012-09-18 19:02:35 +0000
@@ -31,7 +31,11 @@
 class EasingCurve
 {
 public:
+#if defined(NUX_OS_WINDOWS) && !defined(NUX_VISUAL_STUDIO_VC11)
+  enum Type
+#else
   enum class Type
+#endif
   {
     Linear,
     InQuad,
@@ -43,6 +47,8 @@
     BounceIn,
     BounceOut,
     BounceInOut,
+    ExpoEaseIn,
+    ExpoEaseOut
   };
 
   typedef double (*EasingFunction)(double);

=== modified file 'NuxGraphics/GLWindowManager.cpp'
--- NuxGraphics/GLWindowManager.cpp	2011-10-19 20:32:38 +0000
+++ NuxGraphics/GLWindowManager.cpp	2012-09-18 19:02:35 +0000
@@ -99,7 +99,7 @@
   GraphicsDisplay *DisplayAccessController::CreateGLWindow(const char *WindowTitle, unsigned int WindowWidth, unsigned int WindowHeight,
                                                            WindowStyle Style,
                                                            GraphicsDisplay *GLWindow,
-                                                           bool FullscreenFlag,
+                                                           bool fullscreen_flag,
                                                            bool create_rendering_data)
   {
     if (GetGraphicsDisplay())
@@ -110,7 +110,7 @@
     }
 
     GraphicsDisplay *glwindow = new GraphicsDisplay();
-    glwindow->CreateOpenGLWindow(WindowTitle, WindowWidth, WindowHeight, Style, GLWindow, FullscreenFlag, create_rendering_data);
+    glwindow->CreateOpenGLWindow(WindowTitle, WindowWidth, WindowHeight, Style, GLWindow, fullscreen_flag, create_rendering_data);
 
     return glwindow;
   }

=== modified file 'NuxGraphics/GLWindowManager.h'
--- NuxGraphics/GLWindowManager.h	2011-10-19 20:32:38 +0000
+++ NuxGraphics/GLWindowManager.h	2012-09-18 19:02:35 +0000
@@ -49,12 +49,12 @@
       @param WindowHeight Window height.
       @param Style Window style.
       @param parent The parent window.
-      @param FullscreenFlag True to create a full screen window.
+      @param fullscreen_flag True to create a full screen window.
       @param create_rendering_data If true, then in GraphicsEngine, the system creates the OpenGL shaders and the font textures for the rendering.
     */
     GraphicsDisplay *CreateGLWindow(const char *WindowTitle, unsigned int WindowWidth, unsigned int WindowHeight, WindowStyle Style,
       GraphicsDisplay *parent,
-      bool FullscreenFlag = false,
+      bool fullscreen_flag = false,
       bool create_rendering_data = true);
 
 #if defined(NUX_OS_WINDOWS)

=== modified file 'NuxGraphics/GpuDevice.cpp'
--- NuxGraphics/GpuDevice.cpp	2012-04-10 21:14:18 +0000
+++ NuxGraphics/GpuDevice.cpp	2012-09-18 19:02:35 +0000
@@ -622,7 +622,7 @@
     NUX_SAFE_DELETE(_gpu_render_states);
 
     _FrameBufferObject.Release();
-    _CurrentFrameBufferObject.Release();
+    active_framebuffer_object_.Release();
 
     _PixelBufferArray.clear();
 
@@ -916,12 +916,30 @@
 
   void GpuDevice::SetCurrentFrameBufferObject(ObjectPtr<IOpenGLFrameBufferObject> fbo)
   {
-    _CurrentFrameBufferObject = fbo;
+    active_framebuffer_object_ = fbo;
   }
 
   ObjectPtr<IOpenGLFrameBufferObject> GpuDevice::GetCurrentFrameBufferObject()
   {
-    return _CurrentFrameBufferObject;
+    return active_framebuffer_object_;
+  }
+
+  ObjectPtr<IOpenGLBaseTexture> GpuDevice::ActiveFboTextureAttachment(int color_attachment_index)
+  {
+    if (active_framebuffer_object_.IsValid())
+    {
+      return active_framebuffer_object_->TextureAttachment(color_attachment_index);
+    }
+    return ObjectPtr<IOpenGLBaseTexture>(0);
+  }
+
+  ObjectPtr<IOpenGLBaseTexture> GpuDevice::ActiveFboDepthTextureAttachment()
+  {
+    if (active_framebuffer_object_.IsValid())
+    {
+      return active_framebuffer_object_->DepthTextureAttachment();
+    }
+    return ObjectPtr<IOpenGLBaseTexture>(0);
   }
 
   void GpuDevice::DeactivateFrameBuffer()
@@ -932,7 +950,7 @@
       return;
     }
 
-    _CurrentFrameBufferObject.Release();
+    active_framebuffer_object_.Release();
     CHECKGL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
     CHECKGL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
   }
@@ -944,6 +962,11 @@
     , BitmapFormat PixelFormat
     , NUX_FILE_LINE_DECL)
   {
+    if ((Width <= 0) || (Height <= 0))
+    {
+      return ObjectPtr<IOpenGLBaseTexture>(0);
+    }
+
     if (GetGpuInfo().Support_ARB_Texture_Non_Power_Of_Two())
     {
       return CreateTexture(Width, Height, Levels, PixelFormat, NUX_FILE_LINE_PARAM);

=== modified file 'NuxGraphics/GpuDevice.h'
--- NuxGraphics/GpuDevice.h	2011-12-06 16:29:06 +0000
+++ NuxGraphics/GpuDevice.h	2012-09-18 19:02:35 +0000
@@ -328,6 +328,12 @@
     ObjectPtr<IOpenGLVertexDeclaration> CreateVertexDeclaration(
       const VERTEXELEMENT *pVertexElements);
 
+    //! Create an return an ObjectPtr that encapsulates OpenGL framebuffer object.
+    /*!
+        Create an return an ObjectPtr that encapsulates OpenGL framebuffer object.
+        This function has side effects. It will change the framebuffer object that 
+        is set in the GPU. 
+    */
     ObjectPtr<IOpenGLFrameBufferObject> CreateFrameBufferObject();
 
     ObjectPtr<IOpenGLShaderProgram> CreateShaderProgram();
@@ -412,13 +418,16 @@
   public:
     void SetCurrentFrameBufferObject(ObjectPtr<IOpenGLFrameBufferObject> fbo);
     ObjectPtr<IOpenGLFrameBufferObject> GetCurrentFrameBufferObject();
+    ObjectPtr<IOpenGLBaseTexture> ActiveFboTextureAttachment(int color_attachment_index);
+    ObjectPtr<IOpenGLBaseTexture> ActiveFboDepthTextureAttachment();
+
 
     int GetOpenGLMajorVersion() const;
     int GetOpenGLMinorVersion() const;
   private:
     // Default FrameBufferobject
     ObjectPtr<IOpenGLFrameBufferObject> _FrameBufferObject;
-    ObjectPtr<IOpenGLFrameBufferObject> _CurrentFrameBufferObject;
+    ObjectPtr<IOpenGLFrameBufferObject> active_framebuffer_object_;
 
     struct PixelBufferObject
     {

=== modified file 'NuxGraphics/GpuDeviceTexture.cpp'
--- NuxGraphics/GpuDeviceTexture.cpp	2011-10-22 06:17:42 +0000
+++ NuxGraphics/GpuDeviceTexture.cpp	2012-09-18 19:02:35 +0000
@@ -56,6 +56,12 @@
     , NUX_FILE_LINE_DECL
     )
   {
+    if ((Width <= 0) || (Height <= 0))
+    {
+      *ppTexture = NULL;
+      return 0;
+    }
+
     // From : http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_non_power_of_two.txt
     //    The "floor" convention has a relatively straightforward way to
     //        evaluate(with integer math) means to determine how many mipmap
@@ -135,6 +141,11 @@
     , NUX_FILE_LINE_DECL
     )
   {
+    if ((Width <= 0) || (Height <= 0))
+    {
+      *ppTexture = NULL;
+      return 0;
+    }
 
     // From : http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_non_power_of_two.txt
     //    The "floor" convention has a relatively straightforward way to

=== modified file 'NuxGraphics/GraphicsDisplayWin.cpp'
--- NuxGraphics/GraphicsDisplayWin.cpp	2012-08-02 17:46:47 +0000
+++ NuxGraphics/GraphicsDisplayWin.cpp	2012-09-18 19:02:35 +0000
@@ -105,20 +105,17 @@
   HDC   GraphicsDisplay::sMainDC = 0;
 
   GraphicsDisplay::GraphicsDisplay()
-    : event_(NULL)
-    , m_GfxInterfaceCreated(false)
-    , m_fullscreen(false)
-    , m_ScreenBitDepth(32)
-    , m_num_device_modes(0)
-    , m_index_of_current_mode(-1)
+    : gfx_interface_created_(false)
+    , fullscreen_(false)
+    , screen_bit_depth_(32)
     , m_DeviceFactory(0)
     , m_GraphicsContext(0)
     , m_Style(WINDOWSTYLE_NORMAL)
     , cursor_(0)
     , m_PauseGraphicsRendering(false)
-    , m_ParentWindow(0)
-    , m_dwExStyle(0)
-    , m_dwStyle(0)
+    , parent_window_(0)
+    , window_extended_style_(0)
+    , window_style_(0)
     , device_context_(NULL)
     , wnd_handle_(NULL)
   {
@@ -149,15 +146,14 @@
 
     inlSetThreadLocalStorage(_TLS_GraphicsDisplay, this);
 
-    m_GfxInterfaceCreated = false;
-    event_ = new Event();
+    gfx_interface_created_ = false;
     GetDisplayInfo();
 
-    m_WindowSize.width = 0;
-    m_WindowSize.height = 0;
+    window_size_.width = 0;
+    window_size_.height = 0;
 
     // A window never starts in a minimized state.
-    m_is_window_minimized = false;
+    window_minimized_ = false;
 
     //_dnd_source_grab_active = false;
     _global_keyboard_grab_data = 0;
@@ -171,11 +167,7 @@
     NUX_SAFE_DELETE( m_GraphicsContext );
     NUX_SAFE_DELETE( m_DeviceFactory );
 
-//     NUX_SAFE_DELETE( m_WGLEWContext );
-//     NUX_SAFE_DELETE( m_GLEWContext );
-
     DestroyOpenGLWindow();
-    NUX_SAFE_DELETE( event_ );
 
     inlSetThreadLocalStorage(_TLS_GraphicsDisplay, 0);
 
@@ -216,7 +208,7 @@
 //---------------------------------------------------------------------------------------------------------
   bool GraphicsDisplay::IsGfxInterfaceCreated()
   {
-    return m_GfxInterfaceCreated;
+    return gfx_interface_created_;
   }
 
 //---------------------------------------------------------------------------------------------------------
@@ -226,45 +218,42 @@
                                          unsigned int WindowHeight,
                                          WindowStyle Style,
                                          const GraphicsDisplay *Parent,
-                                         bool FullscreenFlag,
+                                         bool fullscreen_flag,
                                          bool create_rendering_data)
   {
     NScopeLock Scope(&CreateOpenGLWindow_CriticalSection);
 
     RECT		WindowRect;				// Grabs Rectangle Upper Left / Lower Right Values
 
-    m_GfxInterfaceCreated = false;
+    gfx_interface_created_ = false;
 
     // FIXME : put at the end
-    m_ViewportSize.width = WindowWidth;
-    m_ViewportSize.height = WindowHeight;
-    m_WindowSize.width = WindowWidth;
-    m_WindowSize.height = WindowHeight;
+    viewport_size_.width = WindowWidth;
+    viewport_size_.height = WindowHeight;
+    window_size_.width = WindowWidth;
+    window_size_.height = WindowHeight;
 
     // end of fixme
 
     WindowRect.left     = (long) 0;
-    WindowRect.right    = (long) m_ViewportSize.width;
+    WindowRect.right    = (long) viewport_size_.width;
     WindowRect.top      = (long) 0;
-    WindowRect.bottom   = (long) m_ViewportSize.height;
-
-    m_fullscreen = FullscreenFlag;              // Set The Global Fullscreen Flag
-    m_index_of_current_mode = -1;               // assume -1 if the mode is not fullscreen
-
-
-    if (m_fullscreen)                           // Attempt Fullscreen Mode?
+    WindowRect.bottom   = (long) viewport_size_.height;
+
+    fullscreen_ = fullscreen_flag;              // Set The Global Fullscreen Flag
+
+    if (fullscreen_)                           // Attempt Fullscreen Mode?
     {
       // check if resolution is supported
       bool mode_supported = false;
 
       for (int num_modes = 0 ; num_modes < m_num_gfx_device_modes; num_modes++)
       {
-        if ((m_gfx_device_modes[num_modes].width == m_ViewportSize.width)
-             && (m_gfx_device_modes[num_modes].height == m_ViewportSize.height)
-             && (m_gfx_device_modes[num_modes].format == m_ScreenBitDepth))
+        if ((m_gfx_device_modes[num_modes].width == viewport_size_.width)
+             && (m_gfx_device_modes[num_modes].height == viewport_size_.height)
+             && (m_gfx_device_modes[num_modes].format == screen_bit_depth_))
         {
           mode_supported = true;
-          m_index_of_current_mode = num_modes;
           break;
         }
       }
@@ -274,16 +263,16 @@
         if (inlWin32MessageBox(NULL, "Info", MBTYPE_Ok, MBICON_Information, MBMODAL_ApplicationModal,
                                 "The requested fullscreen mode is not supported by your monitor.\nUsing windowed mode instead.") == MBRES_Yes)
         {
-          m_fullscreen = FALSE;   // Windowed Mode Selected.  Fullscreen = FALSE
+          fullscreen_ = FALSE;   // Windowed Mode Selected.  Fullscreen = FALSE
         }
       }
 
       DEVMODE dmScreenSettings;                                               // Device Mode
       memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));	              // Makes Sure Memory's Cleared
       dmScreenSettings.dmSize = sizeof(dmScreenSettings);                    // Size Of The Devmode Structure
-      dmScreenSettings.dmPelsWidth	= m_ViewportSize.width;                   // Selected Screen Width
-      dmScreenSettings.dmPelsHeight	= m_ViewportSize.height;                  // Selected Screen Height
-      dmScreenSettings.dmBitsPerPel	= m_ScreenBitDepth;                              // Selected Bits Per Pixel
+      dmScreenSettings.dmPelsWidth	= viewport_size_.width;                   // Selected Screen Width
+      dmScreenSettings.dmPelsHeight	= viewport_size_.height;                  // Selected Screen Height
+      dmScreenSettings.dmBitsPerPel	= screen_bit_depth_;                              // Selected Bits Per Pixel
       dmScreenSettings.dmDisplayFrequency = 60;
       dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
 
@@ -293,7 +282,7 @@
         if (inlWin32MessageBox(NULL, "Info", MBTYPE_Ok, MBICON_Information, MBMODAL_ApplicationModal,
                                 "The requested fullscreen mode is not supported by your monitor.\nUsing windowed mode instead.") == MBRES_Yes)
         {
-          m_fullscreen = FALSE;                   // Windowed Mode Selected.  Fullscreen = FALSE
+          fullscreen_ = FALSE;                   // Windowed Mode Selected.  Fullscreen = FALSE
         }
         else
         {
@@ -303,21 +292,21 @@
       }
     }
 
-    m_dwExStyle = 0;
-    m_dwStyle = 0;
+    window_extended_style_ = 0;
+    window_style_ = 0;
 
-    if (m_fullscreen)                                   // Are We Still In Fullscreen Mode?
+    if (fullscreen_)                                   // Are We Still In Fullscreen Mode?
     {
-      m_dwExStyle = WS_EX_APPWINDOW;                    // Window Extended Style
-      m_dwStyle = WS_POPUP;                             // Windows Style
+      window_extended_style_ = WS_EX_APPWINDOW;                    // Window Extended Style
+      window_style_ = WS_POPUP;                             // Windows Style
       ShowCursor(FALSE);                              // Hide Mouse Pointer
     }
     else
     {
       // Window Extended Style
-      m_dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
+      window_extended_style_ = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
       // Windows Style
-      m_dwStyle = WS_OVERLAPPED;    // Creates an overlapped window. An overlapped window has a title bar and a border
+      window_style_ = WS_OVERLAPPED;    // Creates an overlapped window. An overlapped window has a title bar and a border
 
       // See Win32 Window Hierarchy and Styles: http://msdn.microsoft.com/en-us/library/ms997562.aspx
 
@@ -333,31 +322,31 @@
 
       if (Style == WINDOWSTYLE_TOOL)
       {
-        m_dwExStyle = WS_EX_TOOLWINDOW;
-        m_dwStyle = WS_CAPTION | WS_SYSMENU;
+        window_extended_style_ = WS_EX_TOOLWINDOW;
+        window_style_ = WS_CAPTION | WS_SYSMENU;
       }
       else if (Style == WINDOWSTYLE_DIALOG)
       {
-        m_dwExStyle = WS_EX_DLGMODALFRAME;
-        m_dwStyle = WS_CAPTION | WS_SYSMENU;
+        window_extended_style_ = WS_EX_DLGMODALFRAME;
+        window_style_ = WS_CAPTION | WS_SYSMENU;
       }
       else if (Style == WINDOWSTYLE_NOBORDER)
       {
-        m_dwExStyle = WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
-        m_dwStyle = WS_POPUP;
+        window_extended_style_ = WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
+        window_style_ = WS_POPUP;
       }
       else if (Style == WINDOWSTYLE_PANEL)
       {
-        m_dwExStyle = 0;           // Specifies that a window has a border with a raised edge
-        m_dwStyle = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
+        window_extended_style_ = 0;           // Specifies that a window has a border with a raised edge
+        window_style_ = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
       }
       else
       {
         // Normal Window: NormalWindow
-        m_dwExStyle = WS_EX_APPWINDOW |   // Forces a top-level window onto the taskbar when the window is visible
+        window_extended_style_ = WS_EX_APPWINDOW |   // Forces a top-level window onto the taskbar when the window is visible
                       WS_EX_WINDOWEDGE;   // Specifies that a window has a border with a raised edge
 
-        m_dwStyle |= WS_CAPTION |         // Creates a window that has a title bar.
+        window_style_ |= WS_CAPTION |         // Creates a window that has a title bar.
                      WS_SYSMENU |         // Creates a window that has a window menu on its title bar. The WS_CAPTION style must also be specified.
                      WS_THICKFRAME |      // Creates a window that has a sizing border.
                      WS_MINIMIZEBOX |     // Creates a window that has a minimize button.
@@ -368,7 +357,7 @@
     // The AdjustWindowRectEx function calculates the required size of the window rectangle,
     // based on the desired size of the client rectangle. The window rectangle can then be passed to
     // the CreateWindowEx function to create a window whose client area is the desired size.
-    AdjustWindowRectEx(&WindowRect, m_dwStyle, FALSE, m_dwExStyle);    // Adjust Window To True Requested Size
+    AdjustWindowRectEx(&WindowRect, window_style_, FALSE, window_extended_style_);    // Adjust Window To True Requested Size
 
     RECT rect;
     rect.top = 0;
@@ -380,8 +369,8 @@
 
     if (Parent)
     {
-      m_ParentWindow = Parent->GetWindowHandle();
-      GetWindowRect(m_ParentWindow, &rect);
+      parent_window_ = Parent->GetWindowHandle();
+      GetWindowRect(parent_window_, &rect);
 
       int width = rect.right - rect.left;
       int height = rect.bottom - rect.top;
@@ -389,29 +378,29 @@
       WindowX = rect.left + (width - (WindowRect.right - WindowRect.left)) / 2;
       WindowY = rect.top + (height - (WindowRect.bottom - WindowRect.top)) / 2;
     }
-    else if (!m_fullscreen)
+    else if (!fullscreen_)
     {
       ClipOrCenterRectToMonitor(&rect, 0);
       WindowX = rect.left;
       WindowY = rect.top;
     }
 
-    m_WindowTitle = WindowTitle;
+    window_title_ = WindowTitle;
 
     // Create The Window
-    if (! (wnd_handle_ = ::CreateWindowEx(m_dwExStyle,                      // Extended Style For The Window
+    if (! (wnd_handle_ = ::CreateWindowEx(window_extended_style_,         // Extended Style For The Window
                                       WINDOW_CLASS_NAME,                  // Class Name
-                                      m_WindowTitle.GetTCharPtr(),        // Window Title
-                                      m_dwStyle |                           // Defined Window Style
+                                      window_title_.c_str(),              // Window Title
+                                      window_style_ |                     // Defined Window Style
                                       WS_CLIPSIBLINGS |                   // Required Window Style
                                       WS_CLIPCHILDREN,                    // Required Window Style
                                       WindowX, WindowY,                   // Window Position
                                       WindowRect.right - WindowRect.left, // Calculate Window Width
                                       WindowRect.bottom - WindowRect.top, // Calculate Window Height
-                                      m_ParentWindow,                     // No Parent Window
+                                      parent_window_,                     // No Parent Window
                                       NULL,                               // No Menu
                                       gGLWindowManager.GetInstance(),     // Instance
-                                      NULL)))                           // Dont Pass Anything To WM_CREATE
+                                      NULL)))                             // Don't Pass Anything To WM_CREATE
     {
       DestroyOpenGLWindow();
       MessageBox(NULL, "Window Creation Error.", "ERROR", MB_OK | MB_ICONERROR);
@@ -486,14 +475,14 @@
       return FALSE;
     }
 
-    if (! (m_PixelFormat = ChoosePixelFormat(device_context_, &pfd))) // Did Windows Find A Matching Pixel Format?
+    if (! (pixel_format_ = ChoosePixelFormat(device_context_, &pfd))) // Did Windows Find A Matching Pixel Format?
     {
       DestroyOpenGLWindow();
       MessageBox(NULL, "Can't Find A Suitable PixelFormat.", "ERROR", MB_OK | MB_ICONERROR);
       return FALSE;
     }
 
-    if (!SetPixelFormat(device_context_, m_PixelFormat, &pfd))        // Are We Able To Set The Pixel Format?
+    if (!SetPixelFormat(device_context_, pixel_format_, &pfd))        // Are We Able To Set The Pixel Format?
     {
       DestroyOpenGLWindow();
       MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR", MB_OK | MB_ICONERROR);
@@ -540,13 +529,13 @@
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     SwapBuffer();
 
-    m_GfxInterfaceCreated = true;
+    gfx_interface_created_ = true;
 
     //m_GLEWContext = new GLEWContext();
     //m_WGLEWContext = new WGLEWContext();
 
     HGLRC new_opengl_rendering_context = opengl_rendering_context_;
-    m_DeviceFactory = new GpuDevice(m_ViewportSize.width, m_ViewportSize.height, BITFMT_R8G8B8A8,
+    m_DeviceFactory = new GpuDevice(viewport_size_.width, viewport_size_.height, BITFMT_R8G8B8A8,
       device_context_,
       new_opengl_rendering_context,
       1, 0, false);
@@ -579,13 +568,13 @@
 
     RECT rect;
     ::GetClientRect(wnd_handle_, &rect);
-    m_WindowSize = Size(rect.right - rect.left, rect.bottom - rect.top);
-    m_ViewportSize = Size(rect.right - rect.left, rect.bottom - rect.top);
+    window_size_ = Size(rect.right - rect.left, rect.bottom - rect.top);
+    viewport_size_ = Size(rect.right - rect.left, rect.bottom - rect.top);
 
     // The opengl context should be made current by an external entity.
 
-    m_GfxInterfaceCreated = true;
-    m_DeviceFactory = new GpuDevice(m_ViewportSize.width, m_ViewportSize.height, BITFMT_R8G8B8A8,
+    gfx_interface_created_ = true;
+    m_DeviceFactory = new GpuDevice(viewport_size_.width, viewport_size_.height, BITFMT_R8G8B8A8,
       device_context_,
       opengl_rendering_context_);
 
@@ -616,28 +605,28 @@
 //---------------------------------------------------------------------------------------------------------
   void GraphicsDisplay::GetWindowSize(int &w, int &h)
   {
-    w = m_WindowSize.width;
-    h = m_WindowSize.height;
+    w = window_size_.width;
+    h = window_size_.height;
   }
 
 //---------------------------------------------------------------------------------------------------------
   int GraphicsDisplay::GetWindowWidth()
   {
-    return m_WindowSize.width;
+    return window_size_.width;
   }
 
 //---------------------------------------------------------------------------------------------------------
   int GraphicsDisplay::GetWindowHeight()
   {
-    return m_WindowSize.height;
+    return window_size_.height;
   }
 
   void GraphicsDisplay::ResetWindowSize()
   {
     RECT rect;
     ::GetClientRect(wnd_handle_, &rect);
-    m_WindowSize = Size(rect.right - rect.left, rect.bottom - rect.top);
-    m_ViewportSize = Size(rect.right - rect.left, rect.bottom - rect.top);
+    window_size_ = Size(rect.right - rect.left, rect.bottom - rect.top);
+    viewport_size_ = Size(rect.right - rect.left, rect.bottom - rect.top);
   }
 
 //---------------------------------------------------------------------------------------------------------
@@ -651,7 +640,7 @@
     new_rect.right = width;
     new_rect.top = 0;
     new_rect.bottom = height;
-    BOOL b = ::AdjustWindowRectEx(&new_rect, m_dwStyle, FALSE, m_dwExStyle);    // Adjust Window To True Requested Size
+    BOOL b = ::AdjustWindowRectEx(&new_rect, window_style_, FALSE, window_extended_style_);    // Adjust Window To True Requested Size
 
     ::MoveWindow(wnd_handle_,
                   window_rect.left,
@@ -666,11 +655,11 @@
   {
     if (IsGfxInterfaceCreated())
     {
-      //do not rely on m_ViewportSize: glViewport can be called directly
-      m_ViewportSize.width = width;
-      m_ViewportSize.height = height;
+      //do not rely on viewport_size_: glViewport can be called directly
+      viewport_size_.width = width;
+      viewport_size_.height = height;
 
-      m_GraphicsContext->SetViewport(x, y, m_ViewportSize.width, m_ViewportSize.height);
+      m_GraphicsContext->SetViewport(x, y, viewport_size_.width, viewport_size_.height);
       m_GraphicsContext->SetScissor(0, 0, width, height);
     }
   }
@@ -767,9 +756,9 @@
 //---------------------------------------------------------------------------------------------------------
   void GraphicsDisplay::DestroyOpenGLWindow()
   {
-    if (m_GfxInterfaceCreated == true)
+    if (gfx_interface_created_ == true)
     {
-      if (m_fullscreen)                                   // Are We In Fullscreen Mode?
+      if (fullscreen_)                                   // Are We In Fullscreen Mode?
       {
         ChangeDisplaySettings(NULL, 0);                  // If So Switch Back To The Desktop
         ShowCursor(TRUE);                                // Show Mouse Pointer
@@ -803,7 +792,7 @@
       wnd_handle_ = NULL;                                                // Set Window Handle To NULL
     }
 
-    m_GfxInterfaceCreated = false;
+    gfx_interface_created_ = false;
   }
 
 
@@ -902,26 +891,26 @@
       return extended ? extendedlut[vk] : vklut[vk];
   }*/
 //---------------------------------------------------------------------------------------------------------
-  static int mouse_event(HWND window, Event *event, int what, int button,
+  static int InspectMouseEvent(HWND window, Event& event, int what, int button,
                           WPARAM wParam, LPARAM lParam)
   {
     static int pmx, pmy;
-    event->x = (signed short) LOWORD(lParam);
-    event->y = (signed short) HIWORD(lParam);
-    event->x_root = 0;
-    event->y_root = 0;
+    event.x = (signed short) LOWORD(lParam);
+    event.y = (signed short) HIWORD(lParam);
+    event.x_root = 0;
+    event.y_root = 0;
 
     POINT EventScreenPosition;
 
     ClientToScreen(window, &EventScreenPosition);
-    EventScreenPosition.x = event->x;
-    EventScreenPosition.y = event->y;
+    EventScreenPosition.x = event.x;
+    EventScreenPosition.y = event.y;
     POINT WindowScreenPosition;
     WindowScreenPosition.x = WindowScreenPosition.y = 0;
     ClientToScreen(window, &WindowScreenPosition);
 
     // Erase mouse event and mouse doubleclick events. Keep the mouse states.
-    ulong _mouse_state = event->mouse_state & 0x0F000000;
+    ulong _mouse_state = event.mouse_state & 0x0F000000;
 
     // establish cause of the event
 //     if (button == 1)
@@ -933,16 +922,16 @@
 //     else
     if (button == 4)
     {
-      event->mouse_state |= NUX_EVENT_MOUSEWHEEL;
-      event->type = NUX_MOUSE_WHEEL;
+      event.mouse_state |= NUX_EVENT_MOUSEWHEEL;
+      event.type = NUX_MOUSE_WHEEL;
 
       int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
       int xPos = (int) (short) LOWORD(lParam) - WindowScreenPosition.x;
       int yPos = (int) (short) HIWORD(lParam) - WindowScreenPosition.y;
-      event->x = xPos;
-      event->y = yPos;
+      event.x = xPos;
+      event.y = yPos;
 
-      event->wheel_delta = zDelta;
+      event.wheel_delta = zDelta;
       return 1;
     }
 
@@ -1016,39 +1005,39 @@
       break;
     }
 
-    event->mouse_state = _mouse_state;
+    event.mouse_state = _mouse_state;
 
     switch(what)
     {
       static int px, py;
       case 1: // double-click
 
-        if (event->is_click)
+        if (event.is_click)
         {
-          event->clicks++;
+          event.clicks++;
           // The SetCapture function sets the mouse capture to the specified window belonging to
           // the current thread. SetCapture captures mouse input either when the mouse is over the
           // capturing window, or when the mouse button was pressed while the mouse was over the
           // capturing window and the button is still down. Only one window at a time can capture the mouse.
           SetCapture(window);
-          event->is_click = 1;
-          px = pmx = event->x;
-          py = pmy = event->y;
-          event->type = NUX_MOUSE_DOUBLECLICK;
+          event.is_click = 1;
+          px = pmx = event.x;
+          py = pmy = event.y;
+          event.type = NUX_MOUSE_DOUBLECLICK;
           return 1;
         }
 
       case 0: // single-click
-        event->clicks = 0;
+        event.clicks = 0;
         // The SetCapture function sets the mouse capture to the specified window belonging to
         // the current thread. SetCapture captures mouse input either when the mouse is over the
         // capturing window, or when the mouse button was pressed while the mouse was over the
         // capturing window and the button is still down. Only one window at a time can capture the mouse.
         SetCapture(window);
-        event->is_click = 1;
-        px = pmx = event->x;
-        py = pmy = event->y;
-        event->type = NUX_MOUSE_PRESSED;
+        event.is_click = 1;
+        px = pmx = event.x;
+        py = pmy = event.y;
+        event.type = NUX_MOUSE_PRESSED;
         return 1;
 
       case 2: // release:
@@ -1057,21 +1046,21 @@
         // mouse input, regardless of the position of the cursor, except when a mouse button is clicked
         // while the cursor hot spot is in the window of another thread.
         ReleaseCapture();
-        event->type = NUX_MOUSE_RELEASED;
+        event.type = NUX_MOUSE_RELEASED;
         return 1;
 
       case 3: // move:
       default: // avoid compiler warning
         // MSWindows produces extra events even if mouse does not move, ignore them.
         // http://blogs.msdn.com/oldnewthing/archive/2003/10/01/55108.aspx: Why do I get spurious WM_MOUSEMOVE messages?
-        if (event->x == pmx && event->y == pmy)
+        if (event.x == pmx && event.y == pmy)
           return 1;
 
-        pmx = event->x;
-        pmy = event->y;
-//        if (abs(event->x - px)>5 || abs(event->y - py)>5)
-//            event->is_click = 0;
-        event->type = NUX_MOUSE_MOVE;
+        pmx = event.x;
+        pmy = event.y;
+//        if (abs(event.x - px)>5 || abs(event.y - py)>5)
+//            event.is_click = 0;
+        event.type = NUX_MOUSE_MOVE;
         return 1;
     }
 
@@ -1131,12 +1120,12 @@
   }
 
 //---------------------------------------------------------------------------------------------------------
-  bool GraphicsDisplay::GetSystemEvent(Event *evt)
+  bool GraphicsDisplay::GetSystemEvent(Event *event)
   {
     MSG		msg;
-    event_->Reset();
+    event_.Reset();
     // Erase mouse event and mouse doubleclick states. Keep the mouse states.
-    event_->mouse_state &= 0x0F000000;
+    event_.mouse_state &= 0x0F000000;
     bool got_event;
 
     // Always set the second parameter of PeekMessage to NULL. Indeed, many services creates
@@ -1154,12 +1143,12 @@
       TranslateMessage(&msg);
       DispatchMessage(&msg);
 
-      memcpy(evt, event_, sizeof(Event));
+      memcpy(event, &event_, sizeof(Event));
       got_event = true;
     }
     else
     {
-      memcpy(evt, event_, sizeof(Event));
+      memcpy(event, &event_, sizeof(Event));
       got_event = false;
     }
 
@@ -1169,14 +1158,14 @@
       // See [Modality, part 3: The WM_QUIT message] http://blogs.msdn.com/oldnewthing/archive/2005/02/22/378018.aspx
       PostQuitMessage(msg.wParam);
 
-      event_->type = NUX_TERMINATE_APP;
-      memcpy(evt, event_, sizeof(Event));
+      event_.type = NUX_TERMINATE_APP;
+      memcpy(event, &event_, sizeof(Event));
     }
 
     if (msg.message == -1) // error
     {
-      event_->type = NUX_NO_EVENT;
-      memcpy(evt, event_, sizeof(Event));
+      event_.type = NUX_NO_EVENT;
+      memcpy(event, &event_, sizeof(Event));
     }
 
     return got_event;
@@ -1184,16 +1173,16 @@
 
   void GraphicsDisplay::ProcessForeignWin32Event(HWND hWnd, MSG msg, WPARAM wParam, LPARAM lParam, Event *event)
   {
-    event_->Reset();
+    event_.Reset();
     // Erase mouse event and mouse doubleclick states. Keep the mouse states.
-    event_->mouse_state &= 0x0F000000;
+    event_.mouse_state &= 0x0F000000;
 
     // Always set the second parameter of PeekMessage to NULL. Indeed, many services creates
     // windows on the program behalf. If pass the main window as filter, we will miss all the
     // messages from the other windows.
     // Same with GetMessage.
     ProcessWin32Event(hWnd, msg.message, wParam, lParam);
-    memcpy(event, event_, sizeof(Event));
+    memcpy(event, &event_, sizeof(Event));
 
     if (msg.message != WM_QUIT)
     {
@@ -1201,20 +1190,20 @@
       // See [Modality, part 3: The WM_QUIT message] http://blogs.msdn.com/oldnewthing/archive/2005/02/22/378018.aspx
       PostQuitMessage(msg.wParam);
 
-      event_->type = NUX_TERMINATE_APP;
-      memcpy(event, event_, sizeof(Event));
+      event_.type = NUX_TERMINATE_APP;
+      memcpy(event, &event_, sizeof(Event));
     }
 
     if (msg.message == -1) // error
     {
-      event_->type = NUX_NO_EVENT;
-      memcpy(event, event_, sizeof(Event));
+      event_.type = NUX_NO_EVENT;
+      memcpy(event, &event_, sizeof(Event));
     }
   }
 
-  Event &GraphicsDisplay::GetCurrentEvent()
+  const Event& GraphicsDisplay::GetCurrentEvent() const
   {
-    return *event_;
+    return event_;
   }
 
 //---------------------------------------------------------------------------------------------------------
@@ -1268,13 +1257,13 @@
     {
       case WM_DESTROY:
       {
-        nuxDebugMsg("[GraphicsDisplay::WndProc]: Window \"%s\" received WM_DESTROY message.", m_WindowTitle.GetTCharPtr());
+        nuxDebugMsg("[GraphicsDisplay::WndProc]: Window \"%s\" received WM_DESTROY message.", window_title_.c_str());
         break;
       }
 
       case WM_CLOSE:
       {
-        nuxDebugMsg("[GraphicsDisplay::WndProc]: Window \"%s\" received WM_CLOSE message.", m_WindowTitle.GetTCharPtr());
+        nuxDebugMsg("[GraphicsDisplay::WndProc]: Window \"%s\" received WM_CLOSE message.", window_title_.c_str());
         // close? yes or no?
         PostQuitMessage(0);
         return 0;
@@ -1283,7 +1272,7 @@
       case WM_PAINT:
       {
         ValidateRect(hWnd, NULL); //  validate the surface to avoid receiving WM_PAINT continuously
-        event_->type = NUX_WINDOW_DIRTY;
+        event_.type = NUX_WINDOW_DIRTY;
         break;
       }
 
@@ -1293,7 +1282,7 @@
         if ((HWND) lParam == hWnd)
         {
           // Cancel everything about the mouse state and send a NUX_WINDOW_EXIT_FOCUS message.
-          event_->mouse_state = 0;
+          event_.mouse_state = 0;
           //nuxDebugMsg("Windows Msg: WM_CAPTURECHANGED/NUX_WINDOW_EXIT_FOCUS");
           return 0;
         }
@@ -1311,9 +1300,9 @@
         RECT clientrect;
         GetClientRect( hWnd, &clientrect);
 
-        event_->type = NUX_SIZE_CONFIGURATION;
-        event_->width =  clientrect.right - clientrect.left;
-        event_->height =  clientrect.bottom - clientrect.top;
+        event_.type = NUX_SIZE_CONFIGURATION;
+        event_.width =  clientrect.right - clientrect.left;
+        event_.height =  clientrect.bottom - clientrect.top;
         return 0;
       }
 
@@ -1322,26 +1311,26 @@
         RECT clientrect;
         GetClientRect( hWnd, &clientrect);
 
-        event_->type = NUX_NO_EVENT; //NUX_SIZE_CONFIGURATION;
-        event_->width =  clientrect.right - clientrect.left;
-        event_->height =  clientrect.bottom - clientrect.top;
+        event_.type = NUX_NO_EVENT; //NUX_SIZE_CONFIGURATION;
+        event_.width =  clientrect.right - clientrect.left;
+        event_.height =  clientrect.bottom - clientrect.top;
 
         //setViewPort(0, 0, clientrect.right - clientrect.left, clientrect.bottom - clientrect.top);
-        m_WindowSize.width = clientrect.right - clientrect.left;
-        m_WindowSize.height = clientrect.bottom - clientrect.top;
+        window_size_.width = clientrect.right - clientrect.left;
+        window_size_.height = clientrect.bottom - clientrect.top;
 
         if ((wParam == SIZE_MAXHIDE) || (wParam == SIZE_MINIMIZED))
         {
-          m_is_window_minimized = true;
+          window_minimized_ = true;
         }
         else
         {
-          m_is_window_minimized = false;
+          window_minimized_ = false;
         }
 
         if ((wParam == SIZE_MAXIMIZED) || (wParam == SIZE_RESTORED))
         {
-          event_->type = NUX_SIZE_CONFIGURATION;
+          event_.type = NUX_SIZE_CONFIGURATION;
         }
 
         return 0;
@@ -1349,32 +1338,32 @@
 
       case WM_SETFOCUS:
       {
-        event_->type = NUX_WINDOW_ENTER_FOCUS;
-        event_->mouse_state = 0;
+        event_.type = NUX_WINDOW_ENTER_FOCUS;
+        event_.mouse_state = 0;
 
         // This causes the mouse to be outside of all widgets when it is tested in m_EventHandler.Process().
         // Because WM_SETFOCUS can happen with the mouse outside of the client area, we set x and y so that the mouse will be
         // outside of all widgets. A subsequent mouse down or mouse move event will set the correct values for x and y.
-        event_->x = 0xFFFFFFFF;
-        event_->y = 0xFFFFFFFF;
-        event_->dx = 0;
-        event_->dy = 0;
-        event_->virtual_code = 0;
+        event_.x = 0xFFFFFFFF;
+        event_.y = 0xFFFFFFFF;
+        event_.dx = 0;
+        event_.dy = 0;
+        event_.virtual_code = 0;
         //nuxDebugMsg("Windows Msg: WM_SETFOCUS/NUX_WINDOW_ENTER_FOCUS");
         break;
       }
 
       case WM_KILLFOCUS:
       {
-        event_->type = NUX_WINDOW_EXIT_FOCUS;
-        event_->mouse_state = 0;
+        event_.type = NUX_WINDOW_EXIT_FOCUS;
+        event_.mouse_state = 0;
 
         // This causes the mouse to be outside of all widgets when it is tested in m_EventHandler.Process()
-        event_->x = 0xFFFFFFFF;
-        event_->y = 0xFFFFFFFF;
-        event_->dx = 0;
-        event_->dy = 0;
-        event_->virtual_code = 0;
+        event_.x = 0xFFFFFFFF;
+        event_.y = 0xFFFFFFFF;
+        event_.dx = 0;
+        event_.dy = 0;
+        event_.virtual_code = 0;
         //nuxDebugMsg("Windows Msg: WM_KILLFOCUS/NUX_WINDOW_EXIT_FOCUS");
         break;
       }
@@ -1388,24 +1377,24 @@
       {
         if (LOWORD(wParam) != WA_INACTIVE)
         {
-          event_->type = NUX_WINDOW_ENTER_FOCUS;
+          event_.type = NUX_WINDOW_ENTER_FOCUS;
         }
         else
         {
-          event_->type = NUX_WINDOW_EXIT_FOCUS;
+          event_.type = NUX_WINDOW_EXIT_FOCUS;
         }
-        event_->mouse_state = 0;
+        event_.mouse_state = 0;
 
         // This causes the mouse to be outside of all widgets when it is tested in m_EventHandler.Process().
         // Because WM_SETFOCUS can happen with the mouse outside of the client area, we set x and y so that the mouse will be
         // outside of all widgets. A subsequent mouse down or mouse move event will set the correct values for x and y.
-        event_->x = 0xFFFFFFFF;
-        event_->y = 0xFFFFFFFF;
-        event_->dx = 0;
-        event_->dy = 0;
-        event_->virtual_code = 0;
+        event_.x = 0xFFFFFFFF;
+        event_.y = 0xFFFFFFFF;
+        event_.dx = 0;
+        event_.dy = 0;
+        event_.virtual_code = 0;
 
-        event_->key_modifiers = GetModifierKeyState();
+        event_.key_modifiers = GetModifierKeyState();
         return 0;
       }
 
@@ -1413,48 +1402,48 @@
         {
           if (wParam)
           {
-            event_->type = NUX_WINDOW_ENTER_FOCUS;
+            event_.type = NUX_WINDOW_ENTER_FOCUS;
           }
           else
           {
-            event_->type = NUX_WINDOW_EXIT_FOCUS;
+            event_.type = NUX_WINDOW_EXIT_FOCUS;
           }
-          event_->mouse_state = 0;
+          event_.mouse_state = 0;
 
           // This causes the mouse to be outside of all widgets when it is tested in m_EventHandler.Process().
           // Because WM_SETFOCUS can happen with the mouse outside of the client area, we set x and y so that the mouse will be
           // outside of all widgets. A subsequent mouse down or mouse move event will set the correct values for x and y.
-          event_->x = 0xFFFFFFFF;
-          event_->y = 0xFFFFFFFF;
-          event_->dx = 0;
-          event_->dy = 0;
-          event_->virtual_code = 0;
+          event_.x = 0xFFFFFFFF;
+          event_.y = 0xFFFFFFFF;
+          event_.dx = 0;
+          event_.dy = 0;
+          event_.virtual_code = 0;
 
-          event_->key_modifiers = GetModifierKeyState();
+          event_.key_modifiers = GetModifierKeyState();
           return 0;
         }
 
       case WM_SYSKEYDOWN:
       case WM_KEYDOWN:
       {
-        event_->type = NUX_KEYDOWN;
-        event_->key_modifiers = GetModifierKeyState();
-        event_->win32_keysym = wParam;
+        event_.type = NUX_KEYDOWN;
+        event_.key_modifiers = GetModifierKeyState();
+        event_.win32_keysym = wParam;
 
         if ((uMsg == WM_KEYDOWN) || (uMsg == WM_SYSKEYDOWN))
         {
-          event_->VirtualKeycodeState[GraphicsDisplay::Win32KeySymToINL(wParam) ] = 1;
+          event_.VirtualKeycodeState[GraphicsDisplay::Win32KeySymToINL(wParam) ] = 1;
         }
 
         if (wParam == VK_CONTROL)
         {
           if (lParam & (1 << 24))
           {
-            event_->win32_keysym = NUX_VK_RCONTROL;
+            event_.win32_keysym = NUX_VK_RCONTROL;
           }
           else
           {
-            event_->win32_keysym = NUX_VK_LCONTROL;
+            event_.win32_keysym = NUX_VK_LCONTROL;
           }
         }
 
@@ -1462,11 +1451,11 @@
         {
           if (lParam & (1 << 24))
           {
-            event_->win32_keysym = NUX_VK_RALT;
+            event_.win32_keysym = NUX_VK_RALT;
           }
           else
           {
-            event_->win32_keysym = NUX_VK_LALT;
+            event_.win32_keysym = NUX_VK_LALT;
           }
         }
 
@@ -1474,11 +1463,11 @@
         {
           if (HIWORD(GetAsyncKeyState(VK_LSHIFT)))
           {
-            event_->win32_keysym = NUX_VK_LSHIFT;
+            event_.win32_keysym = NUX_VK_LSHIFT;
           }
           else if (HIWORD(GetAsyncKeyState(VK_RSHIFT)))
           {
-            event_->win32_keysym = NUX_VK_RSHIFT;
+            event_.win32_keysym = NUX_VK_RSHIFT;
           }
         }
 
@@ -1488,13 +1477,13 @@
       case WM_SYSKEYUP:
       case WM_KEYUP:
       {
-        event_->type = NUX_KEYUP;
-        event_->key_modifiers = GetModifierKeyState();
-        event_->win32_keysym = wParam;
+        event_.type = NUX_KEYUP;
+        event_.key_modifiers = GetModifierKeyState();
+        event_.win32_keysym = wParam;
 
         if ((uMsg == WM_KEYUP) || (uMsg == WM_SYSKEYUP))
         {
-          event_->VirtualKeycodeState[GraphicsDisplay::Win32KeySymToINL(wParam) ] = 0;
+          event_.VirtualKeycodeState[GraphicsDisplay::Win32KeySymToINL(wParam) ] = 0;
         }
 
         break;
@@ -1505,22 +1494,22 @@
       case WM_CHAR:
       case WM_SYSCHAR:
       {
-        event_->key_modifiers = GetModifierKeyState();
+        event_.key_modifiers = GetModifierKeyState();
 
         // reset key repeat count to 0.
-        event_->key_repeat_count = 0;
+        event_.key_repeat_count = 0;
 
         if (lParam & (1 << 31))
         {
           // key up events.
-          event_->type = NUX_KEYUP;
+          event_.type = NUX_KEYUP;
           return 0;
         }
         else
         {
           // key down events.
-          event_->type = NUX_KEYDOWN;
-          event_->key_repeat_count = (int) (lParam & 0xff);
+          event_.type = NUX_KEYDOWN;
+          event_.key_repeat_count = (int) (lParam & 0xff);
         }
 
 
@@ -1533,12 +1522,12 @@
         }
 
         wchar_t *utf16_str = new wchar_t [4];
-        Memset(utf16_str, 0, sizeof(wchar_t) * 4);
-        Memcpy(utf16_str, (int*) &wParam, sizeof(wParam));
+        std::memset(utf16_str, 0, sizeof(wchar_t) * 4);
+        std::memcpy(utf16_str, (int*) &wParam, sizeof(wParam));
         wchar_t *temp0 = utf16_str;
 
         unsigned char *utf8_str = new unsigned char [NUX_EVENT_TEXT_BUFFER_SIZE];
-        Memset(utf8_str, 0, sizeof(unsigned char) * NUX_EVENT_TEXT_BUFFER_SIZE);
+        std::memset(utf8_str, 0, sizeof(unsigned char) * NUX_EVENT_TEXT_BUFFER_SIZE);
         unsigned char *temp1 = utf8_str;
 
 
@@ -1550,7 +1539,7 @@
 
         if (res == conversionOK)
         {
-          Memcpy(event_->text, utf8_str, NUX_EVENT_TEXT_BUFFER_SIZE);
+          std::memcpy(event_.text, utf8_str, NUX_EVENT_TEXT_BUFFER_SIZE);
         }
         delete utf8_str;
         delete utf16_str;
@@ -1563,31 +1552,31 @@
         if (wParam == UNICODE_NOCHAR)
           return 1;
 
-        event_->key_modifiers = GetModifierKeyState();
+        event_.key_modifiers = GetModifierKeyState();
 
         // reset key repeat count to 0.
-        event_->key_repeat_count = 0;
+        event_.key_repeat_count = 0;
 
         if (lParam & (1 << 31))
         {
           // key up events.
-          event_->type = NUX_KEYUP;
+          event_.type = NUX_KEYUP;
           return 0;
         }
         else
         {
           // key down events.
-          event_->type = NUX_KEYDOWN;
-          event_->key_repeat_count = (int) (lParam & 0xff);
+          event_.type = NUX_KEYDOWN;
+          event_.key_repeat_count = (int) (lParam & 0xff);
         }
 
         unsigned int *utf32_str = new unsigned int [4];
-        Memset(utf32_str, 0, sizeof(unsigned int) * 4);
-        Memcpy(utf32_str, (int*) &wParam, sizeof(wParam));
+        std::memset(utf32_str, 0, sizeof(unsigned int) * 4);
+        std::memcpy(utf32_str, (int*) &wParam, sizeof(wParam));
         unsigned int *temp0 = utf32_str;
 
         unsigned char *utf8_str = new unsigned char [NUX_EVENT_TEXT_BUFFER_SIZE];
-        Memset(utf8_str, 0, sizeof(unsigned char) * NUX_EVENT_TEXT_BUFFER_SIZE);
+        std::memset(utf8_str, 0, sizeof(unsigned char) * NUX_EVENT_TEXT_BUFFER_SIZE);
         unsigned char *temp1 = utf8_str;
 
 
@@ -1599,7 +1588,7 @@
 
         if (res == conversionOK)
         {
-          Memcpy(event_->text, utf8_str, NUX_EVENT_TEXT_BUFFER_SIZE);
+          std::memcpy(event_.text, utf8_str, NUX_EVENT_TEXT_BUFFER_SIZE);
         }
         delete utf8_str;
         delete utf32_str;
@@ -1607,107 +1596,107 @@
 
       case WM_LBUTTONDOWN:
       {
-        mouse_event(hWnd, event_, 0, 1, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 0, 1, wParam, lParam);
         //nuxDebugMsg("Windows Msg: WM_LBUTTONDOWN");
         return 0;
       }
       case WM_LBUTTONDBLCLK:
       {
-        mouse_event(hWnd, event_, 1, 1, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 1, 1, wParam, lParam);
         //nuxDebugMsg("Windows Msg: WM_LBUTTONDBLCLK");
         return 0;
       }
       case WM_LBUTTONUP:
       {
-        mouse_event(hWnd, event_, 2, 1, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 2, 1, wParam, lParam);
         //nuxDebugMsg("Windows Msg: WM_LBUTTONUP");
         return 0;
       }
       case WM_MBUTTONDOWN:
       {
-        mouse_event(hWnd, event_, 0, 2, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 0, 2, wParam, lParam);
         break;
       }
       case WM_MBUTTONDBLCLK:
       {
-        mouse_event(hWnd, event_, 1, 2, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 1, 2, wParam, lParam);
         break;
       }
       case WM_MBUTTONUP:
       {
-        mouse_event(hWnd, event_, 2, 2, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 2, 2, wParam, lParam);
         break;
       }
       case WM_RBUTTONDOWN:
       {
-        mouse_event(hWnd, event_, 0, 3, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 0, 3, wParam, lParam);
         break;
       }
       case WM_RBUTTONDBLCLK:
       {
-        mouse_event(hWnd, event_, 1, 3, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 1, 3, wParam, lParam);
         break;
       }
       case WM_RBUTTONUP:
       {
-        mouse_event(hWnd, event_, 2, 3, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 2, 3, wParam, lParam);
         break;
       }
       case WM_MOUSEWHEEL:
       {
-        mouse_event(hWnd, event_, 0, 4, wParam, lParam);
+        InspectMouseEvent(hWnd, event_, 0, 4, wParam, lParam);
         break;
       }
 
       case WM_NCLBUTTONDBLCLK:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;
         break;
       }
       case WM_NCLBUTTONDOWN:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;
         break;
       }
       case WM_NCLBUTTONUP:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;
         break;
       }
       case WM_NCMBUTTONDBLCLK:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;
         break;
       }
       case WM_NCMBUTTONDOWN:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;
         break;
       }
       case WM_NCMBUTTONUP:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;
         break;
       }
       case WM_NCRBUTTONDBLCLK:
       {
-        event_->type = NUX_NC_WINDOW_CONFIGURATION;
+        event_.type = NUX_NC_WINDOW_CONFIGURATION;