Merge lp:~unity-team/unity/unity.dash-to-preview into lp:unity

[Jay Taoko]

This branch introduces dash to preview transitions. I relies on this nux branch: https://code.launchpad.net/~unity-team/nux/nux.redirected-views/+merge/124661

Animation from Dash to Preview slides out elements of the dash to make room for the previews. The process happens in 250ms.

Many changes were necessary to create this effects. It has to be said that the changes have an impact on the rendering engine and the way elements are drawn in the dash. Efforts are being made to reduce this impact.

This branch introduces dash to preview transitions. I relies on this nux branch: https://code.launchpad.net/~unity-team/nux/nux.redirected-views/+merge/124661

Animation from Dash to Preview slides out elements of the dash to make room for the previews. The process happens in 250ms.

Many changes were necessary to create this effects. It has to be said that the changes have an impact on the rendering engine and the way elements are drawn in the dash. Efforts are being made to reduce this impact.

[Neil J. Patel (njpatel)]

Hey, looks good and works well, have been using it for about a week.

Some comments:

- You've added an 'i' to the UBusMessages.h but forgot to add what it's for :)

- Please remove the commented out code:

//tick_source_.reset(new nux::NuxTimerTickSource);
//animation_controller_.reset(new na::AnimationController(*tick_source_));

// nux::GetGraphicsDisplay()->GetGraphicsEngine()->QRP_GetCopyTexture(
// src_texture->GetWidth(), src_texture->GetHeight(),
// layout_copy_, src_texture,
// texxform, nux::color::White);

//layout_->SetCopyPreviousFboTexture(false);

//(opening_row_y_ - layout_->GetY())/(float)layout_->GetHeight();

//SetCopyPreviousFboTexture(false);

//SetRedirectRenderingToTexture(true);
//SetCopyPreviousFboTexture(false);

// if (RedirectedAncestor())
// {
// // This is necessary when doing redirected rendering. Clean the area below this view.
// unsigned int current_alpha_blend;
// unsigned int current_src_blend_factor;
// unsigned int current_dest_blend_factor;
// GfxContext.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);

// GfxContext.GetRenderStates().SetBlend(false);
// GfxContext.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));

// GfxContext.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
// }

// tick_source_.tick(g_get_monotonic_time());

// nux::animation::TickSource tick_source_;
// nux::animation::AnimationController animation_controller_;

review: Needs Fixing

[Neil J. Patel (njpatel)]

Oh, please add the manual tests as discussed too, thanks.

[Neil J. Patel (njpatel)]

review: Approve

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity/1340/console reported an error when processing this lp:~unity-team/unity/unity.dash-to-preview branch.
Not merging it.

=== modified file 'dash/CoverflowResultView.cpp'
--- dash/CoverflowResultView.cpp	2012-09-17 16:59:51 +0000
+++ dash/CoverflowResultView.cpp	2012-09-18 14:01:19 +0000
@@ -135,7 +135,7 @@
   int size = model_->Items().size();
 
   ubus_.SendMessage(UBUS_DASH_PREVIEW_INFO_PAYLOAD, 
-                    g_variant_new("(iii)", 0, index, size - index));
+                    g_variant_new("(iiii)", 0, 0, index, size - index));
 }
 
 CoverflowResultView::Impl::Impl(CoverflowResultView *parent)
@@ -193,7 +193,7 @@
       int right_results = num_results ? (num_results - current_index) - 1 : 0;
       parent_->UriActivated.emit(GetUriForIndex(current_index), ActivateType::PREVIEW);
       ubus_.SendMessage(UBUS_DASH_PREVIEW_INFO_PAYLOAD, 
-                              g_variant_new("(iii)", 0, left_results, right_results));
+                              g_variant_new("(iiii)", 0, 0, left_results, right_results));
     }
   });
 }
@@ -269,6 +269,20 @@
   nux::Geometry base = GetGeometry();
   GfxContext.PushClippingRectangle(base);
 
