Merge lp:~3v1n0/unity/overlay-scrollbars-gtk-like into lp:unity

[Marco Trevisan (Treviño)]

Places(Overlay)VScrollBar: impelement gtk-like overlay scrollbars

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4019
http://jenkins.qa.ubuntu.com/job/unity-ci/1345/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/122
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/121
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/120/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/1345/rebuild

review: Needs Fixing (continuous-integration)

[Andrea Azzarone (azzar1)]

Overall looks good. Just few redrawing issues:
* with a different scale, scrolling inside the scope view makes the dash flicker in the right border.
* some redrawing issues with the filter view.

I suggested some possible fix on IRC.

review: Needs Fixing

[Andrea Azzarone (azzar1)]

LGTM.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:4020
http://jenkins.qa.ubuntu.com/job/unity-ci/1372/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-amd64-ci/24
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-armhf-ci/24
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-i386-ci/24

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/1372/rebuild

review: Approve (continuous-integration)

=== modified file 'dash/PlacesGroup.cpp'
--- dash/PlacesGroup.cpp	2015-08-25 08:15:50 +0000
+++ dash/PlacesGroup.cpp	2015-12-09 12:47:13 +0000
@@ -49,14 +49,13 @@
 {
 namespace
 {
-
-const nux::Color kExpandDefaultTextColor(1.0f, 1.0f, 1.0f, 0.5f);
-const float kExpandDefaultIconOpacity = 0.5f;
+const nux::Color EXPAND_DEFAULT_TEXT_COLOR(1.0f, 1.0f, 1.0f, 0.5f);
+const float EXPAND_DEFAULT_ICON_OPACITY = 0.5f;
 
 // Category  highlight
-const RawPixel kHighlightRightPadding =  7_em; // FIXME 10 - 3 because the scrollbar is not a real overlay scrollbar!
-const RawPixel kHighlightHeight       = 24_em;
-const RawPixel kHighlightLeftPadding  = 10_em;
+const RawPixel HIGHLIGHT_RIGHT_PADDING = 10_em;
+const RawPixel HIGHLIGHT_HEIGHT       = 24_em;
+const RawPixel HIGHLIGHT_LEFT_PADDING = 10_em;
 const RawPixel SPACE_BETWEEN_CHILDREN = 10_em;
 const RawPixel TEXT_INTERNAL_MARGIN   = 15_em;
 const RawPixel EXPAND_INTERNAL_MARGIN =  8_em;
@@ -65,7 +64,6 @@
 // Font
 const char* const NAME_LABEL_FONT     = "Ubuntu 13"; // 17px = 13
 const char* const EXPANDER_LABEL_FONT = "Ubuntu 10"; // 13px = 10
-
 }
 
 class HeaderView : public nux::View
@@ -184,12 +182,12 @@
   _expand_label->SetLines(-1);
   _expand_label->SetTextEllipsize(StaticCairoText::NUX_ELLIPSIZE_END);
   _expand_label->SetTextAlignment(StaticCairoText::NUX_ALIGN_LEFT);
-  _expand_label->SetTextColor(kExpandDefaultTextColor);
+  _expand_label->SetTextColor(EXPAND_DEFAULT_TEXT_COLOR);
   _expand_label_layout->AddView(_expand_label, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
 
   _expand_icon = new IconTexture(_style.GetGroupExpandIcon());
   _expand_icon->SetDrawMode(IconTexture::DrawMode::STRETCH_WITH_ASPECT);
-  _expand_icon->SetOpacity(kExpandDefaultIconOpacity);
+  _expand_icon->SetOpacity(EXPAND_DEFAULT_ICON_OPACITY);
   _expand_icon->SetVisible(false);
   _expand_layout->AddView(_expand_icon, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_MATCHCONTENT);
 
@@ -466,9 +464,9 @@
   if (_cached_geometry.GetWidth() != geo.GetWidth())
   {
     _focus_layer.reset(_style.FocusOverlay(geo.width -
-                                           kHighlightLeftPadding.CP(scale()) -
-                                           kHighlightRightPadding.CP(scale()),
-                                           kHighlightHeight.CP(scale())));
+                                           HIGHLIGHT_LEFT_PADDING.CP(scale()) -
+                                           HIGHLIGHT_RIGHT_PADDING.CP(scale()),
+                                           HIGHLIGHT_HEIGHT.CP(scale())));
     _cached_geometry = geo;
   }
   return ret;