+  if (RedirectedAncestor())
+  {
+    // This is necessary when doing redirected rendering. Clean the area below this view.
+    unsigned int current_alpha_blend;
+    unsigned int current_src_blend_factor;
+    unsigned int current_dest_blend_factor;
+    GfxContext.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+
+    GfxContext.GetRenderStates().SetBlend(false);
+    GfxContext.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+
+    GfxContext.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+  }
+  
   if (GetCompositionLayout())
   {
     nux::Geometry geo = GetCompositionLayout()->GetGeometry();

=== modified file 'dash/DashView.cpp'
--- dash/DashView.cpp	2012-09-18 09:05:50 +0000
+++ dash/DashView.cpp	2012-09-18 14:01:19 +0000
@@ -16,6 +16,7 @@
  * Authored by: Neil Jagdish Patel <[e-mail]>
  */
 
+
 #include "DashView.h"
 #include "DashViewPrivate.h"
 
@@ -36,6 +37,7 @@
 #include "unity-shared/UBusMessages.h"
 #include "unity-shared/PreviewStyle.h"
 
+#include "Nux/NuxTimerTickSource.h"
 
 namespace unity
 {
@@ -89,7 +91,14 @@
   , search_in_progress_(false)
   , activate_on_finish_(false)
   , visible_(false)
+  , fade_out_value_(0.0f)
+  , fade_in_value_(0.0f)
+  , opening_row_y_(-1)
+  , opening_row_height_(0)
 {
+  //tick_source_.reset(new nux::NuxTimerTickSource);
+  //animation_controller_.reset(new na::AnimationController(*tick_source_));
+
   renderer_.SetOwner(this);
   renderer_.need_redraw.connect([this] () {
     QueueDraw();
@@ -107,6 +116,13 @@
   home_lens_->AddLenses(lenses_);
   home_lens_->search_finished.connect(sigc::mem_fun(this, &DashView::OnGlobalSearchFinished));
   lens_bar_->Activate("home.lens");
+
+  // We are interested in the color of the desktop background.
+  ubus_manager_.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, sigc::mem_fun(this, &DashView::OnBGColorChanged));
+
+  // request the latest colour from bghash
+  ubus_manager_.SendMessage(UBUS_BACKGROUND_REQUEST_COLOUR_EMIT);
+
 }
 
 DashView::~DashView()
@@ -116,6 +132,15 @@
   RemoveLayout();
 }
 
+void DashView::OnBGColorChanged(GVariant *data)
+{
+  double red = 0.0f, green = 0.0f, blue = 0.0f, alpha = 0.0f;
+
+  g_variant_get(data, "(dddd)", &red, &green, &blue, &alpha);
+  background_color_ = nux::Color(red, green, blue, alpha);
+  QueueDraw();
+}
+
 void DashView::SetMonitorOffset(int x, int y)
 {
   renderer_.x_offset = x;
@@ -124,25 +149,87 @@
 
 void DashView::ClosePreview()
 {
+  if (preview_displaying_)
+  {
+    layout_->SetPresentRedirectedView(true);
+    animation_.Stop();
+    fade_out_connection_.disconnect();
+    fade_in_connection_.disconnect();
+    // Set fade animation
+    animation_.SetDuration(250);
+    animation_.SetEasingCurve(na::EasingCurve(na::EasingCurve::Type::ExpoEaseIn));
+    fade_in_connection_ = animation_.updated.connect(sigc::mem_fun(this, &DashView::FadeInCallBack));
+
+    fade_in_value_ = 1.0f;
+    animation_.SetStartValue(fade_in_value_);
+    animation_.SetFinishValue(0.0f);
+    animation_.Start();
+  }
+
   preview_displaying_ = false;
 
-  // sanity check
-  if (!preview_container_)
-    return;
-  RemoveChild(preview_container_.GetPointer());
-  preview_container_->UnParentObject();
-  preview_container_.Release(); // free resources
-  preview_state_machine_.ClosePreview();
-
   // re-focus dash view component.
   nux::GetWindowCompositor().SetKeyFocusArea(default_focus());
   QueueDraw();
 }
 
+void DashView::FadeOutCallBack(float const& fade_out_value)
+{
+  fade_out_value_ = fade_out_value;
+  QueueDraw();
+}
+
+void DashView::FadeInCallBack(float const& fade_in_value)
+{
+  fade_in_value_ = fade_in_value;
+  QueueDraw();
+
+  if (fade_in_value_ == 0.0f)
+  {
+    // sanity check
+    if (!preview_container_)
+    {
+      return;
+    }
+    RemoveChild(preview_container_.GetPointer());
+    preview_container_->UnParentObject();
+    preview_container_.Release(); // free resources
+    preview_state_machine_.ClosePreview();
+
+    // Closing the preview. Set  opening_row_y_ to -1;
+    // opening_row_y_ is updated once when the preview
+    opening_row_y_ = -1;
+  }
+}
+
 void DashView::BuildPreview(Preview::Ptr model)
 {
   if (!preview_displaying_)
   {
+    // Make a copy of this DashView backup texture.
+    if (layout_->RedirectRenderingToTexture())
+    {
+      nux::TexCoordXForm texxform;
+      nux::ObjectPtr<nux::IOpenGLBaseTexture> src_texture;
+
+      layout_copy_ = src_texture = layout_->BackupTexture();
+
+      animation_.Stop();
+      fade_out_connection_.disconnect();
+      fade_in_connection_.disconnect();
+      // Set fade animation
+      animation_.SetDuration(250);
+      animation_.SetEasingCurve(na::EasingCurve(na::EasingCurve::Type::ExpoEaseIn));
+      fade_out_connection_ = animation_.updated.connect(sigc::mem_fun(this, &DashView::FadeOutCallBack));
+
+      fade_out_value_ = 1.0f;
+      animation_.SetStartValue(fade_out_value_);
+      animation_.SetFinishValue(0.0f);
+      animation_.Start();
+
+      layout_->SetPresentRedirectedView(false);
+    }
+
     preview_container_ = previews::PreviewContainer::Ptr(new previews::PreviewContainer());
     AddChild(preview_container_.GetPointer());
     preview_container_->SetParentObject(this);
@@ -261,6 +348,7 @@
   layout_->SetLeftAndRightPadding(style.GetVSeparatorSize(), 0);
   layout_->SetTopAndBottomPadding(style.GetHSeparatorSize(), 0);
   SetLayout(layout_);
+  layout_->SetRedirectRenderingToTexture(true);
 
   content_layout_ = new DashLayout(NUX_TRACKER_LOCATION);
   content_layout_->SetTopAndBottomPadding(style.GetDashViewTopPadding(), 0);
@@ -310,12 +398,21 @@
   ubus_manager_.RegisterInterest(UBUS_DASH_PREVIEW_INFO_PAYLOAD, [&] (GVariant *data) 
   {
     int position = -1;
+    int row_height = 0;
     int results_to_the_left = 0;
     int results_to_the_right = 0;
-    g_variant_get(data, "(iii)", &position, &results_to_the_left, &results_to_the_right);
+    g_variant_get(data, "(iiii)", &position, &row_height, &results_to_the_left, &results_to_the_right);
     preview_state_machine_.SetSplitPosition(SplitPosition::CONTENT_AREA, position);
     preview_state_machine_.left_results = results_to_the_left;
     preview_state_machine_.right_results = results_to_the_right;
+
+    if (opening_row_y_ == -1)
+    {
+      // Update only when opening the previews
+      opening_row_y_ = position;
+    }
+    opening_row_height_ = row_height;
+
   });
 }
 
@@ -394,27 +491,268 @@
   return nux::Geometry(0, 0, width, height);
 }
 
-void DashView::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
+void DashView::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
-  renderer_.DrawFull(gfx_context, content_geo_, GetAbsoluteGeometry(), GetGeometry());
+  renderer_.DrawFull(graphics_engine, content_geo_, GetAbsoluteGeometry(), GetGeometry());
 }
 
-void DashView::DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw)
+void DashView::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
-  renderer_.DrawInner(gfx_context, content_geo_, GetAbsoluteGeometry(), GetGeometry());
+  renderer_.DrawInner(graphics_engine, content_geo_, GetAbsoluteGeometry(), GetGeometry());
+
+  bool display_ghost = false;
+  bool preview_redraw = false;
+  if (preview_container_)
+  {
+    preview_redraw = preview_container_->IsRedrawNeeded();
+  }
+
+  if (!preview_displaying_ && layout_->RedirectRenderingToTexture() && (fade_in_value_ == 0.0f))
+  {
+    nux::Geometry layout_geo = layout_->GetGeometry();
+    graphics_engine.PushClippingRectangle(layout_geo);
+    nux::GetPainter().PaintBackground(graphics_engine, layout_geo);
+    graphics_engine.PopClippingRectangle();
+  }
+
+  if (preview_displaying_ && (IsFullRedraw() || force_draw || preview_redraw) && layout_->RedirectRenderingToTexture())
+  {
+    display_ghost = true;
+    nux::Geometry layout_geo = layout_->GetGeometry();
+    graphics_engine.PushClippingRectangle(layout_geo);
+    nux::GetPainter().PaintBackground(graphics_engine, layout_geo);
+    graphics_engine.PopClippingRectangle();
+  }
 
   if (IsFullRedraw())
+  {
     nux::GetPainter().PushBackgroundStack();
+  }
+
 
   if (preview_displaying_)
-   preview_container_->ProcessDraw(gfx_context, (!force_draw) ? IsFullRedraw() : force_draw);
-  else
-    layout_->ProcessDraw(gfx_context, force_draw);
+  {
+    // Progressively reveal the preview.
+    nux::Geometry preview_clip_geo = preview_container_->GetGeometry();
+    preview_clip_geo.y = (preview_clip_geo.y + preview_clip_geo.height)/2.0f - 
+      (1.0f - fade_out_value_) * (preview_clip_geo.height)/2.0f;
+    preview_clip_geo.height = (1.0f - fade_out_value_) * (preview_clip_geo.height);
+
+    graphics_engine.PushModelViewMatrix(nux::Matrix4::TRANSLATE(-preview_container_->GetWidth()/2.0f, -preview_container_->GetHeight()/2.0f, 0));
+    graphics_engine.PushModelViewMatrix(nux::Matrix4::SCALE(1.0f - fade_out_value_, 1.0f - fade_out_value_, 1.0f));
+    graphics_engine.PushModelViewMatrix(nux::Matrix4::TRANSLATE(preview_container_->GetWidth()/2.0f, preview_container_->GetHeight()/2.0f, 0));
+
+    preview_container_->ProcessDraw(graphics_engine, (!force_draw) ? IsFullRedraw() : force_draw);
+
+    graphics_engine.PopModelViewMatrix();
+    graphics_engine.PopModelViewMatrix();
+    graphics_engine.PopModelViewMatrix();
+  }
+  else if (fade_in_value_ > 0.0f && preview_container_ && preview_container_.IsValid())
+  {
+    graphics_engine.PushModelViewMatrix(nux::Matrix4::TRANSLATE(-preview_container_->GetWidth()/2.0f, -preview_container_->GetHeight()/2.0f, 0));
+    graphics_engine.PushModelViewMatrix(nux::Matrix4::SCALE(fade_in_value_, fade_in_value_, 1.0f));
+    graphics_engine.PushModelViewMatrix(nux::Matrix4::TRANSLATE(preview_container_->GetWidth()/2.0f, preview_container_->GetHeight()/2.0f, 0));
+
+    preview_container_->ProcessDraw(graphics_engine, (!force_draw) ? IsFullRedraw() : force_draw);
+
+    graphics_engine.PopModelViewMatrix();
+    graphics_engine.PopModelViewMatrix();
+    graphics_engine.PopModelViewMatrix();
+  }
+  else if (fade_in_value_ == 0.0f)
+  {
+    layout_->ProcessDraw(graphics_engine, force_draw);
+  }
+  
+  // Animation effect rendering
+  if (display_ghost || IsFullRedraw())
+  {
+    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);
+
+    float ghost_opacity = 0.25f;    
+    float tint_factor = 1.2f;
+    float saturation_ref = 0.4f;
+    nux::Color bg_color = background_color_;
+
+    int position_offset = 40;
+
+    if (preview_displaying_ && layout_ && layout_->RedirectRenderingToTexture())
+    {
+      if (layout_copy_.IsValid())
+      {
+        graphics_engine.PushClippingRectangle(layout_->GetGeometry());
+        graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+        nux::TexCoordXForm texxform;
+
+        texxform.FlipVCoord(true);
+
+        int filter_width = 10;
+        if (active_lens_view_ && active_lens_view_->filters_expanded)
+        {
+          texxform.uoffset = (active_lens_view_->filter_bar()->GetX() -layout_->GetX())/(float)layout_->GetWidth();
+          texxform.voffset = (active_lens_view_->filter_bar()->GetY() -layout_->GetY())/(float)layout_->GetHeight();
+
+          texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+          graphics_engine.QRP_1Tex(
+            active_lens_view_->filter_bar()->GetX() + (1.0f - fade_out_value_)*(active_lens_view_->filter_bar()->GetWidth() + 10),
+            active_lens_view_->filter_bar()->GetY(),
+            active_lens_view_->filter_bar()->GetWidth(),
+            active_lens_view_->filter_bar()->GetHeight(),
+            layout_copy_, texxform,
+            nux::Color(fade_out_value_, fade_out_value_, fade_out_value_, fade_out_value_)
+            );
+          filter_width += active_lens_view_->filter_bar()->GetWidth();
+        }  
+
+        float saturation = fade_out_value_ + (1.0f - fade_out_value_) * saturation_ref;
+        float opacity = fade_out_value_ < ghost_opacity ? ghost_opacity : fade_out_value_;
+        nux::Color tint = nux::Color(
+          fade_out_value_ + (1.0f - fade_out_value_) * tint_factor*bg_color.red,
+          fade_out_value_ + (1.0f - fade_out_value_) * tint_factor*bg_color.green,
+          fade_out_value_ + (1.0f - fade_out_value_) * tint_factor*bg_color.blue,
+          1.0f);
+
+        // Ghost row of items above the preview
+        {
+          int final_x = layout_->GetX();
+          int final_y = layout_->GetY() - (opening_row_y_) - position_offset ;
+
+          texxform.uoffset = 0.0f;
+          texxform.voffset = 0.0f;
+          texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+          graphics_engine.QRP_TexDesaturate(
+            fade_out_value_ * layout_->GetX() + (1.0f - fade_out_value_) * final_x,
+            fade_out_value_ * layout_->GetY() + (1.0f - fade_out_value_) * final_y,
+            layout_->GetWidth() - filter_width,
+            opening_row_y_ + opening_row_height_,
+            layout_copy_, texxform,
+            nux::Color(tint.red, tint.green, tint.blue, opacity),
+            saturation
+            );
+        }
+
+        // Ghost row of items below the preview
+        {
+          int final_x = layout_->GetX();
+          int final_y = layout_->GetY() + layout_->GetHeight() - (position_offset*1.9);
+
+          texxform.uoffset = (layout_->GetX() - layout_->GetX())/(float)layout_->GetWidth();
+          texxform.voffset = (opening_row_y_ + opening_row_height_ - layout_->GetY())/(float)layout_->GetHeight();
+          texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+          graphics_engine.QRP_TexDesaturate(
+            fade_out_value_ * layout_->GetX() + (1 - fade_out_value_) * final_x,
+            fade_out_value_ * (opening_row_y_ + opening_row_height_) + (1 - fade_out_value_) * final_y,
+            layout_->GetWidth() - filter_width,
+            layout_->GetHeight() - opening_row_y_ - opening_row_height_,
+            layout_copy_, texxform,
+            nux::Color(tint.red, tint.green, tint.blue, opacity),
+            saturation
+            );
+        }
+
+        graphics_engine.GetRenderStates().SetBlend(false);
+        graphics_engine.PopClippingRectangle();
+      }
+
+
+    }
+    else if (layout_ && layout_->RedirectRenderingToTexture() && fade_in_value_ != 0.0f)
+    {
+      if (layout_copy_.IsValid())
+      {
+        graphics_engine.PushClippingRectangle(layout_->GetGeometry());
+        graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+        nux::TexCoordXForm texxform;
+
+        texxform.FlipVCoord(true);
+
+        int filter_width = 10;
+        if (active_lens_view_ && active_lens_view_->filters_expanded)
+        {
+          texxform.uoffset = (active_lens_view_->filter_bar()->GetX() -layout_->GetX())/(float)layout_->GetWidth();
+          texxform.voffset = (active_lens_view_->filter_bar()->GetY() -layout_->GetY())/(float)layout_->GetHeight();
+
+          texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+          graphics_engine.QRP_1Tex(
+            active_lens_view_->filter_bar()->GetX() + (fade_in_value_)*(active_lens_view_->filter_bar()->GetWidth() + 10),
+            active_lens_view_->filter_bar()->GetY(),
+            active_lens_view_->filter_bar()->GetWidth(),
+            active_lens_view_->filter_bar()->GetHeight(),
+            layout_copy_, texxform,
+            nux::Color(1.0f - fade_in_value_, 1.0f - fade_in_value_, 1.0f - fade_in_value_, 1.0f - fade_in_value_)
+            );
+          filter_width += active_lens_view_->filter_bar()->GetWidth();
+        }
+
+        float saturation = fade_in_value_ * saturation_ref + (1.0f - fade_in_value_);
+        float opacity = (1.0f - fade_in_value_) < ghost_opacity ? ghost_opacity : (1.0f - fade_in_value_);
+        nux::Color tint = nux::Color(
+          fade_in_value_ * tint_factor*bg_color.red + (1.0f - fade_in_value_),
+          fade_in_value_ * tint_factor*bg_color.green + (1.0f - fade_in_value_),
+          fade_in_value_ * tint_factor*bg_color.blue + (1.0f - fade_in_value_),
+          1.0f);
+
+        // Ghost row of items above the preview
+        {
+          int final_x = layout_->GetX();
+          int final_y = layout_->GetY() - (opening_row_y_) - position_offset;
+
+          texxform.uoffset = 0.0f;
+          texxform.voffset = 0.0f;
+          texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+          graphics_engine.QRP_TexDesaturate(
+            (1.0f - fade_in_value_) * layout_->GetX() + (fade_in_value_) * final_x,
+            (1.0f - fade_in_value_) * layout_->GetY() + (fade_in_value_) * final_y,
+            layout_->GetWidth() - filter_width,
+            opening_row_y_ + opening_row_height_,
+            layout_copy_, texxform,
+            nux::Color(tint.red, tint.green, tint.blue, opacity),
+            saturation
+            );
+        }
+
+        // Ghost row of items below the preview
+        {
+          int final_x = layout_->GetX();
+          int final_y = layout_->GetY() + layout_->GetHeight() -(position_offset*1.9);
+
+          texxform.uoffset = (layout_->GetX() - layout_->GetX())/(float)layout_->GetWidth();
+          texxform.voffset = (opening_row_y_ + opening_row_height_ - layout_->GetY())/(float)layout_->GetHeight();
+          texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+          graphics_engine.QRP_TexDesaturate(
+            (1.0f - fade_in_value_) * layout_->GetX() + (fade_in_value_) * final_x,
+            (1.0f - fade_in_value_) * (opening_row_y_ + opening_row_height_) + (fade_in_value_) * final_y,
+            layout_->GetWidth() - filter_width,
+            layout_->GetHeight() - opening_row_y_ - opening_row_height_,
+            layout_copy_, texxform,
+            nux::Color(tint.red, tint.green, tint.blue, opacity),
+            saturation
+            );
+        }
+        graphics_engine.GetRenderStates().SetBlend(false);
+        graphics_engine.PopClippingRectangle();
+      }
+    }
+
+    graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+  }
 
   if (IsFullRedraw())
+  {
     nux::GetPainter().PopBackgroundStack();
+  }
 
-  renderer_.DrawInnerCleanup(gfx_context, content_geo_, GetAbsoluteGeometry(), GetGeometry());
+  renderer_.DrawInnerCleanup(graphics_engine, content_geo_, GetAbsoluteGeometry(), GetGeometry());
 }
 
 void DashView::OnMouseButtonDown(int x, int y, unsigned long button, unsigned long key)

=== modified file 'dash/DashView.h'
--- dash/DashView.h	2012-08-17 07:28:10 +0000
+++ dash/DashView.h	2012-09-18 14:01:19 +0000
@@ -23,6 +23,8 @@
 #include <Nux/PaintLayer.h>
 #include <Nux/View.h>
 #include <Nux/VLayout.h>
+#include <Nux/NuxTimerTickSource.h>
+
 #include <UnityCore/FilesystemLenses.h>
 #include <UnityCore/HomeLens.h>
 #include <UnityCore/GLibSource.h>
@@ -30,6 +32,7 @@
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/SearchBar.h"
 #include "unity-shared/Introspectable.h"
+#include "unity-shared/BGHash.h"
 #include "LensBar.h"
 #include "LensView.h"
 #include "unity-shared/UBusWrapper.h"
@@ -38,6 +41,8 @@
 #include "previews/PreviewContainer.h"
 #include "PreviewStateMachine.h"
 