@@ -487,10 +485,10 @@
   {
     nux::Geometry geo(_header_layout->GetGeometry());
     geo.width = base.width -
-                kHighlightRightPadding.CP(scale()) -
-                kHighlightLeftPadding.CP(scale());
+                HIGHLIGHT_RIGHT_PADDING.CP(scale()) -
+                HIGHLIGHT_LEFT_PADDING.CP(scale());
 
-    geo.x += kHighlightLeftPadding.CP(scale());
+    geo.x += HIGHLIGHT_LEFT_PADDING.CP(scale());
 
     _focus_layer->SetGeometry(geo);
     _focus_layer->Renderlayer(graphics_engine);
@@ -500,9 +498,10 @@
   {
     nux::Geometry bg_geo = base;
     int bg_width = _background_layer->GetDeviceTexture()->GetWidth();
-    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.x = std::max(bg_geo.width - bg_width, 0);
+
+    // to render into a space left over by the scrollview (1 has NOT to be scaled)
+    bg_geo.width = std::min(bg_width, bg_geo.GetWidth()) + 1;
     bg_geo.height = _background->GetHeight();
 
     _background_layer->SetGeometry(bg_geo);

=== modified file 'dash/ScopeView.cpp'
--- dash/ScopeView.cpp	2015-05-22 13:21:01 +0000
+++ dash/ScopeView.cpp	2015-12-09 12:47:13 +0000
@@ -105,24 +105,16 @@
     up_area_ = area;
   }
 
-  void DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
-  {
-    if (RedirectedAncestor())
-    {
-      if (m_horizontal_scrollbar_enable && _hscrollbar->IsRedrawNeeded())
-        graphics::ClearGeometry(_hscrollbar->GetGeometry());
-      if (m_vertical_scrollbar_enable && _vscrollbar->IsRedrawNeeded())
-        graphics::ClearGeometry(_vscrollbar->GetGeometry());
-    }
-
-    ScrollView::DrawContent(graphics_engine, force_draw);
-  }
-
   void EnableScrolling(bool enable_scrolling)
   {
     _vscrollbar->SetInputEventSensitivity(enable_scrolling);
   }
 
+  nux::VScrollBar* GetScrollbar() const
+  {
+    return _vscrollbar;
+  }
+
 protected:
 
   // This is so we can break the natural key navigation path.
@@ -161,7 +153,7 @@
 {
   SetupViews(show_filters);
 
-  search_string.SetGetterFunction(sigc::mem_fun(this, &ScopeView::get_search_string));
+  search_string.SetGetterFunction([this] { return search_string_; });
   filters_expanded.changed.connect(sigc::mem_fun(this, &ScopeView::OnScopeFilterExpanded));
   view_type.changed.connect(sigc::mem_fun(this, &ScopeView::OnViewTypeChanged));
   scale.changed.connect(sigc::mem_fun(this, &ScopeView::UpdateScale));
@@ -243,6 +235,7 @@
   scroll_layout_ = new nux::VLayout(NUX_TRACKER_LOCATION);
   scroll_view_->SetLayout(scroll_layout_);
   scroll_view_->SetRightArea(show_filters);
+  scroll_view_->GetScrollbar()->queue_draw.connect(sigc::hide(sigc::mem_fun(scroll_layout_, &nux::VLayout::QueueDraw)));
 
   no_results_ = new StaticCairoText("", NUX_TRACKER_LOCATION);
   no_results_->SetTextColor(nux::color::White);
@@ -260,6 +253,7 @@
 
   fscroll_layout_ = new nux::VLayout();
   fscroll_view_->SetLayout(fscroll_layout_);
+  fscroll_view_->GetScrollbar()->queue_draw.connect(sigc::hide(sigc::mem_fun(fscroll_layout_, &nux::VLayout::QueueDraw)));
 
   filter_bar_ = new FilterBar();
 
@@ -876,11 +870,6 @@
   return false;
 }
 
-std::string ScopeView::get_search_string() const
-{
-  return search_string_;
-}
-
 void ScopeView::OnGroupExpanded(PlacesGroup* group)
 {
   ResultViewGrid* grid = static_cast<ResultViewGrid*>(group->GetChildView());

=== modified file 'dash/ScopeView.h'
--- dash/ScopeView.h	2015-05-04 20:55:56 +0000
+++ dash/ScopeView.h	2015-12-09 12:47:13 +0000
@@ -143,8 +143,6 @@
 
   void OnCompositorKeyNavFocusChanged(nux::Area*, bool, nux::KeyNavDirection);
 
-  std::string get_search_string() const;
-
   CategoryGroups category_views_;
 
   Scope::Ptr scope_;

=== modified file 'dash/StandaloneDash.cpp'
--- dash/StandaloneDash.cpp	2014-07-09 10:31:21 +0000
+++ dash/StandaloneDash.cpp	2015-12-09 12:47:13 +0000
@@ -37,7 +37,7 @@
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/ThumbnailGenerator.h"
 #include "unity-shared/UBusMessages.h"
-#include "unity-shared/UBusServer.h"
+#include "unity-shared/UBusWrapper.h"
 #include <UnityCore/GSettingsScopes.h>
 #include <UnityCore/ScopeProxyInterface.h>
 
@@ -50,12 +50,13 @@
 {
 public:
   TestRunner(std::string const& scope, double scale)
-    : scope_(scope)
+    : scope_(scope.empty() ? "home.scope" : scope)
     , scale_(scale)
   {}
 
-  static void InitWindowThread (nux::NThread* thread, void* InitData);
-  void Init ();
+  static void InitWindowThread(nux::NThread* thread, void* InitData);
+  void Init();
+
   std::string scope_;
   double scale_;
   nux::Layout *layout;
@@ -78,14 +79,14 @@
   nux::GetWindowThread()->SetLayout (layout);
   nux::GetWindowCompositor().SetKeyFocusArea(view->default_focus());
 
-  unity::UBusServer().SendMessage(UBUS_PLACE_ENTRY_ACTIVATE_REQUEST,
+  unity::UBusManager::SendMessage(UBUS_PLACE_ENTRY_ACTIVATE_REQUEST,
                                   g_variant_new("(sus)", scope_.c_str(), GOTO_DASH_URI, ""));
 }
 
 void TestRunner::InitWindowThread(nux::NThread* thread, void* InitData)
 {
   TestRunner *self =  (TestRunner *) InitData;
-  self->Init ();
+  self->Init();
 }
 
 int main(int argc, char **argv)
@@ -124,6 +125,12 @@
                                         WIDTH.CP(scale), HEIGHT.CP(scale),
                                         0, &TestRunner::InitWindowThread, test_runner));
 
+  nux::ObjectPtr<nux::BaseTexture> background_tex;
+  background_tex.Adopt(nux::CreateTextureFromFile("/usr/share/backgrounds/warty-final-ubuntu.png"));
+  nux::TexCoordXForm texxform;
+  auto tex_layer = std::make_shared<nux::TextureLayer>(background_tex->GetDeviceTexture(), texxform, nux::color::White);
+  wt->SetWindowBackgroundPaintLayer(tex_layer.get());
+
   nux::NuxTimerTickSource tick_source;
   nux::animation::AnimationController animation_controller(tick_source);
   wt->Run(nullptr);

=== modified file 'dash/pch/dash_pch.hh'
--- dash/pch/dash_pch.hh	2012-12-18 13:31:10 +0000
+++ dash/pch/dash_pch.hh	2015-12-09 12:47:13 +0000
@@ -27,3 +27,10 @@
 #include <memory>
 
 #include <Nux/Nux.h>
+
+#include <UnityCore/ModelRowAdaptor.h>
+#include <UnityCore/Model.h>
+#include <UnityCore/Category.h>
+#include <UnityCore/Categories.h>
+#include <UnityCore/Result.h>
+#include <UnityCore/Results.h>

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-10-16 08:46:03 +0000
+++ tests/CMakeLists.txt	2015-12-09 12:47:13 +0000
@@ -261,7 +261,6 @@
                  test_previews_music_payment.cpp
                  test_previews_payment.cpp
                  test_previews_social.cpp
-                 test_overlay_scrollbar.cpp
                  test_quicklist_manager.cpp
                  test_quicklist_menu_item.cpp
                  test_quicklist_view.cpp

=== removed file 'tests/test_overlay_scrollbar.cpp'
--- tests/test_overlay_scrollbar.cpp	2013-11-06 11:21:43 +0000
+++ tests/test_overlay_scrollbar.cpp	1970-01-01 00:00:00 +0000
@@ -1,478 +0,0 @@
-/*
- * Copyright 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3, as
- * published by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the applicable version of the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of both the GNU Lesser General Public
- * License version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Brandon Schaefer <[e-mail]>
- *
- */
-
-#include <gtest/gtest.h>
-
-#include <Nux/Nux.h>
-#include <Nux/NuxTimerTickSource.h>
-#include <Nux/VLayout.h>
-#include <NuxCore/ObjectPtr.h>
-#include <NuxCore/AnimationController.h>
-
-
-#include "unity-shared/VScrollBarOverlayWindow.h"
-#include "unity-shared/PlacesOverlayVScrollBar.h"
-#include "unity-shared/UScreen.h"
-
-using namespace unity::dash;
-using namespace testing;
-
-namespace unity
-{
-
-namespace
-{
-  const unsigned SCROLL_TICK = 1000 * 401;
-  const unsigned SHOW_TICK = 1000 * 91;
-}
-
-class TestOverlayWindow : public Test
-{
-public:
-  TestOverlayWindow()
-    : show_tick_(0)
-    , animation_controller_(tick_source_)
-    , overlay_window_(new VScrollBarOverlayWindow(nux::Geometry(0,0,100,100)))
-  {}
-
-  int GetProxListSize() const
-  {
-    return nux::GetWindowThread()->GetWindowCompositor().GetProximityListSize();
-  }
-
-  void ShowAnimation()
-  {
-    // (tick_source_);
-    show_tick_ += SHOW_TICK;
-    tick_source_.tick(show_tick_);
-  }
-
-  unsigned show_tick_;
-  nux::NuxTimerTickSource tick_source_;
-  nux::animation::AnimationController animation_controller_;
-  nux::ObjectPtr<VScrollBarOverlayWindow> overlay_window_;
-};
-
-namespace dash
-{
-
-class MockScrollBar : public unity::dash::PlacesOverlayVScrollBar
-{
-  public:
-    MockScrollBar(NUX_FILE_LINE_DECL)
-    : PlacesOverlayVScrollBar(NUX_FILE_LINE_PARAM)
-    , animation_controller(tick_source_)
-    , scroll_tick_(0)
-    , scroll_dy_(0)
-    , thumbs_height_(overlay_window_->GetThumbGeometry().height)
-    , scroll_up_signal_(false)
-    , scroll_down_signal_(false)
-    {
-      OnScrollUp.connect([&] (float step, int dy) {
-        scroll_dy_ = dy;
-        scroll_up_signal_ = true;
-      });
-
-      OnScrollDown.connect([&] (float step, int dy) {
-        scroll_dy_ = dy;
-        scroll_down_signal_ = true;
-      });
-    }
-
-    virtual ~MockScrollBar() {}
-
-    // ScrollDown/Up moves the mouse over the overlay scroll bar, then
-    // moves it down/up by scroll_dy
-    void ScrollDown(int scroll_dy)
-    {
-      UpdateStepY();
-
-      auto geo = overlay_window_->GetThumbGeometry();
-      int x = geo.x;
-      int y = geo.y;
-
-      MoveMouse(x, y);
-      MoveDown(x, y);
-
-      MoveMouse(x, y+scroll_dy);
-      MoveUp(x, y+scroll_dy);
-    }
-
-    void ScrollUp(int scroll_dy)
-    {
-      UpdateStepY();
-
-      auto geo = overlay_window_->GetThumbGeometry();
-      int x = geo.x;
-      int y = geo.y;
-
-      MoveMouse(x, y);
-      MoveDown(x, y);
-
-      MoveMouse(x, y-scroll_dy);
-      MoveUp(x, y-scroll_dy);
-    }
-
-    void MoveDown(int x, int y)
-    {
-      nux::Event event;
-      event.type = nux::NUX_MOUSE_PRESSED;
-      event.x = x;
-      event.y = y;
-      nux::GetWindowCompositor().ProcessEvent(event);
-    }
-
-    void MoveUp(int x, int y)
-    {
-      nux::Event event;
-      event.type = nux::NUX_MOUSE_RELEASED;
-      event.x = x;
-      event.y = y;
-      nux::GetWindowCompositor().ProcessEvent(event);
-    }
-
-    void MoveMouse(int x, int y)
-    {
-      nux::Event event;
-      event.type = nux::NUX_MOUSE_MOVE;
-      event.x = x;
-      event.y = y;
-      nux::GetWindowCompositor().ProcessEvent(event);
-    }
-
-    void MoveMouseNear()
-    {
-      auto geo = overlay_window_->GetThumbGeometry();
-      MoveMouse(geo.x, geo.y);
-    }
-
-    void ScrollUpAnimation(int scroll_dy)
-    {
-      MoveMouseNear();
-      UpdateStepY();
-
-      StartScrollAnimation(ScrollDir::UP, scroll_dy);
-      scroll_tick_ += SCROLL_TICK;
-      tick_source_.tick(scroll_tick_);
-    }
-
-    void ScrollDownAnimation(int scroll_dy)
-    {
-      MoveMouseNear();
-      UpdateStepY();
-
-      StartScrollAnimation(ScrollDir::DOWN, scroll_dy);
-      scroll_tick_ += SCROLL_TICK;
-      tick_source_.tick(scroll_tick_);
-    }
-
-    void SetThumbOffset(int y)
-    {
-      overlay_window_->SetThumbOffsetY(y);
-      UpdateConnectorPosition();
-    }
-
-    void StartScrollThenConnectorAnimation()
-    {
-      StartScrollAnimation(ScrollDir::DOWN, 20);
-      MoveMouse(0,0);
-      StartConnectorAnimation();
-
-      scroll_tick_ += SCROLL_TICK;
-      tick_source_.tick(scroll_tick_);
-    }
-
-    void FakeDragDown()
-    {
-      OnMouseDrag(0, overlay_window_->GetThumbOffsetY() + 1, 0, 5, 0, 0);
-    }
-
-    nux::NuxTimerTickSource tick_source_;
-    nux::animation::AnimationController animation_controller;
-
-    using PlacesOverlayVScrollBar::connector_height_;
-    using VScrollBar::_slider;
-
-    unsigned scroll_tick_;
-    int scroll_dy_;
-    int thumbs_height_;
-    bool scroll_up_signal_;
-    bool scroll_down_signal_;
-};
-
-}
-
-class MockScrollView : public nux::ScrollView
-{
-public:
-  MockScrollView(NUX_FILE_LINE_DECL)
-  : nux::ScrollView(NUX_FILE_LINE_PARAM)
-  {
-    scroll_bar_ = new MockScrollBar(NUX_TRACKER_LOCATION);
-    SetVScrollBar(scroll_bar_.GetPointer());
-  }
-
-  nux::ObjectPtr<MockScrollBar> scroll_bar_;
-};
-
-class TestOverlayVScrollBar : public Test
-{
-public:
-  TestOverlayVScrollBar()
-  {
-    nux::VLayout* scroll_layout_ = new nux::VLayout(NUX_TRACKER_LOCATION);
-    scroll_layout_->SetGeometry(0,0,1000,5000);
-    scroll_layout_->SetScaleFactor(0);
-
-    scroll_view_ = new MockScrollView(NUX_TRACKER_LOCATION);
-    scroll_view_->EnableVerticalScrollBar(true);
-    scroll_view_->EnableHorizontalScrollBar(false);
-    scroll_view_->SetLayout(scroll_layout_);
-
-    scroll_view_->scroll_bar_->SetContentSize(0, 0, 201, 2000);
-    scroll_view_->scroll_bar_->SetContainerSize(0, 0, 202, 400);
-  }
-
-  nux::ObjectPtr<MockScrollView> scroll_view_;
-};
-
-TEST_F(TestOverlayWindow, TestOverlayShows)
-{
-  ASSERT_FALSE(overlay_window_->IsVisible());
-  overlay_window_->MouseNear();
-  EXPECT_TRUE(overlay_window_->IsVisible());
-  EXPECT_DOUBLE_EQ(0.0f, overlay_window_->GetOpacity());
-
-  ShowAnimation();
-  EXPECT_DOUBLE_EQ(1.0f, overlay_window_->GetOpacity());
-}
-
-TEST_F(TestOverlayWindow, TestOverlayHides)
-{
-  overlay_window_->MouseNear();
-  ShowAnimation();
-  EXPECT_TRUE(overlay_window_->IsVisible());
-
-  overlay_window_->MouseBeyond();
-  ShowAnimation();
-
-  overlay_window_->MouseLeave();
-  ShowAnimation();
-
-  EXPECT_FALSE(overlay_window_->IsVisible());
-  EXPECT_DOUBLE_EQ(0.0f, overlay_window_->GetOpacity());
-}
-
-TEST_F(TestOverlayWindow, TestOverlayStaysOpenWhenMouseDown)
-{
-  overlay_window_->MouseNear();
-  ShowAnimation();
-
-  overlay_window_->MouseDown();
-  ShowAnimation();
-
-  overlay_window_->MouseBeyond();
-  ShowAnimation();
-
-  overlay_window_->MouseLeave();
-  ShowAnimation();
-
-  EXPECT_TRUE(overlay_window_->IsVisible());
-}
-
-TEST_F(TestOverlayWindow, TestOverlayMouseDrags)
-{
-  overlay_window_->MouseDown();
-  EXPECT_FALSE(overlay_window_->IsMouseBeingDragged());
-
-  overlay_window_->SetThumbOffsetY(10);
-  EXPECT_TRUE(overlay_window_->IsMouseBeingDragged());
-}
-
-TEST_F(TestOverlayWindow, TestOverlayStopDraggingOnMouseUp)
-{
-  overlay_window_->MouseDown();
-  EXPECT_FALSE(overlay_window_->IsMouseBeingDragged());
-
-  overlay_window_->SetThumbOffsetY(10);
-  EXPECT_TRUE(overlay_window_->IsMouseBeingDragged());
-
-  overlay_window_->MouseUp();
-  EXPECT_FALSE(overlay_window_->IsMouseBeingDragged());
-}
-
-TEST_F(TestOverlayWindow, TestOverlaySetsOffsetY)
-{
-  int const offset_y = 30;
-
-  overlay_window_->SetThumbOffsetY(offset_y);
-  EXPECT_EQ(overlay_window_->GetThumbOffsetY(), offset_y);
-}
-
-TEST_F(TestOverlayWindow, TestOverlaySetsOffsetYOutOfBoundsLower)
-{
-  int const offset_y = -40;
-
-  overlay_window_->SetThumbOffsetY(offset_y);
-  EXPECT_EQ(overlay_window_->GetThumbOffsetY(), 0);
-}
-
-TEST_F(TestOverlayWindow, TestOverlaySetsOffsetYOutOfBoundsUpper)
-{
-  int const offset_y = 1000;
-  int const expected_offset = overlay_window_->GetBaseHeight() - overlay_window_->GetThumbHeight();
-
-  overlay_window_->SetThumbOffsetY(offset_y);
-  EXPECT_EQ(overlay_window_->GetThumbOffsetY(), expected_offset);
-}
-
-TEST_F(TestOverlayWindow, TestOverlayMouseIsInsideThumb)
-{
-  nux::Geometry const geo(0, 50, 50, 400);
-
-  overlay_window_->UpdateGeometry(geo);
-  EXPECT_TRUE(overlay_window_->IsMouseInsideThumb(0));
-}
-
-TEST_F(TestOverlayWindow, TestOverlayMouseIsInsideOnOffsetChange)
-{
-  nux::Geometry const geo(0, 50, 50, 400);
-  int const offset_y = 50;
-  int const thumb_height = overlay_window_->GetThumbHeight();
-
-  overlay_window_->UpdateGeometry(geo);
-  overlay_window_->SetThumbOffsetY(offset_y);
-
-  EXPECT_FALSE(overlay_window_->IsMouseInsideThumb(offset_y - 1));
-  EXPECT_TRUE(overlay_window_->IsMouseInsideThumb(offset_y + thumb_height/2));
-  EXPECT_FALSE(overlay_window_->IsMouseInsideThumb(offset_y + thumb_height + 1));
-}
-
-
-TEST_F(TestOverlayVScrollBar, TestScrollDownSignal)
-{
-  scroll_view_->scroll_bar_->ScrollDown(10);
-  EXPECT_TRUE(scroll_view_->scroll_bar_->scroll_down_signal_);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollUpSignal)
-{
-  scroll_view_->scroll_bar_->ScrollDown(10);
-  scroll_view_->scroll_bar_->ScrollUp(10);
-  EXPECT_TRUE(scroll_view_->scroll_bar_->scroll_up_signal_);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollDownDeltaY)
-{
-  int scroll_down = 15;
-  scroll_view_->scroll_bar_->ScrollDown(scroll_down);
-  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_down);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollUpDeltaY)
-{
-  int scroll_up = 7;
-  scroll_view_->scroll_bar_->ScrollDown(scroll_up+1);
-  scroll_view_->scroll_bar_->ScrollUp(scroll_up);
-  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_up);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollDownBaseYMoves)
-{
-  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
-  int scroll_down = 10;
-  scroll_view_->scroll_bar_->ScrollDown(scroll_down);
-  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_down);
-  EXPECT_GT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollUpBaseYMoves)
-{
-  int scroll_up = 10;
-  scroll_view_->scroll_bar_->ScrollDown(scroll_up+1);
-
-  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
-  scroll_view_->scroll_bar_->ScrollUp(scroll_up);
-  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_up);
-  EXPECT_LT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollsSlowlyDeltaY)
-{
-  int scroll_down = 10;
-  for (int i = 0; i < scroll_down; i++)
-  {
-    scroll_view_->scroll_bar_->ScrollDown(1);
-    EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, 1);
-  }
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollUpAnimationMovesSlider)
-{
-  int scroll_up = 10;
-  scroll_view_->scroll_bar_->ScrollDown(scroll_up+10);
-
-  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
-  scroll_view_->scroll_bar_->ScrollUpAnimation(scroll_up);
-
-  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_up);
-  EXPECT_LT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
-}
-
-TEST_F(TestOverlayVScrollBar, TestScrollDownAnimationMovesSlider)
-{
-  int scroll_down = 10;
-  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
-
-  scroll_view_->scroll_bar_->ScrollDownAnimation(scroll_down);
-
-  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_down);
-  EXPECT_GT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
-}
-
-TEST_F(TestOverlayVScrollBar, TestConnectorResetsDuringScrollAnimation)
-{
-  scroll_view_->scroll_bar_->MoveMouseNear();
-  scroll_view_->scroll_bar_->SetThumbOffset(100);
-
-  int connector_height = scroll_view_->scroll_bar_->connector_height_;
-  EXPECT_GT(connector_height, 0);
-
-  scroll_view_->scroll_bar_->StartScrollThenConnectorAnimation();
-
-  connector_height = scroll_view_->scroll_bar_->connector_height_;
-  EXPECT_EQ(connector_height, 0);
-}
-
-
-TEST_F(TestOverlayVScrollBar, TestAllowDragIfOverlayIsAtMaximum)
-{
-  // Offset that sets the thumb at the bottom of the scrollbar
-  int thumb_offset = scroll_view_->scroll_bar_->GetHeight() -
-                     scroll_view_->scroll_bar_->thumbs_height_;
-
-  scroll_view_->scroll_bar_->SetThumbOffset(thumb_offset);
-  scroll_view_->scroll_bar_->FakeDragDown();
-  EXPECT_TRUE(scroll_view_->scroll_bar_->scroll_down_signal_);
-}
-
-}
-

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2015-05-05 02:03:52 +0000
+++ unity-shared/CMakeLists.txt	2015-12-09 12:47:13 +0000
@@ -71,7 +71,6 @@
      UnityWindowView.cpp
      UpstartWrapper.cpp
      UserThumbnailProvider.cpp