+namespace na = nux::animation;
+
 namespace unity
 {
 namespace dash
@@ -79,7 +84,7 @@
 private:
   void SetupViews();
   void SetupUBusConnections();
-
+  void OnBGColorChanged(GVariant *data);
   nux::Geometry GetBestFitGeometry(nux::Geometry const& for_geo);
 
   void Draw(nux::GraphicsEngine& gfx_context, bool force_draw);
@@ -150,6 +155,28 @@
 
   glib::Source::UniquePtr searching_timeout_;
   glib::Source::UniquePtr hide_message_delay_;
+
+  nux::ObjectPtr<nux::IOpenGLBaseTexture> dash_view_copy_;
+  nux::ObjectPtr<nux::IOpenGLBaseTexture> search_view_copy_;
+  nux::ObjectPtr<nux::IOpenGLBaseTexture> filter_view_copy_;
+  nux::ObjectPtr<nux::IOpenGLBaseTexture> layout_copy_;
+
+  float fade_out_value_;
+  float fade_in_value_;
+  std::unique_ptr<nux::NuxTimerTickSource> tick_source_;
+  std::unique_ptr<na::AnimationController> animation_controller_;
+  na::AnimateValue<float> animation_;
+
+  void FadeOutCallBack(float const& fade_out_value);
+  void FadeInCallBack(float const& fade_out_value);
+
+  int opening_row_y_;
+  int opening_row_height_;
+
+  sigc::connection fade_in_connection_;
+  sigc::connection fade_out_connection_;
+
+  nux::Color background_color_;
 };
 
 

=== modified file 'dash/FilterAllButton.cpp'
--- dash/FilterAllButton.cpp	2012-09-13 17:33:52 +0000
+++ dash/FilterAllButton.cpp	2012-09-18 14:01:19 +0000
@@ -38,6 +38,10 @@
   SetInputEventSensitivity(false);
 
   state_change.connect(sigc::mem_fun(this, &FilterAllButton::OnStateChanged));
+  
+  SetRedirectRenderingToTexture(true);
+  //SetCopyPreviousFboTexture(false);
+  SetClearBeforeDraw(true);
 }
 
 FilterAllButton::~FilterAllButton()

=== modified file 'dash/FilterBar.cpp'
--- dash/FilterBar.cpp	2012-09-13 13:15:29 +0000
+++ dash/FilterBar.cpp	2012-09-18 14:01:19 +0000
@@ -99,21 +99,16 @@
   }
 }
 
-void FilterBar::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+void FilterBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
-  nux::Geometry const& geo = GetGeometry();
 
-  GfxContext.PushClippingRectangle(geo);
-  nux::GetPainter().PaintBackground(GfxContext, geo);
-  GfxContext.PopClippingRectangle();
 }
 
-void FilterBar::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+void FilterBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
-  GfxContext.PushClippingRectangle(GetGeometry());
-  GetLayout()->ProcessDraw(GfxContext, force_draw);
-
-  GfxContext.PopClippingRectangle();
+  graphics_engine.PushClippingRectangle(GetGeometry());
+  GetLayout()->ProcessDraw(graphics_engine, force_draw);
+  graphics_engine.PopClippingRectangle();
 }
 
 //

=== modified file 'dash/FilterBasicButton.cpp'
--- dash/FilterBasicButton.cpp	2012-09-13 17:46:04 +0000
+++ dash/FilterBasicButton.cpp	2012-09-18 14:01:19 +0000
@@ -71,6 +71,8 @@
   SetAcceptKeyNavFocusOnMouseDown(false);
   SetAcceptKeyNavFocusOnMouseEnter(true);
 
+  clear_before_draw_ = true;
+
   key_nav_focus_change.connect([&] (nux::Area*, bool, nux::KeyNavDirection)
   {
     QueueDraw();
@@ -128,11 +130,15 @@
   return ret;
 }
 
-void FilterBasicButton::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+void FilterBasicButton::SetClearBeforeDraw(bool clear_before_draw)
+{
+  clear_before_draw_ = clear_before_draw;
+}
+
+void FilterBasicButton::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& geo = GetGeometry();
 
-  gPainter.PaintBackground(GfxContext, geo);
   // set up our texture mode
   nux::TexCoordXForm texxform;
   texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
@@ -140,12 +146,19 @@
 
   // clear what is behind us
   unsigned int alpha = 0, src = 0, dest = 0;
-  GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
-  GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+  graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
+  if (RedirectedAncestor() && clear_before_draw_)
+  {
+    // This is necessary when doing redirected rendering.
+    // Clean the area below this view before drawing anything.
+    graphics_engine.GetRenderStates().SetBlend(false);
+    graphics_engine.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+  }
+  graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
   nux::Color col = nux::color::Black;
   col.alpha = 0;
-  GfxContext.QRP_Color(geo.x,
+  graphics_engine.QRP_Color(geo.x,
                        geo.y,
                        geo.width,
                        geo.height,
@@ -159,7 +172,7 @@
   else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRESSED)
     texture = active_->GetTexture();
 
-  GfxContext.QRP_1Tex(geo.x,
+  graphics_engine.QRP_1Tex(geo.x,
                       geo.y,
                       geo.width,
                       geo.height,
@@ -169,7 +182,7 @@
 
   if (HasKeyboardFocus())
   {
-    GfxContext.QRP_1Tex(geo.x,
+    graphics_engine.QRP_1Tex(geo.x,
                         geo.y,
                         geo.width,
                         geo.height,
@@ -178,7 +191,7 @@
                         nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
   }
 
-  GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
+  graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
 }
 
 } // namespace dash

=== modified file 'dash/FilterBasicButton.h'
--- dash/FilterBasicButton.h	2012-05-06 23:48:38 +0000
+++ dash/FilterBasicButton.h	2012-09-18 14:01:19 +0000
@@ -40,6 +40,7 @@
   FilterBasicButton(NUX_FILE_LINE_PROTO);
   virtual ~FilterBasicButton();
 
+  void SetClearBeforeDraw(bool clear_before_draw);
 protected:
   virtual long ComputeContentSize();
   virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
@@ -60,6 +61,7 @@
 
 private:
   std::string label_;
+  bool clear_before_draw_;
 };
 
 } // namespace dash

=== modified file 'dash/FilterExpanderLabel.cpp'
--- dash/FilterExpanderLabel.cpp	2012-09-14 16:53:45 +0000
+++ dash/FilterExpanderLabel.cpp	2012-09-18 14:01:19 +0000
@@ -257,12 +257,22 @@
   return ((expander_view_ && expander_view_->HasKeyFocus()));
 }
 
-void FilterExpanderLabel::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+void FilterExpanderLabel::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& base = GetGeometry();
 
-  GfxContext.PushClippingRectangle(base);
-  nux::GetPainter().PaintBackground(GfxContext, base);
+  graphics_engine.PushClippingRectangle(base);
+
+  if (RedirectedAncestor())
+  {
+    unsigned int alpha = 0, src = 0, dest = 0;
+    graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
+    // This is necessary when doing redirected rendering.
+    // Clean the area below this view before drawing anything.
+    graphics_engine.GetRenderStates().SetBlend(false);
+    graphics_engine.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+    graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
+  }
 
   if (ShouldBeHighlighted())
   {
@@ -274,23 +284,46 @@
       highlight_layer_.reset(dash::Style::Instance().FocusOverlay(geo.width, geo.height));
 
     highlight_layer_->SetGeometry(geo);
-    highlight_layer_->Renderlayer(GfxContext);
+    highlight_layer_->Renderlayer(graphics_engine);
   }
 
-  GfxContext.PopClippingRectangle();
+  graphics_engine.PopClippingRectangle();
 }
 
-void FilterExpanderLabel::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+void FilterExpanderLabel::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
-  GfxContext.PushClippingRectangle(GetGeometry());
-
-  if (ShouldBeHighlighted() && highlight_layer_ && !IsFullRedraw())
-  {
-    nux::GetPainter().PushLayer(GfxContext, highlight_layer_->GetGeometry(), highlight_layer_.get());
-  }
-
-  GetLayout()->ProcessDraw(GfxContext, force_draw);
-  GfxContext.PopClippingRectangle();
+  graphics_engine.PushClippingRectangle(GetGeometry());
+
+  if (RedirectedAncestor() && !IsFullRedraw())
+  {
+    unsigned int alpha = 0, src = 0, dest = 0;
+    graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
+    // This is necessary when doing redirected rendering.
+    // Clean the area below this view before drawing anything.
+    graphics_engine.GetRenderStates().SetBlend(false);
+    graphics_engine.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+    graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
+  }
+
+  int pushed_paint_layers = 0;
+  if (RedirectedAncestor())
+  {
+    if (ShouldBeHighlighted() && highlight_layer_ && !IsFullRedraw())
+      nux::GetPainter().RenderSinglePaintLayer(graphics_engine, highlight_layer_->GetGeometry(), highlight_layer_.get());
+  }
+  else if (ShouldBeHighlighted() && highlight_layer_ && !IsFullRedraw())
+  {
+    ++pushed_paint_layers;
+    nux::GetPainter().PushLayer(graphics_engine, highlight_layer_->GetGeometry(), highlight_layer_.get());
+  }
+
+  GetLayout()->ProcessDraw(graphics_engine, true);
+  graphics_engine.PopClippingRectangle();
+
+  if (pushed_paint_layers)
+  {
+    nux::GetPainter().PopBackground(pushed_paint_layers);
+  }
 }
 
 //

=== modified file 'dash/FilterMultiRangeButton.cpp'
--- dash/FilterMultiRangeButton.cpp	2012-05-06 23:48:38 +0000
+++ dash/FilterMultiRangeButton.cpp	2012-09-18 14:01:19 +0000
@@ -226,6 +226,13 @@
   // clear what is behind us
   unsigned int alpha = 0, src = 0, dest = 0;
   GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
+  if (RedirectedAncestor())
+  {
+    // This is necessary when doing redirected rendering.
+    // Clean the area below this view before drawing anything.
+    GfxContext.GetRenderStates().SetBlend(false);
+    GfxContext.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+  }
   GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
   nux::Color col = nux::color::Black;

=== modified file 'dash/FilterRatingsButton.cpp'
--- dash/FilterRatingsButton.cpp	2012-07-25 20:08:22 +0000
+++ dash/FilterRatingsButton.cpp	2012-09-18 14:01:19 +0000
@@ -107,6 +107,13 @@
   unsigned int alpha = 0, src = 0, dest = 0;
 
   GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
+  if (RedirectedAncestor())
+  {
+    // This is necessary when doing redirected rendering.
+    // Clean the area below this view before drawing anything.
+    GfxContext.GetRenderStates().SetBlend(false);
+    GfxContext.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+  }
   GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
   nux::Color col = nux::color::Black;

=== modified file 'dash/LensBar.cpp'
--- dash/LensBar.cpp	2012-09-13 10:56:42 +0000
+++ dash/LensBar.cpp	2012-09-18 14:01:19 +0000
@@ -104,32 +104,49 @@
   }
 }
 
-void LensBar::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
+void LensBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& base = GetGeometry();
 
-  gfx_context.PushClippingRectangle(base);
-  nux::GetPainter().PaintBackground(gfx_context, base);
+  graphics_engine.PushClippingRectangle(base);
 
   bg_layer_->SetGeometry(base);
-  nux::GetPainter().RenderSinglePaintLayer(gfx_context, base, bg_layer_.get());
+  nux::GetPainter().RenderSinglePaintLayer(graphics_engine, base, bg_layer_.get());
 
-  gfx_context.PopClippingRectangle();
+  graphics_engine.PopClippingRectangle();
 }
 
-void LensBar::DrawContent(nux::GraphicsEngine& gfx_context, bool force_draw)
+void LensBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& base = GetGeometry();
 
-  gfx_context.PushClippingRectangle(base);
-
-  if (!IsFullRedraw())
-    nux::GetPainter().PushLayer(gfx_context, bg_layer_->GetGeometry(), bg_layer_.get());
-
-  layout_->ProcessDraw(gfx_context, force_draw);
-
-  if (!IsFullRedraw())
-    nux::GetPainter().PopBackground();
+  graphics_engine.PushClippingRectangle(base);
+
+  int pushed_paint_layers = 0;
+  if(RedirectedAncestor())
+  {
+    {
+      unsigned int alpha = 0, src = 0, dest = 0;
+      graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
+      // This is necessary when doing redirected rendering.
+      // Clean the area below this view before drawing anything.
+      graphics_engine.GetRenderStates().SetBlend(false);
+      graphics_engine.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+      graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
+    }
+
+    nux::GetPainter().RenderSinglePaintLayer(graphics_engine, bg_layer_->GetGeometry(), bg_layer_.get());
+  }
+  else if (!IsFullRedraw())
+  {
+    ++pushed_paint_layers;
+    nux::GetPainter().PushLayer(graphics_engine, bg_layer_->GetGeometry(), bg_layer_.get());
+  }
+
+  layout_->ProcessDraw(graphics_engine, true);
+
+  if (pushed_paint_layers)
+    nux::GetPainter().PopBackground(pushed_paint_layers);
 
   for (auto icon: icons_)
   {
@@ -142,7 +159,7 @@
       // bigger one and clip part of them using the "-1".
       int y = base.y - 1;
 
-      nux::GetPainter().Draw2DTriangleColor(gfx_context,
+      nux::GetPainter().Draw2DTriangleColor(graphics_engine,
                                             middle - size, y,
                                             middle, y + size,
                                             middle + size, y,
@@ -152,7 +169,7 @@
     }
   }
 
-  gfx_context.PopClippingRectangle();
+  graphics_engine.PopClippingRectangle();
 }
 
 void LensBar::SetActive(LensBarIcon* activated)