-     VScrollBarOverlayWindow.cpp
      WindowButtons.cpp
      WindowManager.cpp
 )

=== modified file 'unity-shared/CoverArt.cpp'
--- unity-shared/CoverArt.cpp	2014-07-11 03:36:45 +0000
+++ unity-shared/CoverArt.cpp	2015-12-09 12:47:13 +0000
@@ -450,6 +450,7 @@
   overlay_text_->SetLines(-3);
   overlay_text_->SetScale(scale);
   overlay_text_->SetText(_("No Image Available"));
+  overlay_text_->SetInputEventSensitivity(false);
 
   spin_ = dash::Style::Instance().GetSearchSpinIcon(scale);
 

=== modified file 'unity-shared/OverlayScrollView.cpp'
--- unity-shared/OverlayScrollView.cpp	2015-05-05 13:07:36 +0000
+++ unity-shared/OverlayScrollView.cpp	2015-12-09 12:47:13 +0000
@@ -1,3 +1,4 @@
+
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
  * Copyright (C) 2014 Canonical Ltd
@@ -52,7 +53,7 @@
   });
 
   page_direction.connect([scrollbar] (ScrollDir dir) {
-      scrollbar->PerformPageNavigation(dir);
+    scrollbar->PerformPageNavigation(dir);
   });
 }
 