=== modified file 'dash/LensBarIcon.cpp'
--- dash/LensBarIcon.cpp	2012-05-06 23:48:38 +0000
+++ dash/LensBarIcon.cpp	2012-09-18 14:01:19 +0000
@@ -58,21 +58,21 @@
 
   active.changed.connect(sigc::mem_fun(this, &LensBarIcon::OnActiveChanged));
   key_nav_focus_change.connect([&](nux::Area*, bool, nux::KeyNavDirection){ QueueDraw(); });
+  SetRedirectRenderingToTexture(true);
 }
 
 LensBarIcon::~LensBarIcon()
 {}
 
-void LensBarIcon::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
+void LensBarIcon::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& geo = GetGeometry();
 
-  gfx_context.PushClippingRectangle(geo);
-  nux::GetPainter().PaintBackground(gfx_context, geo);
+  graphics_engine.PushClippingRectangle(geo);
 
   if (!texture())
   {
-    gfx_context.PopClippingRectangle();
+    graphics_engine.PopClippingRectangle();
     return;
   }
 
@@ -82,7 +82,7 @@
     nux::AbstractPaintLayer* layer = focus_layer_.get();
 
     layer->SetGeometry(geo);
-    layer->Renderlayer(gfx_context);
+    layer->Renderlayer(graphics_engine);
   }
 
   float opacity = active ? 1.0f : inactive_opacity_;
@@ -94,7 +94,7 @@
   texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
   texxform.SetWrap(nux::TEXWRAP_CLAMP_TO_BORDER, nux::TEXWRAP_CLAMP_TO_BORDER);
 
-  gfx_context.QRP_1Tex(geo.x + ((geo.width - width) / 2),
+  graphics_engine.QRP_1Tex(geo.x + ((geo.width - width) / 2),
                        geo.y + ((geo.height - height) / 2),
                        width,
                        height,
@@ -102,7 +102,7 @@
                        texxform,
                        col);
 
-  gfx_context.PopClippingRectangle();
+  graphics_engine.PopClippingRectangle();
 }
 
 void LensBarIcon::OnActiveChanged(bool is_active)

=== modified file 'dash/LensView.cpp'
--- dash/LensView.cpp	2012-09-14 14:59:09 +0000
+++ dash/LensView.cpp	2012-09-18 14:01:19 +0000
@@ -174,7 +174,6 @@
         if ((child && child->HasKeyFocus()) ||
             (expand_label && expand_label->HasKeyFocus()))
         {
-
           focused_pos.x += child->GetGeometry().x;
           focused_pos.y += child->GetGeometry().y - 30;
           focused_pos.height += 30;
@@ -200,7 +199,7 @@
   scroll_view_->EnableHorizontalScrollBar(false);
   layout_->AddView(scroll_view_);
 
-  scroll_view_->OnGeometryChanged.connect([this] (nux::Area *area, nux::Geometry& geo)
+  scroll_view_->geometry_changed.connect([this] (nux::Area *area, nux::Geometry& geo)
   {
     CheckScrollBarState();
   });

=== modified file 'dash/PlacesGroup.cpp'
--- dash/PlacesGroup.cpp	2012-09-17 10:00:38 +0000
+++ dash/PlacesGroup.cpp	2012-09-18 14:01:19 +0000
@@ -458,10 +458,29 @@
 void PlacesGroup::Draw(nux::GraphicsEngine& graphics_engine,
                        bool                 forceDraw)
 {
+
+}
+
+void
+PlacesGroup::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
+{
   nux::Geometry const& base = GetGeometry();
   graphics_engine.PushClippingRectangle(base);
 
-
+  if (RedirectedAncestor())
+  {
+    // This is necessary when doing redirected rendering. Clean the area below this view.
+    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);
+
+    graphics_engine.GetRenderStates().SetBlend(false);
+    graphics_engine.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+
+    graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+  }
+  
   if (ShouldBeHighlighted())
   {
     nux::Geometry geo(_header_layout->GetGeometry());
@@ -486,41 +505,11 @@
   
   _background_layer->SetGeometry(bg_geo);
   _background_layer->Renderlayer(graphics_engine);
-  graphics_engine.PopClippingRectangle();
-}
-
-void
-PlacesGroup::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
-{
-  nux::Geometry const& base = GetGeometry();
-
-  graphics_engine.PushClippingRectangle(base);
-  nux::Geometry bg_geo = GetGeometry();
-  
-  int bg_width = 0;
-  if (_using_nofilters_background)
-    bg_width = _background_nofilters->GetWidth();
-  else
-    bg_width = _background->GetWidth();
-  
-  // if the dash is smaller, resize to fit, otherwise move to the right edge
-  bg_geo.x = std::max(bg_geo.width - bg_width, 0);
-  bg_geo.width = std::min(bg_width, bg_geo.GetWidth()) + 1; // to render into a space left over by the scrollview
-  
-  bg_geo.height = _background->GetHeight();
-
-  if (!IsFullRedraw())
-  {
-    nux::GetPainter().PushLayer(graphics_engine, bg_geo, _background_layer.get());
-  }
-  if (ShouldBeHighlighted() && !IsFullRedraw() && _focus_layer)
-  {
-    nux::GetPainter().PushLayer(graphics_engine, _focus_layer->GetGeometry(), _focus_layer.get());
-  }
-
-  _group_layout->ProcessDraw(graphics_engine, force_draw);
-
-  graphics_engine.PopClippingRectangle();
+
+  _group_layout->ProcessDraw(graphics_engine, true);
+
+  graphics_engine.PopClippingRectangle();
+
 }
 
 void PlacesGroup::PostDraw(nux::GraphicsEngine& graphics_engine,

=== modified file 'dash/ResultViewGrid.cpp'
--- dash/ResultViewGrid.cpp	2012-08-20 14:21:31 +0000
+++ dash/ResultViewGrid.cpp	2012-09-18 14:01:19 +0000
@@ -143,10 +143,28 @@
                           << " " << activated_uri_;
         int left_results = current_index;
         int right_results = num_results ? (num_results - current_index) - 1 : 0;
+
+        int row_y = padding + GetRootGeometry().y;
+        int row_size = renderer_->height + vertical_spacing;
+        int row_height = row_size;
+
+        if (GetItemsPerRow())
+        {
+          int num_row = GetNumResults() / GetItemsPerRow();
+          if (GetNumResults() % GetItemsPerRow())
+          {
+            ++num_row;
+          }
+          int row_index = current_index / GetItemsPerRow();
+
+          row_y += row_index * row_size;
+        }
+        
         ubus_.SendMessage(UBUS_DASH_PREVIEW_INFO_PAYLOAD, 
-                                g_variant_new("(iii)", 0, left_results, right_results));
+                                g_variant_new("(iiii)", row_y, row_height, left_results, right_results));
         UriActivated.emit(activated_uri_, ActivateType::PREVIEW);
       }
+
     }
 
     g_free(uri);