=== modified file 'unity-shared/OverlayWindowButtons.cpp'
--- unity-shared/OverlayWindowButtons.cpp	2015-06-03 12:11:00 +0000
+++ unity-shared/OverlayWindowButtons.cpp	2015-12-09 12:47:13 +0000
@@ -72,6 +72,9 @@
 
 void OverlayWindowButtons::Show()
 {
+  if (!nux::GetWindowThread()->IsEmbeddedWindow())
+    return;
+
   UpdateGeometry();
   ShowWindow(true);
   PushToFront();
@@ -80,6 +83,9 @@
 
 void OverlayWindowButtons::Hide()
 {
+  if (!nux::GetWindowThread()->IsEmbeddedWindow())
+    return;
+
   ShowWindow(false);
   PushToBack();
   QueueDraw();

=== modified file 'unity-shared/PlacesOverlayVScrollBar.cpp'
--- unity-shared/PlacesOverlayVScrollBar.cpp	2015-05-04 20:55:56 +0000
+++ unity-shared/PlacesOverlayVScrollBar.cpp	2015-12-09 12:47:13 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2012 Canonical Ltd
+ * Copyright (C) 2012-2015 Canonical Ltd
  *
  * 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
@@ -15,11 +15,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Brandon Schaefer <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #include <Nux/Nux.h>
 
-#include "CairoTexture.h"
+#include "AnimationUtils.h"
 #include "PlacesOverlayVScrollBar.h"
 #include "RawPixel.h"
 
@@ -29,438 +30,124 @@
 {
 namespace
 {
-  const RawPixel PROXIMITY = 7_em;
-  const int SCROLL_ANIMATION = 400;
-  const int MAX_CONNECTOR_ANIMATION = 200;
-  const nux::Color CONNECTOR_COLOR = nux::color::Gray;
+const RawPixel PROXIMITY = 7_em;
+const int PAGE_SCROLL_ANIMATION = 200;
+const int CLICK_SCROLL_ANIMATION = 80;
+
+const RawPixel BUTTONS_HEIGHT = 0_em;
+const RawPixel DEFAULT_WIDTH = 3_em;
+const RawPixel ACTIVE_WIDTH = 8_em;
 }
 
-class PlacesOverlayVScrollBar::ProximityArea : public nux::InputAreaProximity, public sigc::trackable
+struct PlacesOverlayVScrollBar::ProximityArea : public nux::InputAreaProximity, public sigc::trackable
 {
-public:
   ProximityArea(nux::InputArea* area, unsigned prox)
     : nux::InputAreaProximity(area, prox)
     , proximity([this] { return proximity_; }, [this] (unsigned px) { proximity_ = px; return false; })
   {}
 
   nux::RWProperty<unsigned> proximity;
+
+  bool IsMouseNear() const { return is_mouse_near_; }
 };
 
 PlacesOverlayVScrollBar::PlacesOverlayVScrollBar(NUX_FILE_LINE_DECL)
   : PlacesVScrollBar(NUX_FILE_LINE_PARAM)
-  , overlay_window_(new VScrollBarOverlayWindow(_track->GetAbsoluteGeometry()))
   , area_prox_(std::make_shared<ProximityArea>(this, PROXIMITY.CP(scale)))
-  , thumb_above_slider_(false)
-  , connector_height_(0)
-  , mouse_down_offset_(0)
   , delta_update_(0)
 {
-  area_prox_->mouse_near.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseNear));
-  area_prox_->mouse_beyond.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseBeyond));
-
-  overlay_window_->scale = scale();
-  overlay_window_->mouse_enter.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseEnter));
-  overlay_window_->mouse_leave.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseLeave));
-  overlay_window_->mouse_down.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseDown));
-  overlay_window_->mouse_up.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseUp));
-  overlay_window_->mouse_click.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseClick));
-  overlay_window_->mouse_move.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseMove));
-  overlay_window_->mouse_drag.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseDrag));
-  overlay_window_->mouse_wheel.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnMouseWheel));
-  overlay_window_->sigHidden.connect(sigc::hide(sigc::mem_fun(this, &PlacesOverlayVScrollBar::ResetConnector)));
-
-  _track->geometry_changed.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnTrackGeometryChanged));
-  OnVisibleChanged.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnVisibilityChanged));
-  OnSensitiveChanged.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnSensitivityChanged));
-
   scale.changed.connect([this] (double scale) {
     area_prox_->proximity = PROXIMITY.CP(scale);
-    overlay_window_->scale = scale;
-  });
-}
-
-void PlacesOverlayVScrollBar::OnTrackGeometryChanged(nux::Area* /*area*/, nux::Geometry& /*geo*/)
-{
-  UpdateStepY();
-  overlay_window_->UpdateGeometry(_track->GetAbsoluteGeometry());
-
-  if (overlay_window_->IsVisible() && !IsScrollBarVisible())
-  {
-    overlay_window_->ResetStates();
-    ResetConnector();
-  }
-}
-
-void PlacesOverlayVScrollBar::OnVisibilityChanged(nux::Area* /*area*/, bool visible)
-{
-  if (overlay_window_->IsVisible() && !visible)
-  {
-    overlay_window_->ResetStates();
-    ResetConnector();
-  }
-}
-
-void PlacesOverlayVScrollBar::OnSensitivityChanged(nux::Area* /*area*/, bool sensitive)
-{
-  if (!sensitive)
-  {
-    overlay_window_->ResetStates();
-    ResetConnector();
-  }
-}
-
-void PlacesOverlayVScrollBar::SetupAnimation(int start, int stop, int milliseconds)
-{
-  tweening_connection_->disconnect();
+    UpdateScrollbarSize();
+  });
+
+  auto update_sb_cb = sigc::mem_fun(this, &PlacesOverlayVScrollBar::UpdateScrollbarSize);
+
+  auto update_sb_proximity_cb = sigc::hide(update_sb_cb);
+  area_prox_->mouse_near.connect(update_sb_proximity_cb);
+  area_prox_->mouse_beyond.connect(update_sb_proximity_cb);
+
+  auto update_sb_mouse_cb = sigc::hide(sigc::hide(sigc::hide(update_sb_proximity_cb)));
+  _track->mouse_enter.connect(update_sb_mouse_cb);
+  _track->mouse_leave.connect(update_sb_mouse_cb);
+  _slider->mouse_enter.connect(update_sb_mouse_cb);
+  _slider->mouse_leave.connect(update_sb_mouse_cb);
+  _slider->mouse_up.connect(update_sb_mouse_cb);
+  _track->mouse_up.connect(update_sb_mouse_cb);
+
+  // Disable default track-click handlers
+  _track->mouse_down.clear();
+  _track->mouse_up.clear();
+  _track->mouse_down.connect([this] (int x, int y, unsigned long, unsigned long) {
+    int slider_vcenter = _slider->GetBaseY() - _track->GetBaseY() + _slider->GetBaseHeight() / 2;
+    int scroll_offset = slider_vcenter - y;
+
+    if (scroll_offset > 0)
+      StartScrollAnimation(ScrollDir::UP, scroll_offset, CLICK_SCROLL_ANIMATION);
+    else
+      StartScrollAnimation(ScrollDir::DOWN, -scroll_offset, CLICK_SCROLL_ANIMATION);
+  });
+
+  UpdateScrollbarSize();
+}
+
+void PlacesOverlayVScrollBar::UpdateScrollbarSize()
+{
+  bool is_hovering = false;
+  SetMinimumWidth(ACTIVE_WIDTH.CP(scale));
+  SetMaximumWidth(ACTIVE_WIDTH.CP(scale));
+
+  _scroll_up_button->SetMaximumHeight(BUTTONS_HEIGHT.CP(scale));
+  _scroll_up_button->SetMinimumHeight(BUTTONS_HEIGHT.CP(scale));
+  _scroll_down_button->SetMaximumHeight(BUTTONS_HEIGHT.CP(scale));
+  _scroll_down_button->SetMinimumHeight(BUTTONS_HEIGHT.CP(scale));
+
+  int slider_width = DEFAULT_WIDTH.CP(scale);
+
+  if (_track->IsMouseInside() || _track->IsMouseOwner() ||
+      _slider->IsMouseInside() || _slider->IsMouseOwner() ||
+       area_prox_->IsMouseNear())
+  {
+    is_hovering = true;
+    slider_width = ACTIVE_WIDTH.CP(scale);
+  }
+
+  hovering = is_hovering;
+
+  _slider->SetMinimumWidth(slider_width);
+  _slider->SetMaximumWidth(slider_width);
+  _scroll_up_button->SetBaseWidth(slider_width);
+
+  QueueDraw();
+}
+
+void PlacesOverlayVScrollBar::PerformPageNavigation(ScrollDir dir)
+{
+  StartScrollAnimation(dir, _slider->GetBaseHeight(), PAGE_SCROLL_ANIMATION);
+}
+
+void PlacesOverlayVScrollBar::StartScrollAnimation(ScrollDir dir, int stop, unsigned duration)
+{
+  if (animation_.CurrentState() != nux::animation::Animation::State::Stopped)
+    return;
+
   delta_update_ = 0;
-
-  animation_.SetDuration(milliseconds);
-  animation_.SetEasingCurve(nux::animation::EasingCurve(nux::animation::EasingCurve::Type::Linear));
-
-  animation_.SetStartValue(start);
-  animation_.SetFinishValue(stop);
-}
-
-void PlacesOverlayVScrollBar::PerformPageNavigation(ScrollDir dir)
-{
-  StartScrollAnimation(dir, _slider->GetBaseHeight());
-}
-
-void PlacesOverlayVScrollBar::StartScrollAnimation(ScrollDir dir, int stop)
-{
-  if (animation_.CurrentState() == nux::animation::Animation::State::Stopped)
-  {
-    SetupAnimation(0, stop, SCROLL_ANIMATION);
-
-    tweening_connection_ = animation_.updated.connect([this, dir] (int const& update) {
-      OnScroll(dir, update - delta_update_);
+  stepY = (float) (content_height_ - container_height_) / (float) (_track->GetBaseHeight() - _slider->GetBaseHeight());
+
+  tweening_connection_ = animation_.updated.connect([this, dir] (int update) {
+      int mouse_dy = update - delta_update_;
+
+      if (dir == ScrollDir::UP)
+        OnScrollUp.emit(stepY, mouse_dy);
+      else if (dir == ScrollDir::DOWN)
+        OnScrollDown.emit(stepY, mouse_dy);
+
       delta_update_ = update;
-
-      CheckIfThumbIsInsideSlider();
-      UpdateConnectorPosition();
       QueueDraw();
     });
 
-    animation_.Start();
-  }
-}
-
-void PlacesOverlayVScrollBar::OnScroll(ScrollDir dir, int mouse_dy)
-{
-  if (dir == ScrollDir::UP)
-    OnScrollUp.emit(stepY, mouse_dy);
-  else if (dir == ScrollDir::DOWN)
-    OnScrollDown.emit(stepY, mouse_dy);
-}
-
-void PlacesOverlayVScrollBar::StartConnectorAnimation()
-{
-  if (animation_.CurrentState() == nux::animation::Animation::State::Stopped)
-  {
-    SetupAnimation(connector_height_, 0, std::min(connector_height_, MAX_CONNECTOR_ANIMATION));
-
-    tweening_connection_ = animation_.updated.connect([this] (int const& update) {
-      connector_height_ = update;
-      UpdateConnectorTexture();
-    });
-
-    animation_.Start();
-  }
-}
-
-bool PlacesOverlayVScrollBar::IsScrollBarVisible() const
-{
-  return (content_height_ > container_height_);
-}
-
-void PlacesOverlayVScrollBar::OnMouseEnter(int x, int y, unsigned int button_flags, unsigned int key_flags)
-{
-  overlay_window_->MouseEnter();
-  UpdateConnectorPosition();
-}
-
-void PlacesOverlayVScrollBar::OnMouseLeave(int x, int y, unsigned int button_flags, unsigned int key_flags)
-{
-  overlay_window_->MouseLeave();
-  UpdateConnectorPosition();
-}
-
-void PlacesOverlayVScrollBar::OnMouseNear(nux::Point const& mouse_pos)
-{
-  if (IsSensitive() && IsVisible() && IsScrollBarVisible())
-  {
-    animation_.Stop();
-
-    overlay_window_->MouseNear();
-    AdjustThumbOffsetFromMouse();
-  }
-}
-
-void PlacesOverlayVScrollBar::OnMouseBeyond(nux::Point const& mouse_pos)
-{
-  if (IsVisible() && IsScrollBarVisible())
-  {
-    overlay_window_->MouseBeyond();
-    UpdateConnectorPosition();
-  }
-}
-
-void PlacesOverlayVScrollBar::AdjustThumbOffsetFromMouse()
-{
-  if (!overlay_window_->IsMouseBeingDragged())
-  {
-    nux::Point const& mouse = nux::GetWindowCompositor().GetMousePosition();
-
-    if (mouse.y > 0)
-    {
-      int const quarter_of_thumb = overlay_window_->GetThumbHeight()/4;
-      int const new_offset = mouse.y - _track->GetAbsoluteY() - overlay_window_->GetThumbHeight()/2;
-
-      int const slider_offset = _slider->GetAbsoluteY() - _track->GetAbsoluteY() + _slider->GetBaseHeight()/3;
-      bool const mouse_above_slider = slider_offset < new_offset;
-
-      if (mouse_above_slider)
-        overlay_window_->SetThumbOffsetY(new_offset - quarter_of_thumb);
-      else
-        overlay_window_->SetThumbOffsetY(new_offset + quarter_of_thumb);
-    }
-
-    CheckIfThumbIsInsideSlider();
-  }
-}
-
-void PlacesOverlayVScrollBar::CheckIfThumbIsInsideSlider()
-{
-  nux::Geometry const& slider_geo = _slider->GetAbsoluteGeometry();
-  nux::Geometry const& thumb_geo = overlay_window_->GetThumbGeometry();
-
-  if (thumb_geo.IsIntersecting(slider_geo))
-  {
-    ResetConnector();
-    overlay_window_->ThumbInsideSlider();
-  }
-  else
-  {
-    UpdateConnectorPosition();
-    overlay_window_->ThumbOutsideSlider();
-  }
-}
-
-void PlacesOverlayVScrollBar::UpdateConnectorPosition()
-{
-  int const slider_y = _slider->GetBaseY() - GetBaseY();
-  int const thumb_y = overlay_window_->GetThumbOffsetY();
-  int const thumb_height = overlay_window_->GetThumbHeight();
-
-  if (!overlay_window_->IsVisible())
-  {
-    ResetConnector();
-  }
-  else if (slider_y > thumb_y)
-  {
-    thumb_above_slider_ = true;
-    connector_height_ = slider_y - (thumb_y + thumb_height);
-  }
-  else
-  {
-    thumb_above_slider_ = false;
-    connector_height_ = thumb_y - (_slider->GetBaseY() + _slider->GetBaseHeight()) + _track->GetBaseY();
-  }
-
-  UpdateConnectorTexture();
-}
-
-void PlacesOverlayVScrollBar::ResetConnector()
-{
-  if (animation_.CurrentState() == nux::animation::Animation::State::Stopped)
-  {
-    if (connector_height_ > 0)
-    {
-      StartConnectorAnimation();
-    }
-  }
-  else
-  {
-    connector_height_ = 0;
-  }
-
-  QueueDraw();
-}
-
-void PlacesOverlayVScrollBar::OnMouseClick(int /*x*/, int y, unsigned int button_flags, unsigned int /*key_flags*/)
-{
-  if (!overlay_window_->IsMouseBeingDragged())
-  {
-    int const button = nux::GetEventButton(button_flags);
-
-    if (button == 1)
-      LeftMouseClick(y);
-    else if (button == 2)
-      MiddleMouseClick(y);
-  }
-
-  overlay_window_->MouseUp();
-}
-
-void PlacesOverlayVScrollBar::LeftMouseClick(int y)
-{
-  if (IsMouseInTopHalfOfThumb(y))
-  {
-    int const top = _slider->GetBaseY() - _track->GetBaseY();
-    StartScrollAnimation(ScrollDir::UP, std::min(_slider->GetBaseHeight(), top));
-  }
-  else
-  {
-    int const bottom = (_track->GetBaseY() + _track->GetBaseHeight()) -
-                       (_slider->GetBaseHeight() + _slider->GetBaseY());
-    StartScrollAnimation(ScrollDir::DOWN, std::min(_slider->GetBaseHeight(), bottom));
-  }
-
-  UpdateConnectorPosition();
-}
-
-void PlacesOverlayVScrollBar::MiddleMouseClick(int y)
-{
-  int const slider_offset = _slider->GetBaseY() - _track->GetBaseY();
-  bool const move_up = slider_offset > overlay_window_->GetThumbOffsetY();
-
-  int const slider_thumb_diff = abs(overlay_window_->GetThumbOffsetY() - slider_offset);
-
-  if (move_up)
-    StartScrollAnimation(ScrollDir::UP, slider_thumb_diff);
-  else
-    StartScrollAnimation(ScrollDir::DOWN, slider_thumb_diff);
-}
-
-void PlacesOverlayVScrollBar::OnMouseDown(int /*x*/, int y, unsigned int /*button_flags*/, unsigned int /*key_flags*/)
-{
-  if (overlay_window_->IsMouseInsideThumb(y))
-  {
-    if (IsMouseInTopHalfOfThumb(y))
-      overlay_window_->PageUpAction();
-    else
-      overlay_window_->PageDownAction();
-
-    mouse_down_offset_ = y - overlay_window_->GetThumbOffsetY();
-    overlay_window_->MouseDown();
-  }
-}
-
-bool PlacesOverlayVScrollBar::IsMouseInTopHalfOfThumb(int y)
-{
-  int const thumb_height = overlay_window_->GetThumbHeight();
-  int const thumb_offset_y = overlay_window_->GetThumbOffsetY();
-
-  return (y < (thumb_height/2 + thumb_offset_y));
-}
-
-void PlacesOverlayVScrollBar::OnMouseUp(int x, int y, unsigned int /*button_flags*/, unsigned int /*key_flags*/)
-{
-  nux::Geometry const& geo = overlay_window_->GetAbsoluteGeometry();
-
-  if (!geo.IsPointInside(x + geo.x, y + geo.y))
-  {
-    overlay_window_->MouseUp();
-    UpdateConnectorPosition();
-  }
-}
-
-void PlacesOverlayVScrollBar::OnMouseMove(int /*x*/, int y, int /*dx*/, int /*dy*/, unsigned int /*button_flags*/, unsigned int /*key_flags*/)
-{
-  if (!overlay_window_->IsMouseInsideThumb(y))
-    AdjustThumbOffsetFromMouse();
-}
-
-void PlacesOverlayVScrollBar::OnMouseDrag(int /*x*/, int y, int /*dx*/, int dy, unsigned int /*button_flags*/, unsigned int /*key_flags*/)
-{
-  animation_.Stop();
-  MouseDraggingOverlay(y, dy);
-}
-
-void PlacesOverlayVScrollBar::OnMouseWheel(int x, int y, int delta, unsigned long mouse_state, unsigned long key_state)
-{
-  mouse_wheel.emit(x, y, delta, mouse_state, key_state);
-  UpdateConnectorPosition();
-}
-
-void PlacesOverlayVScrollBar::MouseDraggingOverlay(int y, int dy)
-{
-  int const thumb_offset = overlay_window_->GetThumbOffsetY() + mouse_down_offset_;
-
-  if (dy < 0 && !AtMinimum() && y <= thumb_offset)
-  {
-    OnScrollUp.emit(stepY, abs(dy));
-  }
-  else if (dy > 0 && !AtMaximum() && y >= thumb_offset)
-  {
-    OnScrollDown.emit(stepY, dy);
-  }
-
-  overlay_window_->SetThumbOffsetY(y - mouse_down_offset_);
-  CheckIfThumbIsInsideSlider();
-}
-
-void PlacesOverlayVScrollBar::UpdateStepY()
-{
-  stepY = (float) (content_height_ - container_height_) / (float) (_track->GetBaseHeight() - _slider->GetBaseHeight());
-}
-
-void PlacesOverlayVScrollBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
-{
-  PlacesVScrollBar::Draw(graphics_engine, force_draw);
-
-  if (connector_height_ > 0 && connector_texture_.IsValid())
-  {
-    int const connector_width = GetBaseWidth();
-    int offset_y = 0;
-    if (thumb_above_slider_)
-    {
-      offset_y = _slider->GetBaseY() - connector_height_;
-    }
-    else
-    {
-      offset_y = _slider->GetBaseY() + _slider->GetBaseHeight();
-    }
-
-    nux::Geometry base(_track->GetBaseX(), offset_y - 4, connector_width, connector_height_ + 5);
-    nux::TexCoordXForm texxform;
-
-    graphics_engine.QRP_1Tex(base.x,
-                             base.y,
-                             base.width,
-                             base.height,
-                             connector_texture_->GetDeviceTexture(),
-                             texxform,
-                             nux::color::White);
-  }
-}
-
-void PlacesOverlayVScrollBar::UpdateConnectorTexture()
-{
-  if (connector_height_ < 0)
-    return;
-
-  int width = _slider->GetWidth();
-  int height = connector_height_;
-
-  if (connector_texture_ && connector_texture_->GetWidth() == width && connector_texture_->GetHeight() == height)
-    return;
-
-  nux::CairoGraphics cairoGraphics(CAIRO_FORMAT_ARGB32, width, height);
-  cairo_t* cr = cairoGraphics.GetInternalContext();
-  cairo_surface_set_device_scale(cairo_get_target(cr), scale, scale);
-
-  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
-  cairo_paint(cr);
-
-  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-  cairo_set_source_rgba(cr, CONNECTOR_COLOR.red, CONNECTOR_COLOR.green, CONNECTOR_COLOR.blue, 0.8);
-  cairo_rectangle(cr, 0, 0, static_cast<double>(width)/scale(), static_cast<double>(height)/scale());
-  cairo_fill(cr);
-
-  connector_texture_ = texture_ptr_from_cairo_graphics(cairoGraphics);
-
-  QueueDraw();
+  animation_.SetDuration(duration);
+  animation::Start(animation_, 0, stop);
 }
 
 } // namespace dash

=== modified file 'unity-shared/PlacesOverlayVScrollBar.h'
--- unity-shared/PlacesOverlayVScrollBar.h	2015-05-04 20:55:56 +0000
+++ unity-shared/PlacesOverlayVScrollBar.h	2015-12-09 12:47:13 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2012 Canonical Ltd
+ * Copyright (C) 2012-2015 Canonical Ltd
  *
  * 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
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Brandon Schaefer <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #ifndef PLACES_OVERLAY_VSCROLLBAR_H
@@ -27,7 +28,6 @@
 #include <memory>
 
 #include "unity-shared/PlacesVScrollBar.h"
-#include "unity-shared/VScrollBarOverlayWindow.h"
 
 namespace unity
 {
@@ -46,67 +46,17 @@
   PlacesOverlayVScrollBar(NUX_FILE_LINE_PROTO);
   virtual ~PlacesOverlayVScrollBar() {}
 
-  void PerformPageNavigation(ScrollDir dir);
-
-protected:
-  void Draw(nux::GraphicsEngine& graphics_engine, bool force_draw);
+  void PerformPageNavigation(ScrollDir);
 
 private:
-  void OnTrackGeometryChanged(nux::Area* area, nux::Geometry& geo);
-  void OnVisibilityChanged(nux::Area* area, bool visible);
-  void OnSensitivityChanged(nux::Area* area, bool sensitive);
-
-  void OnMouseEnter(int x, int y, unsigned int button_flags, unsigned int key_flags);
-  void OnMouseLeave(int x, int y, unsigned int button_flags, unsigned int key_flags);
-
-  void OnMouseNear(nux::Point const& mouse_pos);
-  void OnMouseBeyond(nux::Point const& mouse_pos);
-  void AdjustThumbOffsetFromMouse();
-
-  void OnMouseClick(int x, int y, unsigned int button_flags, unsigned int key_flags);
-  void LeftMouseClick(int y);
-  void MiddleMouseClick(int y);
-
-  void OnMouseDown(int x, int y, unsigned int button_flags, unsigned int key_flags);
-  void OnMouseUp(int x, int y, unsigned int button_flags, unsigned int key_flags);
-  void OnMouseMove(int x, int y, int dx, int dy, unsigned int button_flags, unsigned int key_flags);
-  void OnMouseDrag(int x, int y, int dx, int dy, unsigned int button_flags, unsigned int key_flags);
-  void OnMouseWheel(int x, int y, int delta, unsigned long mouse_state, unsigned long key_state);
-
-  void MouseDraggingOverlay(int y, int dy);
-
-  bool IsMouseInTopHalfOfThumb(int y);
-  void CheckIfThumbIsInsideSlider();
-
-  bool IsScrollBarVisible() const;
-
-  void UpdateConnectorPosition();
-  void ResetConnector();
-
-  void UpdateStepY();
-
-  void SetupAnimation(int start, int stop, int milliseconds);
-
-  void StartScrollAnimation(ScrollDir dir, int stop);
-  void OnScroll(ScrollDir dir, int mouse_dy);
-
-  void StartConnectorAnimation();
-
-  void UpdateConnectorTexture();
-
-  nux::ObjectPtr<VScrollBarOverlayWindow> overlay_window_;
+  void UpdateScrollbarSize();
+  void StartScrollAnimation(ScrollDir, int stop, unsigned duration);
 
   class ProximityArea;
   std::shared_ptr<ProximityArea> area_prox_;
 
   nux::animation::AnimateValue<int> animation_;
   connection::Wrapper tweening_connection_;
-
-  nux::ObjectPtr<nux::BaseTexture> connector_texture_;
-  
-  bool thumb_above_slider_;
-  int connector_height_;
-  int mouse_down_offset_;
   int delta_update_;
 
   friend class MockScrollBar;

=== modified file 'unity-shared/PlacesVScrollBar.cpp'
--- unity-shared/PlacesVScrollBar.cpp	2015-02-03 13:06:47 +0000
+++ unity-shared/PlacesVScrollBar.cpp	2015-12-09 12:47:13 +0000
@@ -21,9 +21,10 @@
 #include <Nux/Nux.h>
 #include <NuxGraphics/CairoGraphics.h>
 
+#include "PlacesVScrollBar.h"
 #include "unity-shared/CairoTexture.h"
 #include "unity-shared/RawPixel.h"
-#include "PlacesVScrollBar.h"
+#include "unity-shared/GraphicsUtils.h"
 
 namespace unity
 {
@@ -31,13 +32,14 @@
 {
 namespace
 {
-const RawPixel BUTTONS_HEIGHT = 15_em;
+const RawPixel BUTTONS_HEIGHT = 0_em;
 const RawPixel WIDTH = 3_em;
 }
 
 PlacesVScrollBar::PlacesVScrollBar(NUX_FILE_LINE_DECL)
   : nux::VScrollBar(NUX_FILE_LINE_PARAM)
   , scale(1.0)
+  , hovering(false)
 {
   UpdateSize();
   scale.changed.connect([this] (double scale) {
@@ -54,53 +56,16 @@
 
   _scroll_down_button->SetMaximumHeight(BUTTONS_HEIGHT.CP(scale));
   _scroll_down_button->SetMinimumHeight(BUTTONS_HEIGHT.CP(scale));
-
-  _slider->SetMinimumWidth(WIDTH.CP(scale));
-  _slider->SetMaximumWidth(WIDTH.CP(scale));
-  SetMinimumWidth(WIDTH.CP(scale));
-  SetMaximumWidth(WIDTH.CP(scale));
-}
-
-void PlacesVScrollBar::PreLayoutManagement()
-{
-  nux::VScrollBar::PreLayoutManagement();
-}
-
-long
-PlacesVScrollBar::PostLayoutManagement(long LayoutResult)
-{
-  long ret = nux::VScrollBar::PostLayoutManagement(LayoutResult);
-
-  UpdateTexture();
-  return ret;
-}
-
-void
-PlacesVScrollBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+}
+
+void PlacesVScrollBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+{}
+
+void PlacesVScrollBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
 {
   if (!RedirectedAncestor())
-  {
-    DrawScrollbar(graphics_engine);
-  }
-}
-
-void
-PlacesVScrollBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
-{
-  if (RedirectedAncestor())
-  {
-    DrawScrollbar(graphics_engine);
-  }
-}
-
-void
-PlacesVScrollBar::DrawScrollbar(nux::GraphicsEngine& graphics_engine)
-{
-  // check if textures have been computed... if they haven't, exit function
-  if (!slider_texture_)
     return;
 
-  nux::Color color = nux::color::White;
   nux::Geometry const& base  = GetGeometry();
   nux::TexCoordXForm texxform;
 
@@ -108,7 +73,6 @@
   unsigned int alpha = 0, src = 0, dest = 0;
   graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
 
-
   texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_SCALE_COORD);
 
   graphics_engine.GetRenderStates().SetBlend(true);
@@ -117,29 +81,50 @@
   if (content_height_ > container_height_)
   {
     nux::Geometry const& slider_geo = _slider->GetGeometry();
-
-    graphics_engine.QRP_1Tex(slider_geo.x,
-                        slider_geo.y,
-                        slider_geo.width,
-                        slider_geo.height,
-                        slider_texture_->GetDeviceTexture(),
-                        texxform,
-                        color);
+    nux::GetPainter().PushBackgroundStack();
+
+    if (hovering)
+      graphics::ClearGeometry(base);
+
+    nux::ROPConfig rop;
+    rop.Blend = true;
+    rop.SrcBlend = GL_ONE;
+    rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+    nux::ColorLayer layer(nux::color::Transparent, true, rop);
+    nux::GetPainter().PushDrawLayer(graphics_engine, base, &layer);
+
+    if (hovering)
+      graphics_engine.QRP_Color(base.x, base.y, base.width, base.height, nux::color::White * 0.4);
+
+    UpdateTexture(slider_geo);
+    graphics_engine.QRP_1Tex(base.x + base.width - slider_geo.width,
+                             slider_geo.y,
+                             slider_geo.width,
+                             slider_geo.height,
+                             slider_texture_->GetDeviceTexture(),
+                             texxform,
+                             nux::color::White);
+
+    nux::GetPainter().PopBackgroundStack();
   }
 
   graphics_engine.PopClippingRectangle();
   graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
 }
 
-void PlacesVScrollBar::UpdateTexture()
+void PlacesVScrollBar::UpdateTexture(nux::Geometry const& geo)
 {
   // update texture of slider
-  int width  = _slider->GetBaseWidth();
-  int height = _slider->GetBaseHeight();
+  int width  = geo.width;
+  int height = geo.height;
 
   if (slider_texture_ && slider_texture_->GetWidth() == width && slider_texture_->GetHeight() == height)
     return;
 
+  double unscaled_width = static_cast<double>(width) / scale();
+  double unscaled_height = static_cast<double>(height) / scale();
+
   nux::CairoGraphics cg(CAIRO_FORMAT_ARGB32, width, height);
   auto* cr = cg.GetInternalContext();
   cairo_surface_set_device_scale(cairo_get_target(cr), scale, scale);
@@ -149,7 +134,7 @@
 
   cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
   cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 1.0f);
-  cg.DrawRoundedRectangle(cr, 1.0f, 0.0, 0.0, 1.5, 3.0, static_cast<double>(height)/scale() - 3.0);
+  cg.DrawRoundedRectangle(cr, 1.0f, 0, 0, unscaled_width / 2.0, unscaled_width, unscaled_height - 2.0);
   cairo_fill(cr);
 
   slider_texture_ = texture_ptr_from_cairo_graphics(cg);

=== modified file 'unity-shared/PlacesVScrollBar.h'
--- unity-shared/PlacesVScrollBar.h	2014-07-11 19:14:00 +0000
+++ unity-shared/PlacesVScrollBar.h	2015-12-09 12:47:13 +0000
@@ -33,18 +33,15 @@
   PlacesVScrollBar(NUX_FILE_LINE_PROTO);
 
   nux::Property<double> scale;
+  nux::Property<bool> hovering;
 
 protected:
-  virtual void PreLayoutManagement();
-  virtual long PostLayoutManagement(long LayoutResult);
-
   void Draw(nux::GraphicsEngine& gfxContext, bool forceDraw);
   void DrawContent(nux::GraphicsEngine& gfxContext, bool forceDraw);
 
 private:
   void UpdateSize();
-  void UpdateTexture();
-  void DrawScrollbar(nux::GraphicsEngine& graphics_engine);
+  void UpdateTexture(nux::Geometry const&);
 
 private:
   nux::ObjectPtr<nux::BaseTexture> slider_texture_;

=== removed file 'unity-shared/VScrollBarOverlayWindow.cpp'
--- unity-shared/VScrollBarOverlayWindow.cpp	2014-07-11 22:42:00 +0000
+++ unity-shared/VScrollBarOverlayWindow.cpp	1970-01-01 00:00:00 +0000
@@ -1,568 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2012 Canonical Ltd
- *
- * 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 warranty of
- * MERCHANTABILITY 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
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Brandon Schaefer <[e-mail]>
- */
-
-#include <Nux/Nux.h>
-#include <NuxGraphics/CairoGraphics.h>
-
-#include "VScrollBarOverlayWindow.h"
-#include "UScreen.h"
-#include "DashStyle.h"
-#include "CairoTexture.h"
-#include "unity-shared/AnimationUtils.h"
-
-namespace unity
-{
-
-namespace
-{
-  const RawPixel THUMB_WIDTH = 21_em;
-  const RawPixel THUMB_HEIGHT = 68_em;
-  const int THUMB_RADIUS = 3;
-  const int ANIMATION_DURATION = 90;
-}
-
-VScrollBarOverlayWindow::VScrollBarOverlayWindow(nux::Geometry const& geo)
-  : nux::BaseWindow("")
-  , scale(1.0)
-  , content_size_(geo)
-  , content_offset_x_(0)
-  , mouse_offset_y_(0)
-  , current_state_(ThumbState::NONE)
-  , current_action_(ThumbAction::NONE)
-  , show_animator_(ANIMATION_DURATION)
-{
-  Area::SetGeometry(content_size_.x, content_size_.y, THUMB_WIDTH.CP(scale), content_size_.height);
-  SetBackgroundColor(nux::color::Transparent);
-  SetAcceptMouseWheelEvent(true);
-
-  show_animator_.updated.connect(sigc::mem_fun(this, &BaseWindow::SetOpacity));
-  show_animator_.finished.connect([this] {
-    if (animation::GetDirection(show_animator_) == animation::Direction::BACKWARD)
-      ShowWindow(false);
-  });
-
-  SetOpacity(0.0f);
-  UpdateTexture();
-
-  scale.changed.connect([this] (double scale) {
-    UpdateContentGeometry();
-    UpdateTexture();
-  });
-}
-
-void VScrollBarOverlayWindow::UpdateContentGeometry()
-{
-  UpdateMouseOffsetX();
-  Area::SetGeometry(content_size_.x + content_offset_x_, content_size_.y, THUMB_WIDTH.CP(scale), content_size_.height);
-}
-
-void VScrollBarOverlayWindow::UpdateGeometry(nux::Geometry const& geo)
-{
-  if (content_size_.x != geo.x ||
-      content_size_.y != geo.y ||
-      content_size_.height != geo.height)
-  {
-    content_size_ = geo;
-    UpdateContentGeometry();
-  }
-}
-
-void VScrollBarOverlayWindow::SetThumbOffsetY(int y)
-{
-  int const new_offset = GetValidOffsetYValue(y);
-
-  if (new_offset != mouse_offset_y_)
-  {
-    if (HasState(ThumbState::MOUSE_DOWN))
-      MouseDragging();
-
-    mouse_offset_y_ = new_offset;
-    QueueDraw();
-  }
-}
-
-int VScrollBarOverlayWindow::GetValidOffsetYValue(int new_offset) const
-{
-  if (new_offset < 0)
-    return 0;
-  else if (new_offset > content_size_.height - THUMB_HEIGHT.CP(scale))
-    return content_size_.height - THUMB_HEIGHT.CP(scale);
-
-  return new_offset;
-}
-
-void VScrollBarOverlayWindow::UpdateMouseOffsetX()
-{
-  int monitor = unity::UScreen::GetDefault()->GetMonitorWithMouse();
-  nux::Geometry const& geo = unity::UScreen::GetDefault()->GetMonitorGeometry(monitor);
-
-  if (content_size_.x + THUMB_WIDTH.CP(scale) > geo.x + geo.width)
-    content_offset_x_ = geo.x + geo.width - (content_size_.x + THUMB_WIDTH.CP(scale));
-  else
-    content_offset_x_ = 0;
-}
-
-bool VScrollBarOverlayWindow::IsMouseInsideThumb(int y) const
-{
-  nux::Geometry const thumb(0, mouse_offset_y_, THUMB_WIDTH.CP(scale), THUMB_HEIGHT.CP(scale));
-  return thumb.IsPointInside(0,y);
-}
-
-bool VScrollBarOverlayWindow::IsMouseBeingDragged() const
-{
-  return current_action_ == ThumbAction::DRAGGING;
-}
-
-int VScrollBarOverlayWindow::GetThumbHeight() const
-{
-  return THUMB_HEIGHT.CP(scale);
-}
-
-int VScrollBarOverlayWindow::GetThumbOffsetY() const
-{
-  return mouse_offset_y_;
-}
-
-nux::Geometry VScrollBarOverlayWindow::GetThumbGeometry() const
-{
-  return nux::Geometry(content_size_.x + content_offset_x_,
-                       content_size_.y + mouse_offset_y_,
-                       THUMB_WIDTH.CP(scale), THUMB_HEIGHT.CP(scale));
-}
-
-void VScrollBarOverlayWindow::MouseDown()
-{
-  AddState(ThumbState::MOUSE_DOWN);
-  UpdateTexture();
-}
-
-void VScrollBarOverlayWindow::MouseUp()
-{
-  RemoveState(ThumbState::MOUSE_DOWN);
-  current_action_ = ThumbAction::NONE;
-  UpdateTexture();
-  ShouldHide();
-}
-
-void VScrollBarOverlayWindow::MouseNear()
-{
-  AddState(ThumbState::MOUSE_NEAR);
-  ShouldShow();
-}
-
-void VScrollBarOverlayWindow::MouseBeyond()
-{
-  RemoveState(ThumbState::MOUSE_NEAR);
-  ShouldHide();
-}
-
-void VScrollBarOverlayWindow::MouseEnter()
-{
-  AddState(ThumbState::MOUSE_INSIDE);
-  ShouldShow();
-}
-
-void VScrollBarOverlayWindow::MouseLeave()
-{
-  RemoveState(ThumbState::MOUSE_INSIDE);
-  ShouldHide();
-}
-
-void VScrollBarOverlayWindow::ThumbInsideSlider()
-{
-  if (!HasState(ThumbState::INSIDE_SLIDER))
-  {
-    AddState(ThumbState::INSIDE_SLIDER);
-    UpdateTexture();
-  }
-}
-
-void VScrollBarOverlayWindow::ThumbOutsideSlider()
-{
-  if (HasState(ThumbState::INSIDE_SLIDER))
-  {
-    RemoveState(ThumbState::INSIDE_SLIDER);
-    UpdateTexture();
-  }
-}
-
-void VScrollBarOverlayWindow::PageUpAction()
-{
-  current_action_ = ThumbAction::PAGE_UP;
-  UpdateTexture();
-}
-
-void VScrollBarOverlayWindow::PageDownAction()
-{
-  current_action_ = ThumbAction::PAGE_DOWN;
-  UpdateTexture();
-}
-
-void VScrollBarOverlayWindow::MouseDragging()
-{
-  if (current_action_ != ThumbAction::DRAGGING)
-  {
-    current_action_ = ThumbAction::DRAGGING;
-    UpdateTexture();
-  }
-}
-
-void VScrollBarOverlayWindow::ShouldShow()
-{
-  if (!IsVisible())
-  {
-    if (HasState(ThumbState::MOUSE_DOWN) ||
-        HasState(ThumbState::MOUSE_NEAR))
-    {
-      ShowWindow(true);
-      PushToFront();
-      animation::StartOrReverse(show_animator_, animation::Direction::FORWARD);
-    }
-  }
-}
-
-void VScrollBarOverlayWindow::ShouldHide()
-{
-  if (IsVisible())
-  {
-    if (!(HasState(ThumbState::MOUSE_DOWN)) &&
-        !(HasState(ThumbState::MOUSE_NEAR)) &&
-        !(HasState(ThumbState::MOUSE_INSIDE)))
-    {
-      animation::StartOrReverse(show_animator_, animation::Direction::BACKWARD);
-    }
-  }
-}
-
-void VScrollBarOverlayWindow::ResetStates()
-{
-  current_state_ = ThumbState::NONE;
-  current_action_ = ThumbAction::NONE;
-  ShouldHide();
-}
-
-void VScrollBarOverlayWindow::AddState(ThumbState const& state)
-{
-  current_state_ |= state;
-}
-
-void VScrollBarOverlayWindow::RemoveState(ThumbState const& state)
-{
-  current_state_ &= ~(state);
-}
-
-bool VScrollBarOverlayWindow::HasState(ThumbState const& state) const
-{
-  return (current_state_ & state);
-}
-
-void VScrollBarOverlayWindow::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
-{
-  if (!thumb_texture_)
-    return;
-
-  nux::Geometry base(0, mouse_offset_y_, THUMB_WIDTH.CP(scale), THUMB_HEIGHT.CP(scale));
-  nux::TexCoordXForm texxform;
-
-  graphics_engine.QRP_1Tex(base.x,
-                           base.y,
-                           base.width,
-                           base.height,
-                           thumb_texture_->GetDeviceTexture(),
-                           texxform,
-                           nux::color::White);
-}
-
-nux::color::RedGreenBlue ProduceColorShade(nux::color::RedGreenBlue const& rgb, float shade)
-{
-  if (shade == 1.0f)
-    return rgb;
-
-  nux::color::HueLightnessSaturation hls(rgb);
-
-  hls.lightness *= shade;
-  if (hls.lightness > 1.0f)
-    hls.lightness = 1.0f;
-  else if (hls.lightness < 0.0f)
-    hls.lightness = 0.0f;
-
-  hls.saturation *= shade;
-  if (hls.saturation > 1.0f)
-    hls.saturation = 1.0f;
-  else if (hls.saturation < 0.0f)
-    hls.saturation = 0.0f;
-
-  nux::color::RedGreenBlue rgb_shade(hls);
-
-  return rgb_shade;
-}
-
-void PatternAddRGBStop(cairo_pattern_t* pat, nux::color::RedGreenBlue const& rgb, double stop, float alpha)
-{
-  cairo_pattern_add_color_stop_rgba (pat, stop, rgb.red, rgb.green, rgb.blue, alpha);
-}
-
-void SetSourceRGB(cairo_t* cr, nux::color::RedGreenBlue const& rgb, float alpha)
-{
-  cairo_set_source_rgba(cr, rgb.red, rgb.green, rgb.blue, alpha);
-}
-
-void DrawGrip (cairo_t* cr, double x, double y, int nx, int ny)
-{
-  gint lx, ly;
-
-  for (ly = 0; ly < ny; ly++)
-  {
-    for (lx = 0; lx < nx; lx++)
-    {
-      gint sx = lx * 3;
-      gint sy = ly * 3;
-
-      cairo_rectangle (cr, x + sx, y + sy, 1, 1);
-    }
-  }
-}
-
-void DrawBothGrips(cairo_t* cr, nux::color::RedGreenBlue const& rgb, int width, int height)
-{
-  int const grip_width = 5;
-  int const grip_height = 6;
-  float const grip_y = 13.5;
-  float const offset = 6.5;
-
-  cairo_pattern_t* pat;
-  pat = cairo_pattern_create_linear(0, 0, 0, height);
-
-  PatternAddRGBStop(pat, rgb, 0.0, 0.0);
-  PatternAddRGBStop(pat, rgb, 0.49, 0.5);
-  PatternAddRGBStop(pat, rgb, 0.49, 0.5);
-  PatternAddRGBStop(pat, rgb, 1.0, 0.0);
-
-  cairo_set_source(cr, pat);
-  cairo_pattern_destroy(pat);
-
-  DrawGrip(cr, width/2 - offset, grip_y, grip_width, grip_height);
-  DrawGrip(cr, width/2 - offset, height/2 + (grip_y - 10), grip_width, grip_height);
-
-  cairo_fill(cr);
-}
-
-void DrawLineSeperator(cairo_t* cr, nux::color::RedGreenBlue const& top,
-                       nux::color::RedGreenBlue const& bottom, int width, int height)
-{
-  int const offset = 1.5;
-
-  // Top
-  cairo_move_to(cr, offset, height/2);
-  cairo_line_to(cr, width - offset, height/2);
-  SetSourceRGB(cr, top, 0.36);
-  cairo_stroke(cr);
-
-  // Bottom
-  cairo_move_to(cr, offset, 1 + height/2);
-  cairo_line_to(cr, width - offset, 1 + height/2);
-  SetSourceRGB(cr, bottom, 0.5);
-  cairo_stroke(cr);
-}
-
-
-void DrawArrow(cairo_t* cr, nux::color::RedGreenBlue const& rgb, double x, double y, double width, double height)
-{
-  cairo_save (cr);
-
-  cairo_translate (cr, x, y);
-  cairo_move_to (cr, -width / 2, -height / 2);
-  cairo_line_to (cr, 0, height / 2);
-  cairo_line_to (cr, width / 2, -height / 2);
-  cairo_close_path (cr);
-
-  SetSourceRGB(cr, rgb, 0.75);
-  cairo_fill_preserve (cr);
-
-  SetSourceRGB(cr, rgb, 1.0);
-  cairo_stroke (cr);
-
-  cairo_restore (cr);
-}
-
-void DrawBothArrows(cairo_t* cr, nux::color::RedGreenBlue const& rgb, int width, int height)
-{
-  int const arrow_width = 5;
-  int const arrow_height = 3;
-  float const trans_height = 8.5;
-  float const offset_x = 0.5;
-
-  // Top
-  cairo_save(cr);
-  cairo_translate(cr, width/2 + offset_x, trans_height);
-  cairo_rotate(cr, G_PI);
-  DrawArrow(cr, rgb, offset_x, 0, arrow_width, arrow_height);
-  cairo_restore(cr);
-
-  // Bottom
-  cairo_save(cr);
-  cairo_translate(cr, width/2 + offset_x, height - trans_height);
-  cairo_rotate(cr, 0);
-  DrawArrow(cr, rgb, -offset_x, 0, arrow_width, arrow_height);
-  cairo_restore(cr);
-}
-
-void VScrollBarOverlayWindow::UpdateTexture()
-{
-  int width  = THUMB_WIDTH;
-  int height = THUMB_HEIGHT;
-
-  float const aspect = 1.0f;
-  float current_x = 0.0f;
-  float current_y = 0.0f;
-
-  auto const& bg = nux::color::WhiteSmoke;
-  auto const& bg_selected = nux::color::White;
-  auto const& bg_active = nux::color::Gray;
-  auto const& arrow_color = nux::color::DarkSlateGray;
-
-  auto const& bg_arrow_up = ProduceColorShade(bg, 0.86);
-  auto const& bg_arrow_down = ProduceColorShade(bg, 1.1);
-  auto const& bg_shadow = ProduceColorShade(bg, 0.2);
-
-  auto const& bg_dark_line = ProduceColorShade(bg, 0.4);
-  auto const& bg_bright_line = ProduceColorShade(bg, 1.2);
-
-  nux::CairoGraphics cairoGraphics(CAIRO_FORMAT_ARGB32, THUMB_WIDTH.CP(scale), THUMB_HEIGHT.CP(scale));
-  cairo_t* cr = cairoGraphics.GetInternalContext();
-  cairo_surface_set_device_scale(cairo_get_target(cr), scale, scale);
-
-  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
-  cairo_paint(cr);
-
-  cairo_translate (cr, 0.5, 0.5);
-  width--;
-  height--;
-
-  cairo_set_line_width (cr, 1.0);
-
-  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-
-  // Draw backgound
-  SetSourceRGB(cr, bg, 1.0);
-  cairoGraphics.DrawRoundedRectangle(cr, aspect, current_x, current_y, THUMB_RADIUS, width, height);
-  cairo_fill_preserve(cr);
-
-  // Draw shaded background
-  cairo_pattern_t* pat = cairo_pattern_create_linear(0, 0, 0, height);
-
-  PatternAddRGBStop(pat, bg_arrow_up, 0.0, 0.8);
-  PatternAddRGBStop(pat, bg_arrow_down, 1.0, 0.8);
-
-  cairo_set_source(cr, pat);
-  cairo_pattern_destroy(pat);
-
-  if (current_action_ == ThumbAction::DRAGGING)
-  {
-    cairo_fill_preserve(cr);
-    SetSourceRGB(cr, bg, 0.8);
-    cairo_fill(cr);
-  }
-  else
-  {
-    cairo_fill(cr);
-  }
-
-  // Draw Page Up/Down Action
-  if (current_action_ == ThumbAction::PAGE_UP ||
-      current_action_ == ThumbAction::PAGE_DOWN)
-  {
-    if (current_action_ == ThumbAction::PAGE_UP)
-      cairo_rectangle(cr, 0, 0, width, height/2);
-    else
-      cairo_rectangle(cr, 0, height/2, width, height/2);
-
-    SetSourceRGB(cr, bg, 0.8);
-    cairo_fill(cr);
-  }
-
-  cairo_save(cr);
-
-  // Draw Outline
-  cairo_set_line_width (cr, 2.0);
-
-  current_x += 0.5;
-  current_y += 0.5;
-  cairoGraphics.DrawRoundedRectangle(cr, aspect, current_x, current_y, THUMB_RADIUS - 1, width - 1, height - 1);
-
-  if (HasState(ThumbState::INSIDE_SLIDER))
-    SetSourceRGB(cr, bg_selected, 1.0);
-  else
-    SetSourceRGB(cr, bg_active, 0.9);
-
-  cairo_stroke(cr);
-
-  cairo_restore(cr);
-
-  // Draw shade outline
-  pat = cairo_pattern_create_linear(0, 0, 0, height);
-
-  PatternAddRGBStop(pat, bg_shadow, 0.5, 0.06);
-
-  switch(current_action_)
-  {
-    case ThumbAction::NONE:
-      PatternAddRGBStop(pat, bg_shadow, 0.0, 0.22);
-      PatternAddRGBStop(pat, bg_shadow, 1.0, 0.22);
-      break;
-    case ThumbAction::DRAGGING:
-      PatternAddRGBStop(pat, bg_shadow, 0.0, 0.2);
-      PatternAddRGBStop(pat, bg_shadow, 1.0, 0.2);
-      break;
-    case ThumbAction::PAGE_UP:
-      PatternAddRGBStop(pat, bg_shadow, 0.0, 0.1);
-      PatternAddRGBStop(pat, bg_shadow, 1.0, 0.22);
-      break;
-    case ThumbAction::PAGE_DOWN:
-      PatternAddRGBStop(pat, bg_shadow, 0.0, 0.22);
-      PatternAddRGBStop(pat, bg_shadow, 1.0, 0.1);
-      break;
-    default:
-      break;
-  }
-
-  cairo_set_source(cr, pat);
-  cairo_pattern_destroy(pat);
-
-  current_x += 0.5;
-  current_y += 0.5;
-  cairoGraphics.DrawRoundedRectangle(cr, aspect, current_x, current_y, THUMB_RADIUS, width- 2, height - 2);
-  cairo_stroke(cr);
-
-  current_x += 1.0;
-  current_y += 1.0;
-  cairoGraphics.DrawRoundedRectangle(cr, aspect, current_x, current_y, THUMB_RADIUS - 1, width - 4, height- 4);
-  SetSourceRGB(cr, bg_bright_line, 0.6);
-  cairo_stroke(cr);
-
-  DrawBothGrips(cr, bg_dark_line, width, height);
-  DrawLineSeperator(cr, bg_dark_line, bg_bright_line, width, height);
-  DrawBothArrows(cr, arrow_color, width, height);
-
-  thumb_texture_ = texture_ptr_from_cairo_graphics(cairoGraphics);
-
-  QueueDraw();
-}
-
-} // namespace unity

=== removed file 'unity-shared/VScrollBarOverlayWindow.h'
--- unity-shared/VScrollBarOverlayWindow.h	2014-07-11 20:04:06 +0000
+++ unity-shared/VScrollBarOverlayWindow.h	1970-01-01 00:00:00 +0000
@@ -1,114 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2012 Canonical Ltd
- *
- * 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 warranty of
- * MERCHANTABILITY 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
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Brandon Schaefer <[e-mail]>
- */
-
-
-#ifndef VSCROLLBAR_OVERLAY_WINDOW_H
-#define VSCROLLBAR_OVERLAY_WINDOW_H
-
-#include <Nux/Nux.h>
-#include <Nux/BaseWindow.h>
-#include <NuxCore/Animation.h>
-
-namespace unity
-{
-
-class VScrollBarOverlayWindow : public nux::BaseWindow
-{
-public:
-  VScrollBarOverlayWindow(nux::Geometry const& geo);
-
-  nux::Property<double> scale;
-
-  void UpdateGeometry(nux::Geometry const& geo);
-  void SetThumbOffsetY(int y);
-
-  void MouseDown();
-  void MouseUp();
-
-  void MouseNear();
-  void MouseBeyond();
-
-  void MouseEnter();
-  void MouseLeave();
-
-  void ThumbInsideSlider();
-  void ThumbOutsideSlider();
-
-  void PageUpAction();
-  void PageDownAction();
-  
-  bool IsMouseInsideThumb(int y) const;
-  bool IsMouseBeingDragged() const;
-
-  int GetThumbHeight() const;
-  int GetThumbOffsetY() const;
-
-  nux::Geometry GetThumbGeometry() const;
-
-  void ResetStates();
-
-protected:
-  virtual void Draw(nux::GraphicsEngine& graphics_engine, bool force_draw);
-
-private:
-  enum class ThumbAction : unsigned int
-  {
-    NONE,
-    DRAGGING,
-    PAGE_UP,
-    PAGE_DOWN
-  };
-
-  enum ThumbState
-  {
-    NONE          = 1 << 0,
-    MOUSE_DOWN    = 1 << 1,
-    MOUSE_NEAR    = 1 << 2,
-    MOUSE_INSIDE  = 1 << 3,
-    INSIDE_SLIDER = 1 << 4
-  };
-
-  void MouseDragging();
-  void UpdateMouseOffsetX();
-  void UpdateContentGeometry();
-  int GetValidOffsetYValue(int y) const;
-
-  void ShouldShow();
-  void ShouldHide();
-
-  void UpdateTexture();
-
-  nux::Geometry content_size_;
-  nux::ObjectPtr<nux::BaseTexture> thumb_texture_;
-  
-  int content_offset_x_;
-  int mouse_offset_y_;
-
-  void AddState(ThumbState const& state);
-  void RemoveState(ThumbState const& state);
-  bool HasState(ThumbState const& state) const;
-  
-  unsigned int current_state_;
-  ThumbAction current_action_;
-  nux::animation::AnimateValue<double> show_animator_;
-};
-
-} // namespace unity
-
-#endif // VSCROLLBAR_OVERLAY_WINDOW_H