@@ -691,8 +709,24 @@
       int left_results = index;
       int right_results = (num_results - index) - 1;
       //FIXME - just uses y right now, needs to use the absolute position of the bottom of the result 
+      // (jay) Here is the fix: Compute the y position of the row where the item is located.
+      int row_y = padding + GetRootGeometry().y;
+      int row_size = renderer_->height + vertical_spacing;
+      int row_height = row_size;
+
+      if (GetItemsPerRow())
+      {
+        int num_row = GetNumResults() / GetItemsPerRow();
+        if (GetNumResults() % GetItemsPerRow())
+        {
+          ++num_row;
+        }
+        int row_index = index / GetItemsPerRow();
+
+        row_y += row_index * row_size;
+      }
       ubus_.SendMessage(UBUS_DASH_PREVIEW_INFO_PAYLOAD, 
-                                g_variant_new("(iii)", y, left_results, right_results));
+                                g_variant_new("(iiii)", row_y, row_height, left_results, right_results));
     }
     else
     {

=== modified file 'dash/previews/PreviewContainer.cpp'
--- dash/previews/PreviewContainer.cpp	2012-09-18 09:05:50 +0000
+++ dash/previews/PreviewContainer.cpp	2012-09-18 14:01:19 +0000
@@ -70,7 +70,7 @@
   , nav_complete_(0)
   , relative_nav_index_(0)
   {
-    OnGeometryChanged.connect([&](nux::Area*, nux::Geometry& geo)
+    geometry_changed.connect([&](nux::Area*, nux::Geometry& geo)
     {
       // Need to update the preview geometries when updating the container geo.
       UpdateAnimationProgress(progress_, curve_progress_);
@@ -323,7 +323,7 @@
       }
     }
 
-    _queued_draw = false;
+    draw_cmd_queued_ = false;
   }
 
   nux::Area* KeyNavIteration(nux::KeyNavDirection direction)

=== added file 'manual-tests/DashToPreviewTransition.txt'
--- manual-tests/DashToPreviewTransition.txt	1970-01-01 00:00:00 +0000
+++ manual-tests/DashToPreviewTransition.txt	2012-09-18 14:01:19 +0000
@@ -0,0 +1,38 @@
+Preview Open Animation
+----------------------
+This tests the dash animation transition to the preview
+
+Setup:
+#. Open dash super
+#. Open a lens which supports previewing (e.g. Application, Music, File)
+
+Actions:
+#. Right click on an icon in the dash
+
+Expected Result:
+  The central part of the dash split itself up just below the icon that was clicked, to reveal the preview window. It fades out but does not become fully transparent.
+  The Search Entry slides up and fades out.
+  If opened, the Filter Bar slides away to the right and fades.
+  Above the Preview, there is a faded out row of icons that include the icon that was right clicked.
+
+
+Preview Close Animation
+-----------------------
+This tests the preview close animation
+
+Setup:
+#. Open dash super
+#. Open a lens which supports previewing (e.g. Application, Music, File)
+#. Right-click the mouse on an icon to open its preview.
+#. Wait for the preview window to open and finish animating.
+
+Actions:
+#. Press Escape.
+
+Expected Result:
+  The Preview is progressively scaled down and disapears.
+  The search bar slides in from the top.
+  If the Filter Bar was opened when the Preview started, it will slide in from the right 
+  to its normal position.
+  The splitted and faded out dash appears to close itself and regain it full opacity.
+

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-09-18 01:41:46 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-09-18 14:01:19 +0000
@@ -24,6 +24,7 @@
 #include <Nux/HLayout.h>
 #include <Nux/BaseWindow.h>
 #include <Nux/WindowCompositor.h>
+#include <Nux/NuxTimerTickSource.h>
 
 #include "BaseWindowRaiserImp.h"
 #include "IconRenderer.h"
@@ -113,7 +114,6 @@
   , screen(screen)
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
-  , animation_controller_(tick_source_)
   , debugger_(this)
   , enable_shortcut_overlay_(true)
   , needsRelayout(false)
@@ -125,6 +125,7 @@
   , allowWindowPaint(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
+  , _bghash(NULL)
   , grab_index_ (0)
   , painting_tray_ (false)
   , last_scroll_event_(0)
@@ -235,8 +236,16 @@
                                            this));
 #endif
 
+    tick_source_.reset(new nux::NuxTimerTickSource);
+    animation_controller_.reset(new na::AnimationController(*tick_source_));
+
      wt->RedrawRequested.connect(sigc::mem_fun(this, &UnityScreen::onRedrawRequested));
 
+    // _bghash is a pointer. We don't want it to be created before Nux system has had a chance
+    // to start. BGHash relies on animations. Nux animation system starts after the WindowThread
+    // has been created.
+    _bghash = new BGHash();
+
      unity_a11y_init(wt.get());
 
      /* i18n init */
@@ -383,6 +392,7 @@
   unity_a11y_finalize();
   ::unity::ui::IconRenderer::DestroyTextures();
   QuicklistManager::Destroy();
+  delete _bghash;
 
   reset_glib_logging();
 }
@@ -1234,10 +1244,6 @@
 {
   cScreen->preparePaint(ms);
 
-  // Emit the current time throught the tick_source.  This moves any running
-  // animations along their path.
-  tick_source_.tick(g_get_monotonic_time());
-
   for (ShowdesktopHandlerWindowInterface *wi : ShowdesktopHandler::animating_windows)
     wi->HandleAnimations (ms);
 
@@ -1532,7 +1538,8 @@
       if (event->xproperty.window == GDK_ROOT_WINDOW() &&
           event->xproperty.atom == gdk_x11_get_xatom_by_name("_GNOME_BACKGROUND_REPRESENTATIVE_COLORS"))
       {
-        _bghash.RefreshColor();
+        if (_bghash)
+          _bghash->RefreshColor();
       }
       break;
     default:
@@ -2744,7 +2751,8 @@
       override_color.red = override_color.red / override_color.alpha;
       override_color.green = override_color.green / override_color.alpha;
       override_color.blue = override_color.blue / override_color.alpha;
-      _bghash.OverrideColor(override_color);
+      if (_bghash)
+        _bghash->OverrideColor(override_color);
       break;
     }
     case UnityshellOptions::LauncherHideMode:

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-09-18 01:41:46 +0000
+++ plugins/unityshell/src/unityshell.h	2012-09-18 14:01:19 +0000
@@ -245,8 +245,8 @@
   bool TopPanelBackgroundTextureNeedsUpdate() const;
   void UpdateTopPanelBackgroundTexture();
 
-  nux::animation::TickSource tick_source_;
-  nux::animation::AnimationController animation_controller_;
+  std::unique_ptr<nux::NuxTimerTickSource> tick_source_;
+  std::unique_ptr<na::AnimationController> animation_controller_;
 
   Settings dash_settings_;
   dash::Style    dash_style_;
@@ -306,7 +306,7 @@
 
   nux::Property<nux::Geometry> primary_monitor_;
 
-  BGHash _bghash;
+  BGHash* _bghash;
 
   ::GLFramebufferObject *oldFbo;
 

=== modified file 'unity-shared/DashStyle.h'
--- unity-shared/DashStyle.h	2012-09-14 14:59:09 +0000
+++ unity-shared/DashStyle.h	2012-09-18 14:01:19 +0000
@@ -246,9 +246,11 @@
   int GetCategorySeparatorLeftPadding() const;
   int GetCategorySeparatorRightPadding() const;
 
+
   sigc::signal<void> changed;
 
   nux::Property<bool> always_maximised;
+  nux::Property<bool> preview_mode;
 
 private:
   class Impl;

=== modified file 'unity-shared/PlacesVScrollBar.cpp'
--- unity-shared/PlacesVScrollBar.cpp	2012-07-20 13:28:26 +0000
+++ unity-shared/PlacesVScrollBar.cpp	2012-09-18 14:01:19 +0000
@@ -67,15 +67,23 @@
 }
 
 void
-PlacesVScrollBar::Draw(nux::GraphicsEngine& gfxContext, bool force_draw)
+PlacesVScrollBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Color color = nux::color::White;
   nux::Geometry const& base  = GetGeometry();
   nux::TexCoordXForm texxform;
 
-  gfxContext.PushClippingRectangle(base);
+  graphics_engine.PushClippingRectangle(base);
+  unsigned int alpha = 0, src = 0, dest = 0;
+  graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
 
-  nux::GetPainter().PaintBackground(gfxContext, base);
+  if(RedirectedAncestor())
+  {
+    // This is necessary when doing redirected rendering.
+    // Clean the area below this view before drawing anything.
+    graphics_engine.GetRenderStates().SetBlend(false);
+    graphics_engine.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+  }
 
   // check if textures have been computed... if they haven't, exit function
   if (!_slider_texture)
@@ -83,14 +91,14 @@
 
   texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_SCALE_COORD);
 
-  gfxContext.GetRenderStates().SetBlend(true);
-  gfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
+  graphics_engine.GetRenderStates().SetBlend(true);
+  graphics_engine.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
 
   if (content_height_ > container_height_)
   {
     nux::Geometry const& slider_geo = _slider->GetGeometry();
 
-    gfxContext.QRP_1Tex(slider_geo.x,
+    graphics_engine.QRP_1Tex(slider_geo.x,
                         slider_geo.y,
                         slider_geo.width,
                         slider_geo.height,
@@ -99,9 +107,8 @@
                         color);
   }
 
-  gfxContext.GetRenderStates().SetBlend(false);
-  gfxContext.PopClippingRectangle();
-  gfxContext.GetRenderStates().SetBlend(true);
+  graphics_engine.PopClippingRectangle();
+  graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
 }
 
 void PlacesVScrollBar::UpdateTexture()

=== modified file 'unity-shared/SearchBar.cpp'
--- unity-shared/SearchBar.cpp	2012-09-14 16:53:45 +0000
+++ unity-shared/SearchBar.cpp	2012-09-18 14:01:19 +0000
@@ -355,17 +355,16 @@
   }
 }
 
-void SearchBar::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+void SearchBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& base = GetGeometry();
 
   UpdateBackground(false);
 
-  GfxContext.PushClippingRectangle(base);
-  nux::GetPainter().PaintBackground(GfxContext, base);
+  graphics_engine.PushClippingRectangle(base);
 
   bg_layer_->SetGeometry(nux::Geometry(base.x, base.y, last_width_, last_height_));
-  nux::GetPainter().RenderSinglePaintLayer(GfxContext,
+  nux::GetPainter().RenderSinglePaintLayer(graphics_engine,
                                            bg_layer_->GetGeometry(),
                                            bg_layer_.get());
 
@@ -381,35 +380,85 @@
     if (!highlight_layer_)
       highlight_layer_.reset(style.FocusOverlay(geo.width, geo.height));
 
+    if (RedirectedAncestor())
+    {
+      unsigned int alpha = 0, src = 0, dest = 0;
+      graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
+      // This is necessary when doing redirected rendering.
+      // Clean the area below this view before drawing anything.
+      graphics_engine.GetRenderStates().SetBlend(false);
+      graphics_engine.QRP_Color(geo.x, geo.y, geo.width, geo.height, nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+      graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
+    }
+
     highlight_layer_->SetGeometry(geo);
-    highlight_layer_->Renderlayer(GfxContext);
-  }
-
-  GfxContext.PopClippingRectangle();
+    highlight_layer_->Renderlayer(graphics_engine);
+  }
+  else if (expander_view_ && expander_view_->IsVisible())
+  {
+    nux::Geometry geo(expander_view_->GetGeometry());
+
+    geo.y -= (HIGHLIGHT_HEIGHT- geo.height) / 2;
+    geo.height = HIGHLIGHT_HEIGHT;
+
+    if (RedirectedAncestor())
+    {
+      unsigned int alpha = 0, src = 0, dest = 0;
+      graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
+      // This is necessary when doing redirected rendering.
+      // Clean the area below this view before drawing anything.
+      graphics_engine.GetRenderStates().SetBlend(false);
+      graphics_engine.QRP_Color(geo.x, geo.y, geo.width, geo.height, nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+      graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
+    }
+  }
+  graphics_engine.PopClippingRectangle();
 }
 
-void SearchBar::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+void SearchBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   nux::Geometry const& geo = GetGeometry();
 
-  GfxContext.PushClippingRectangle(geo);
+  graphics_engine.PushClippingRectangle(geo);
 
   if (highlight_layer_ && ShouldBeHighlighted() && !IsFullRedraw())
   {
-    nux::GetPainter().PushLayer(GfxContext, highlight_layer_->GetGeometry(), highlight_layer_.get());
+    nux::GetPainter().PushLayer(graphics_engine, highlight_layer_->GetGeometry(), highlight_layer_.get());
   }
 
-
   if (!IsFullRedraw())
   {
-    gPainter.PushLayer(GfxContext, bg_layer_->GetGeometry(), bg_layer_.get());
+    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);
+
+    graphics_engine.GetRenderStates().SetBlend(false);
+    graphics_engine.QRP_Color(
+      pango_entry_->GetX(),
+      pango_entry_->GetY(),
+      pango_entry_->GetWidth(),
+      pango_entry_->GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+
+    if (spinner_->IsRedrawNeeded())
+    {
+      graphics_engine.QRP_Color(
+        spinner_->GetX(),
+        spinner_->GetY(),
+        spinner_->GetWidth(),
+        spinner_->GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+    }
+    
+    graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
+
+    gPainter.PushLayer(graphics_engine, bg_layer_->GetGeometry(), bg_layer_.get());
   }
   else
   {
     nux::GetPainter().PushPaintLayerStack();
   }
 
-  layout_->ProcessDraw(GfxContext, force_draw);
+  layout_->ProcessDraw(graphics_engine, force_draw);
 
   if (!IsFullRedraw())
   {
@@ -420,7 +469,7 @@
     nux::GetPainter().PopPaintLayerStack();
   }
 
-  GfxContext.PopClippingRectangle();
+  graphics_engine.PopClippingRectangle();
 }
 
 void SearchBar::OnClearClicked(int x, int y, unsigned long button_fags,

=== modified file 'unity-shared/UBusMessages.h'
--- unity-shared/UBusMessages.h	2012-09-13 09:15:15 +0000
+++ unity-shared/UBusMessages.h	2012-09-18 14:01:19 +0000
@@ -82,8 +82,8 @@
 // FIXME - fix the nux focus api so we don't need this
 #define UBUS_RESULT_VIEW_KEYNAV_CHANGED "RESULT_VIEW_KEYNAV_CHANGED"
 
-// for communicating positions to the preview state machine (iii)
-// (split y coord in absolute geometry, results to the left, results to the right)
+// for communicating positions to the preview state machine (iiii)
+// (split y coord in absolute geometry, height of row where icon resides, results to the left, results to the right)
 #define UBUS_DASH_PREVIEW_INFO_PAYLOAD "DASH_PREVIEW_INFO_PAYLOAD"
 
 // called when previews wish to navigate left/right or close (is)