Merge lp:~brandontschaefer/unity/lp608124-overlay-scrollbar-dash into lp:unity

[Brandon Schaefer]

Add an overlay scroll bar thumb that allows you to control the scroll bars in the dash.

=== Problem ===
The scroll bars in the dash are hard to grab because they are to thin.

=== Fix ===
Add an overlay scroll bar thumb that allows you to control the scroll bar. (Check out the video for more detail.)

New video showing off the overlay scrollbars:
http://ubuntuone.com/7czr6JBvPNtycHDYCRG7PI

Video showing the connector.
http://ubuntuone.com/5XnzPBz8AvecDISZ1ydyYy

Three pixel wide connector...(Video is 2 pixels wide)
http://i.imgur.com/axkOC.jpg

Depends on this nux branch:
https://code.launchpad.net/~brandontschaefer/nux/mouse-near-signal/+merge/133387

This branch fixes the problem when you mouse to quickly off the dash leaving the overlay thumb visible.
https://code.launchpad.net/~brandontschaefer/nux/nux-failing-to-emit-mouse-beyond/+merge/135318

=== Test ===
Unit tests

[Marco Trevisan (Treviño) (3v1n0)]

First of all, looking at the screencast: awesome work!

430 + _prox_area = std::make_shared<nux::ProximityArea>(_overlay_window.GetPointer(), 7);

I like shared pointers, but since we're using a view here I think you should use an ObjectPtr instead. Also please remember to put the magic number to a global constant, so that is defined and easily editable.

773 +VScrollBarOverlayWindow::VScrollBarOverlayWindow(const nux::Geometry geo)
970 + nux::Color color = nux::color::White;
1208 + nux::Color bg_shadow = ProduceColorShade(bg, 0.2);
1239 + nux::Color bg_dark_line = ProduceColorShade(bg, 0.4);
1240 + nux::Color bg_bright_line = ProduceColorShade(bg, 1.2);

const& ;)

971 + nux::Geometry base = content_size_;
972 + base.SetX(0);
973 + base.SetY(mouse_offset_y_);
974 + base.SetWidth(THUMB_WIDTH);
975 + base.SetHeight(THUMB_HEIGHT);

No need to copy content_size_ here since you're changing everything, just initialize a new Geometry.

979 + if (!thumb_texture_)
980 + return;

Add this on top of the function... It's always better to return as soon as you can to avoid unneeded computation.

1130 + cairoGraphics = new nux::CairoGraphics(CAIRO_FORMAT_ARGB32, width, height);

Don't use a pointer here, you don't need it.

1250 + if (thumb_texture_)
1251 + thumb_texture_->UnReference();

You don't need this, just do:
thumb_texture_.Adopt(unity::texture_from_cairo_graphics(*cairoGraphics));

1255 + delete cairoGraphics;
Remove it with the pointer ;)

I see a lot of public methods in VScrollBarOverlayWindow and PlacesOverlayVScrollBar. Please make them private when possible and at least protected when you need them for testing (even if in that case you could just use the "friendship hack" to get things testable anyway).

[Stephen M. Webb (bregma)]

480 + _overlay_window = new VScrollBarOverlayWindow(_track->GetAbsoluteGeometry());

Why can't this member be initialized in the initialization list?

507 + _overlay_window.Release();

Does this not happen automatically? Is this going to mess up the refcount?

516 + _animation.SetDuration(400);

What is magic about 400?

656 + if (y < (thumb_height/2 + thumb_offset_y))
657 + return true;
658 +
659 + return false;

Or maybe "return y < (thumb_height/2 + thumb_offset_y)"?

1044 + const nux::Color& color = nux::color::White;

1122 + DrawGrip(cr, width/2 - 6.5, 13.5, 5, 6);
1123 + DrawGrip(cr, width/2 - 6.5, height/2 + 3.5, 5, 6);

Magic, everywhere. Are those pixels? Millimetres? Points? Ems? Will they
look as good on a 72 dpi screen as on a 300 dpi screen?

Same goes for a lot of the magic numbers used to generate color variants,
offsets, and sizes.

[John Lea (johnlea)]

*almost* there, looking very good ;-) Other than one missing element it looks perfect!

The missing element is the 'connector' between the scrollbar and the thumb that should appear and connect the scrollbar and the thumb together when these two elements are not otherwise attached.

If you need any further visual designs contact Otto, I spoke to him a moment ago and he said that you discussed with him at UDS using a very light semi-transparent line as the connector.

Also ping me on IRC if you can't get in touch with Otto or have any other questions.

cheers,
John

review: Needs Fixing (design)

[Brandon Schaefer (brandontschaefer)]

Thank you for looking at it! I was using xchat as a reference and it seems to be missing that 'connector'. Ill get to working on that :).

I thought Otto and I talked about the outline of the thumb is self, which would refelct the color of the 'connector' I just missed the connector part!

[Brandon Schaefer (brandontschaefer)]

@John

Video showing the connector.
http://ubuntuone.com/5XnzPBz8AvecDISZ1ydyYy

The connector is 2 pixels wide in the video because that matches up with the thumbs outline...though the slider is 3 pixels wide. Should it be left at 2?

[John Lea (johnlea)]

Reviewed latest video showing connector, looks good, design wise approved ;-)

review: Approve (design)

[Andrea Azzarone (azzar1)]

+ OnVisibleChanged.connect([&] (nux::Area* area, bool visible) {

I'd prefert to comment out area here so: nux::Area* /*area*/, bool visible.

576 + , _overlay_window(new VScrollBarOverlayWindow(_track->GetAbsoluteGeometry()))
577 + , _area_prox(_overlay_window.GetPointer(), PROXIMITY)
578 + , _thumb_above_slider(false)
579 + , _connector_height(0)
580 + , _mouse_down_offset(0)

For new files please use the new style member_variable_ :)

+void PlacesOverlayVScrollBar::OnTrackGeometryChanged(nux::Area* area, nux::Geometry& geo)

Comment out area and geo.

622 + _animation.SetDuration(SCROLL_ANIMATION);
623 + _animation.SetEasingCurve(nux::animation::EasingCurve(nux::animation::EasingCurve::Type::Linear));
624 +
625 + _animation.SetStartValue(0);
626 + _animation.SetFinishValue(stop);
627 +
628 + StartScrollAnimation(dir);

Maybe you can move 622..627 in a new function so you have:
  SetupScrollAnimation();
  StartScrollAnimation(dir);

But if you don't like it's ok :)

Sometimes you use this condition (content_height_ > container_height_)

I'd move this condition in a readable function (something like IsVScrollbarActive, but I'm sure you'll find a better name :)

+ _overlay_window->SetThumbOffsetY(new_offset - _overlay_window->GetThumbHeight()/4);

I'm sure this 4 is not a magic number but it's not so easy to get its purpose.

[Marco Trevisan (Treviño) (3v1n0)]

Looks very good both code-wise and result-wise... Awesome work, approving it! :)

review: Approve

[Marco Trevisan (Treviño) (3v1n0)]

623 +void PlacesOverlayVScrollBar::StopAnimation()
624 +{
625 + if (animation_.CurrentState() != nux::animation::Animation::State::Stopped)
626 + animation_.Stop();
627 +}

This shouldn't be needed, since animation_.Stop() already does that check...

=== modified file 'dash/DashView.cpp'
--- dash/DashView.cpp	2012-11-19 18:54:19 +0000
+++ dash/DashView.cpp	2012-11-23 23:52:20 +0000
@@ -166,6 +166,7 @@
 
   preview_navigation_mode_ = previews::Navigation::NONE;
   preview_displaying_ = false;
+  active_lens_view_->SetVisible(true);
 
   // re-focus dash view component.
   nux::GetWindowCompositor().SetKeyFocusArea(default_focus());
@@ -269,6 +270,7 @@
 
     preview_container_->SetGeometry(layout_->GetGeometry());
     preview_displaying_ = true;
+    active_lens_view_->SetVisible(false);
 
     // connect to nav left/right signals to request nav left/right movement.
     preview_container_->navigate_left.connect([&] () {
@@ -328,18 +330,19 @@
     LOG_DEBUG(logger) << "Setting ViewType " << ViewType::LENS_VIEW
                                 << " on '" << home_lens_->id() << "'";
   }
-  else if (active_lens_view_)
+  else
   {
     // careful here, the lens_view's view_type doesn't get reset when the dash
     // hides, but lens' view_type does, so we need to update the lens directly
     active_lens_view_->lens()->view_type = ViewType::LENS_VIEW;
   }
+  active_lens_view_->SetVisible(true);
 
   // this will make sure the spinner animates if the search takes a while
   search_bar_->ForceSearchChanged();
 
   // if a preview is open, close it
-  if (preview_displaying_) 
+  if (preview_displaying_)
   {
     ClosePreview();
   }
@@ -363,8 +366,10 @@
   LOG_DEBUG(logger) << "Setting ViewType " << ViewType::HIDDEN
                             << " on '" << home_lens_->id() << "'";
 
+  active_lens_view_->SetVisible(false);
+
   // if a preview is open, close it
-  if (preview_displaying_) 
+  if (preview_displaying_)
   {
     ClosePreview();
   }
@@ -967,6 +972,8 @@
     return;
   }
 
+  lens_views_[id]->SetVisible(true);
+  active_lens_view_->SetVisible(false);
   LensView* view = active_lens_view_ = lens_views_[id];
   view->JumpToTop();
 

=== modified file 'dash/LensView.cpp'
--- dash/LensView.cpp	2012-11-19 18:54:19 +0000
+++ dash/LensView.cpp	2012-11-23 23:52:20 +0000
@@ -33,6 +33,7 @@
 #include "unity-shared/UBusMessages.h"
 #include "unity-shared/UBusWrapper.h"
 #include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
 
 #include <glib/gi18n-lib.h>
 
@@ -57,6 +58,13 @@
     , up_area_(nullptr)
   {
     SetVScrollBar(scroll_bar);
+
+    OnVisibleChanged.connect([&] (nux::Area* /*area*/, bool visible) {
+      if (m_horizontal_scrollbar_enable)
+        _hscrollbar->SetVisible(visible);
+      if (m_vertical_scrollbar_enable)
+        _vscrollbar->SetVisible(visible);
+    });
   }
 
   void ScrollToPosition(nux::Geometry const& position)
@@ -192,6 +200,10 @@
     }
   });
 
+  OnVisibleChanged.connect([&] (nux::Area* area, bool visible) {
+    scroll_view_->SetVisible(visible);
+  });
+
 }
 
 void LensView::SetupViews(nux::Area* show_filters)
@@ -201,9 +213,9 @@
   layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
   layout_->SetSpaceBetweenChildren(style.GetSpaceBetweenLensAndFilters());
 
-  scroll_view_ = new LensScrollView(new PlacesVScrollBar(NUX_TRACKER_LOCATION),
+  scroll_view_ = new LensScrollView(new PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION),
                                     NUX_TRACKER_LOCATION);
-  scroll_view_->EnableVerticalScrollBar(false);
+  scroll_view_->EnableVerticalScrollBar(true);
   scroll_view_->EnableHorizontalScrollBar(false);
   layout_->AddView(scroll_view_);
 

=== modified file 'dash/previews/ApplicationPreview.cpp'
--- dash/previews/ApplicationPreview.cpp	2012-10-29 09:34:54 +0000
+++ dash/previews/ApplicationPreview.cpp	2012-11-23 23:52:20 +0000
@@ -25,7 +25,7 @@
 #include "unity-shared/CoverArt.h"
 #include "unity-shared/IconTexture.h"
 #include "unity-shared/StaticCairoText.h"
-#include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
 #include <UnityCore/ApplicationPreview.h>
 #include <NuxCore/Logger.h>
 #include <Nux/HLayout.h>
@@ -54,7 +54,7 @@
   DetailsScrollView(NUX_FILE_LINE_PROTO)
   : ScrollView(NUX_FILE_LINE_PARAM)
   {
-    SetVScrollBar(new dash::PlacesVScrollBar(NUX_TRACKER_LOCATION));
+    SetVScrollBar(new dash::PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION));
   }
 
 };

=== modified file 'dash/previews/GenericPreview.cpp'
--- dash/previews/GenericPreview.cpp	2012-10-29 09:34:54 +0000
+++ dash/previews/GenericPreview.cpp	2012-11-23 23:52:20 +0000
@@ -24,7 +24,7 @@
 #include "unity-shared/PreviewStyle.h"
 #include "unity-shared/CoverArt.h"
 #include "unity-shared/StaticCairoText.h"
-#include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
 #include <NuxCore/Logger.h>
 #include <Nux/HLayout.h>
 #include <Nux/VLayout.h>
@@ -49,7 +49,7 @@
   DetailsScrollView(NUX_FILE_LINE_PROTO)
   : ScrollView(NUX_FILE_LINE_PARAM)
   {
-    SetVScrollBar(new dash::PlacesVScrollBar(NUX_TRACKER_LOCATION));
+    SetVScrollBar(new dash::PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION));
   }
 
 };

=== modified file 'dash/previews/MoviePreview.cpp'
--- dash/previews/MoviePreview.cpp	2012-10-29 09:34:54 +0000
+++ dash/previews/MoviePreview.cpp	2012-11-23 23:52:20 +0000
@@ -24,7 +24,7 @@
 #include "unity-shared/PreviewStyle.h"
 #include "unity-shared/CoverArt.h"
 #include "unity-shared/StaticCairoText.h"
-#include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
 #include <UnityCore/MoviePreview.h>
 #include <NuxCore/Logger.h>
 #include <Nux/HLayout.h>
@@ -50,7 +50,7 @@
   DetailsScrollView(NUX_FILE_LINE_PROTO)
   : ScrollView(NUX_FILE_LINE_PARAM)
   {
-    SetVScrollBar(new dash::PlacesVScrollBar(NUX_TRACKER_LOCATION));
+    SetVScrollBar(new dash::PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION));
   }
 
 };

=== modified file 'dash/previews/SocialPreview.cpp'
--- dash/previews/SocialPreview.cpp	2012-11-08 09:12:24 +0000
+++ dash/previews/SocialPreview.cpp	2012-11-23 23:52:20 +0000
@@ -25,7 +25,7 @@
 #include "unity-shared/CoverArt.h"
 #include "unity-shared/IconTexture.h"
 #include "unity-shared/StaticCairoText.h"
-#include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
 #include <UnityCore/SocialPreview.h>
 #include <NuxCore/Logger.h>
 #include <Nux/HLayout.h>
@@ -54,7 +54,7 @@
   DetailsScrollView(NUX_FILE_LINE_PROTO)
   : ScrollView(NUX_FILE_LINE_PARAM)
   {
-    SetVScrollBar(new dash::PlacesVScrollBar(NUX_TRACKER_LOCATION));
+    SetVScrollBar(new dash::PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION));
   }
 
 };

=== modified file 'dash/previews/Tracks.cpp'
--- dash/previews/Tracks.cpp	2012-10-29 09:34:54 +0000
+++ dash/previews/Tracks.cpp	2012-11-23 23:52:20 +0000
@@ -24,7 +24,7 @@
 #include <NuxCore/Logger.h>
 #include <Nux/VLayout.h>
 #include "unity-shared/IntrospectableWrappers.h"
-#include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
 #include "unity-shared/PreviewStyle.h"
 #include <UnityCore/Track.h>
 #include <UnityCore/Variant.h>
@@ -76,7 +76,7 @@
 
 void Tracks::SetupViews()
 {
-  SetVScrollBar(new dash::PlacesVScrollBar(NUX_TRACKER_LOCATION));
+  SetVScrollBar(new dash::PlacesOverlayVScrollBar(NUX_TRACKER_LOCATION));
   EnableHorizontalScrollBar(false);
   layout_ = new nux::VLayout();
   layout_->SetPadding(0, previews::Style::Instance().GetDetailsRightMargin(), 0, 0);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-11-22 10:08:38 +0000
+++ tests/CMakeLists.txt	2012-11-23 23:52:20 +0000
@@ -233,6 +233,7 @@
                  test_previews_movie.cpp
                  test_previews_music.cpp
                  test_previews_social.cpp
+                 test_overlay_scrollbar.cpp
                  test_quicklist_menu_item.cpp
                  test_quicklist_view.cpp
                  test_resultviewgrid.cpp

=== added file 'tests/test_overlay_scrollbar.cpp'
--- tests/test_overlay_scrollbar.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_overlay_scrollbar.cpp	2012-11-23 23:52:20 +0000
@@ -0,0 +1,280 @@
+/*
+ * 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 <NuxCore/ObjectPtr.h>
+#include <Nux/VLayout.h>
+
+#include "unity-shared/VScrollBarOverlayWindow.h"
+#include "unity-shared/PlacesOverlayVScrollBar.h"
+#include "unity-shared/UScreen.h"
+
+using namespace testing;
+
+namespace
+{
+
+class TestOverlayWindow : public Test
+{
+public:
+  TestOverlayWindow()
+  {
+    overlay_window_ = new VScrollBarOverlayWindow(nux::Geometry(0,0,100,100));
+  }
+
+  int GetProxListSize() const
+  {
+    return nux::GetWindowThread()->GetWindowCompositor().GetProximityListSize();
+  }
+
+  nux::ObjectPtr<VScrollBarOverlayWindow> overlay_window_;
+};
+
+class TestOverlayScrollBar : public Test
+{
+public:
+  class MockScrollBar : public unity::dash::PlacesOverlayVScrollBar
+  {
+    public:
+      MockScrollBar(NUX_FILE_LINE_DECL)
+      : unity::dash::PlacesOverlayVScrollBar(NUX_FILE_LINE_PARAM)
+      , scroll_dy(0)
+      , scroll_up_signal_(false)
+      , scroll_down_signal_(false)
+      {
+        SetGeometry(nux::Geometry(0,0,200,500));
+        SetContainerSize(0,0,200,200);
+        SetContentSize(0,0,200,2000);
+        ComputeContentSize();
+
+        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;
+        });
+      }
+
+      void ScrollDown(int scroll_dy)
+      {
+        // Shows we are over the Overlay Thumb
+        int x = _track->GetBaseX() + _track->GetBaseWidth() + 5;
+        int y = _track->GetBaseY();
+
+        MoveMouse(x,y);
+        MoveDown(x,y);
+
+        MoveMouse(x,y+scroll_dy);
+        MoveUp(x,y+scroll_dy);
+      }
+
+      void ScrollUp(int scroll_dy)
+      {
+        ScrollDown(scroll_dy);
+
+        // Shows we are over the Overlay Thumb
+        int x = _track->GetBaseX() + _track->GetBaseWidth() + 5;
+        int y = _track->GetBaseY();
+
+        MoveMouse(x,y+scroll_dy);
+        MoveDown(x,y+scroll_dy);
+
+        MoveMouse(x,y);
+        MoveUp(x,y);
+      }
+
+      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);
+      }
+
+      using nux::VScrollBar::AtMinimum;
+      using nux::VScrollBar::GetBaseHeight;
+
+      int scroll_dy;
+      bool scroll_up_signal_;
+      bool scroll_down_signal_;
+  };
+
+  TestOverlayScrollBar()
+  {
+     scroll_bar_ = std::make_shared<MockScrollBar>(NUX_TRACKER_LOCATION);
+  }
+
+  std::shared_ptr<MockScrollBar> scroll_bar_;
+};
+
+TEST_F(TestOverlayWindow, TestOverlayShows)
+{
+  overlay_window_->MouseNear();
+  EXPECT_TRUE(overlay_window_->IsVisible());
+}
+
+TEST_F(TestOverlayWindow, TestOverlayHides)
+{
+  overlay_window_->MouseNear();
+  EXPECT_TRUE(overlay_window_->IsVisible());
+
+  overlay_window_->MouseBeyond();
+  EXPECT_FALSE(overlay_window_->IsVisible());
+}
+
+TEST_F(TestOverlayWindow, TestOverlayStaysOpenWhenMouseDown)
+{
+  overlay_window_->MouseNear();
+  overlay_window_->MouseDown();
+
+  overlay_window_->MouseBeyond();
+  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(TestOverlayScrollBar, TestScrollDownSignal)
+{
+  scroll_bar_->ScrollDown(10);
+  EXPECT_TRUE(scroll_bar_->scroll_down_signal_);
+}
+
+TEST_F(TestOverlayScrollBar, TestScrollUpSignal)
+{
+  scroll_bar_->ScrollUp(10);
+  EXPECT_TRUE(scroll_bar_->scroll_up_signal_);
+}
+
+TEST_F(TestOverlayScrollBar, TestScrollDownDeltaY)
+{
+  int scroll_down = 15;
+  scroll_bar_->ScrollDown(scroll_down);
+  EXPECT_EQ(scroll_bar_->scroll_dy, scroll_down);
+}
+
+TEST_F(TestOverlayScrollBar, TestScrollUpDeltaY)
+{
+  int scroll_up = 7;
+  scroll_bar_->ScrollUp(scroll_up);
+  EXPECT_EQ(scroll_bar_->scroll_dy, scroll_up);
+}
+
+TEST_F(TestOverlayScrollBar, TestScrollsSlowlyDeltaY)
+{
+  int scroll_down = 10;
+  for (int i = 0; i < scroll_down; i++)
+  {
+    scroll_bar_->ScrollDown(1);
+    EXPECT_EQ(scroll_bar_->scroll_dy, 1);
+  }
+}
+
+}

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2012-11-15 18:44:55 +0000
+++ unity-shared/CMakeLists.txt	2012-11-23 23:52:20 +0000
@@ -49,6 +49,7 @@
      OverlayRenderer.cpp
      PanelStyle.cpp
      PlacesVScrollBar.cpp
+     PlacesOverlayVScrollBar.cpp
      PreviewStyle.cpp
      RatingsButton.cpp
      SearchBar.cpp
@@ -66,6 +67,7 @@
      UnityWindowStyle.cpp
      UnityWindowView.cpp
      UserThumbnailProvider.cpp
+     VScrollBarOverlayWindow.cpp
      WindowManager.cpp
      XPathQueryPart.cpp
 )

=== added file 'unity-shared/PlacesOverlayVScrollBar.cpp'
--- unity-shared/PlacesOverlayVScrollBar.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/PlacesOverlayVScrollBar.cpp	2012-11-23 23:52:20 +0000
@@ -0,0 +1,417 @@
+// -*- 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 "PlacesOverlayVScrollBar.h"
+#include "CairoTexture.h"
+
+namespace
+{
+  int const PROXIMITY = 7;
+  int const SCROLL_ANIMATION = 400;
+  int const MAX_CONNECTOR_ANIMATION = 200;
+}
+
+namespace unity
+{
+namespace dash
+{
+
+PlacesOverlayVScrollBar::PlacesOverlayVScrollBar(NUX_FILE_LINE_DECL)
+  : PlacesVScrollBar(NUX_FILE_LINE_PARAM)
+  , overlay_window_(new VScrollBarOverlayWindow(_track->GetAbsoluteGeometry()))
+  , area_prox_(overlay_window_.GetPointer(), PROXIMITY)
+  , 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_->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));
+
+  _track->geometry_changed.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnTrackGeometryChanged));
+  OnVisibleChanged.connect(sigc::mem_fun(this, &PlacesOverlayVScrollBar::OnVisibilityChanged));
+}
+
+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::StopAnimation()
+{
+  if (animation_.CurrentState() != nux::animation::Animation::State::Stopped)
+    animation_.Stop();
+}
+
+void PlacesOverlayVScrollBar::SetupAnimation(int start, int stop, int milliseconds)
+{
+  tweening_connection_.disconnect();
+  delta_update_ = 0;
+
+  animation_.SetDuration(milliseconds);
+  animation_.SetEasingCurve(nux::animation::EasingCurve(nux::animation::EasingCurve::Type::Linear));
+
+  animation_.SetStartValue(start);
+  animation_.SetFinishValue(stop);
+}
+
+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_);
+      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::OnMouseNear(nux::Point const& mouse_pos)
+{
+  if (IsVisible() && IsScrollBarVisible())
+  {
+    StopAnimation();
+
+    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();
+  nux::Geometry const& intersection = (thumb_geo.Intersect(slider_geo));
+
+  if (!intersection.IsNull())
+  {
+    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()
+{
+  StartConnectorAnimation();
+  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*/)
+{
+  StopAnimation();
+  MouseDraggingOverlay(y, dy);
+}
+
+void PlacesOverlayVScrollBar::MouseDraggingOverlay(int y, int dys)
+{
+  int const dy = y - overlay_window_->GetThumbOffsetY() - mouse_down_offset_;
+  int const at_min = overlay_window_->GetThumbOffsetY() <= 0;
+  int const at_max = overlay_window_->GetThumbOffsetY() + overlay_window_->GetThumbHeight() >= _track->GetBaseHeight();
+
+  if (dy < 0 && !at_min)
+  {
+    OnScrollUp.emit(stepY, abs(dy));
+  }
+  else if (dy > 0 && !at_max)
+  {
+    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 = 3;
+  int height = connector_height_;
+  float const radius = 1.5f;
+  float const aspect = 1.0f;
+
+  cairo_t* cr = NULL;
+
+  nux::color::RedGreenBlue const& connector_bg = nux::color::Gray;
+
+  nux::CairoGraphics cairoGraphics(CAIRO_FORMAT_ARGB32, width, height);
+  cr = cairoGraphics.GetContext();
+  cairo_save(cr);
+
+  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint(cr);
+
+  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+  cairo_save(cr);
+
+  cairo_set_source_rgba(cr, connector_bg.red, connector_bg.green, connector_bg.blue, 0.8);
+  cairoGraphics.DrawRoundedRectangle(cr, aspect, 0.0f, 0.0f, radius, width, height);
+  cairo_fill_preserve(cr);
+
+  connector_texture_.Adopt(texture_from_cairo_graphics(cairoGraphics));
+  cairo_destroy(cr);
+
+  QueueDraw();
+}
+
+} // namespace dash
+} // namespace unity
+

=== added file 'unity-shared/PlacesOverlayVScrollBar.h'
--- unity-shared/PlacesOverlayVScrollBar.h	1970-01-01 00:00:00 +0000
+++ unity-shared/PlacesOverlayVScrollBar.h	2012-11-23 23:52:20 +0000
@@ -0,0 +1,107 @@
+// -*- 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 PLACES_OVERLAY_VSCROLLBAR_H
+#define PLACES_OVERLAY_VSCROLLBAR_H
+
+#include <Nux/Nux.h>
+#include <Nux/InputAreaProximity.h>
+#include <NuxCore/Animation.h>
+#include <memory>
+
+#include "unity-shared/PlacesVScrollBar.h"
+#include "unity-shared/VScrollBarOverlayWindow.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class PlacesOverlayVScrollBar: public PlacesVScrollBar
+{
+public:
+  PlacesOverlayVScrollBar(NUX_FILE_LINE_PROTO);
+
+protected:
+  void Draw(nux::GraphicsEngine& graphics_engine, bool force_draw);
+
+private:
+  enum class ScrollDir : unsigned int
+  {
+    UP,
+    DOWN,
+  };
+
+  void OnTrackGeometryChanged(nux::Area* area, nux::Geometry& geo);
+  void OnVisibilityChanged(nux::Area* area, bool visible);
+
+  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 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 StopAnimation();
+
+  void StartScrollAnimation(ScrollDir dir, int stop);
+  void OnScroll(ScrollDir dir, int mouse_dy);
+
+  void StartConnectorAnimation();
+
+  void UpdateConnectorTexture();
+
+  nux::ObjectPtr<VScrollBarOverlayWindow> overlay_window_;
+  nux::InputAreaProximity area_prox_;
+
+  nux::animation::AnimateValue<int> animation_;
+  sigc::connection tweening_connection_;
+
+  nux::ObjectPtr<nux::BaseTexture> connector_texture_;
+  
+  bool thumb_above_slider_;
+  int connector_height_;
+  int mouse_down_offset_;
+  int delta_update_;
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // PLACES_OVERLAY_VSCROLLBAR_H

=== added file 'unity-shared/VScrollBarOverlayWindow.cpp'
--- unity-shared/VScrollBarOverlayWindow.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/VScrollBarOverlayWindow.cpp	2012-11-23 23:52:20 +0000
@@ -0,0 +1,526 @@
+// -*- 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"
+
+namespace
+{
+  int const THUMB_WIDTH = 21;
+  int const THUMB_HEIGHT = 68;
+  int const THUMB_RADIUS = 3;
+}
+
+
+VScrollBarOverlayWindow::VScrollBarOverlayWindow(nux::Geometry const& geo)
+  : nux::BaseWindow("")
+  , content_size_(geo)
+  , content_offset_x_(0)
+  , mouse_offset_y_(0)
+  , mouse_down_(false)
+  , mouse_near_(false)
+  , inside_slider_(false)
+  , current_action_(ThumbAction::NONE)
+{
+  Area::SetGeometry(content_size_.x, content_size_.y, THUMB_WIDTH, content_size_.height);
+  SetBackgroundColor(nux::color::Transparent);
+
+  UpdateTexture();
+}
+
+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;
+    UpdateMouseOffsetX();
+
+    Area::SetGeometry(content_size_.x + content_offset_x_, content_size_.y, THUMB_WIDTH, content_size_.height);
+  }
+}
+
+void VScrollBarOverlayWindow::SetThumbOffsetY(int y)
+{
+  int const new_offset = GetValidOffsetYValue(y);
+
+  if (new_offset != mouse_offset_y_)
+  {
+    if (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)
+    return content_size_.height - THUMB_HEIGHT;
+
+  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 > geo.x + geo.width)
+    content_offset_x_ = geo.x + geo.width - (content_size_.x + THUMB_WIDTH);
+  else
+    content_offset_x_ = 0;
+}
+
+bool VScrollBarOverlayWindow::IsMouseInsideThumb(int y) const
+{
+  nux::Geometry const thumb(0, mouse_offset_y_, THUMB_WIDTH, THUMB_HEIGHT);
+  return thumb.IsPointInside(0,y);
+}
+
+bool VScrollBarOverlayWindow::IsMouseBeingDragged() const
+{
+  return current_action_ == ThumbAction::DRAGGING;
+}
+
+int VScrollBarOverlayWindow::GetThumbHeight() const
+{
+  return THUMB_HEIGHT;
+}
+
+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, THUMB_HEIGHT);
+}
+
+void VScrollBarOverlayWindow::MouseDown()
+{
+  mouse_down_ = true;
+  UpdateTexture();
+}
+
+void VScrollBarOverlayWindow::MouseUp()
+{
+  mouse_down_ = false;
+  current_action_ = ThumbAction::NONE;
+  UpdateTexture();
+  ShouldHide();
+}
+
+void VScrollBarOverlayWindow::MouseNear()
+{
+  mouse_near_ = true;
+  ShouldShow();
+}
+
+void VScrollBarOverlayWindow::MouseBeyond()
+{
+  mouse_near_ = false;
+  ShouldHide();
+}
+
+void VScrollBarOverlayWindow::ThumbInsideSlider()
+{
+  if (!inside_slider_)
+  {
+    inside_slider_ = true;
+    UpdateTexture();
+  }
+}
+
+void VScrollBarOverlayWindow::ThumbOutsideSlider()
+{
+  if (inside_slider_)
+  {
+    inside_slider_ = false;
+    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 (mouse_down_ || mouse_near_)
+    {
+      ShowWindow(true);
+      PushToFront();
+      QueueDraw();
+    }
+  }
+}
+
+void VScrollBarOverlayWindow::ShouldHide()
+{
+  if (IsVisible())
+  {
+    if (!mouse_down_ && !mouse_near_)
+    {
+      ShowWindow(false);
+      QueueDraw();
+    }
+  }
+}
+
+void VScrollBarOverlayWindow::ResetStates()
+{
+  mouse_down_ = false;
+  mouse_near_ = false;
+  current_action_ = ThumbAction::NONE;
+  ShouldHide();
+}
+
+void VScrollBarOverlayWindow::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+{
+  if (!thumb_texture_)
+    return;
+
+  nux::Geometry base(0, mouse_offset_y_, THUMB_WIDTH, THUMB_HEIGHT);
+  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;
+  int radius = THUMB_RADIUS;
+
+  float const aspect = 1.0f;
+  float current_x = 0.0f;
+  float current_y = 0.0f;
+
+  cairo_t*            cr            = NULL;
+  cairo_pattern_t*    pat           = NULL;
+
+  nux::color::RedGreenBlue const& bg = nux::color::WhiteSmoke;
+  nux::color::RedGreenBlue const& bg_selected = nux::color::White;
+  nux::color::RedGreenBlue const& bg_active = nux::color::Gray;
+  nux::color::RedGreenBlue const& arrow_color = nux::color::DarkSlateGray;
+
+  nux::color::RedGreenBlue const& bg_arrow_up = ProduceColorShade(bg, 0.86);
+  nux::color::RedGreenBlue const& bg_arrow_down = ProduceColorShade(bg, 1.1);
+  nux::color::RedGreenBlue const& bg_shadow = ProduceColorShade(bg, 0.2);
+
+  nux::color::RedGreenBlue const& bg_dark_line = ProduceColorShade(bg, 0.4);
+  nux::color::RedGreenBlue const& bg_bright_line = ProduceColorShade(bg, 1.2);
+
+  nux::CairoGraphics cairoGraphics(CAIRO_FORMAT_ARGB32, width, height);
+  cr = cairoGraphics.GetContext();
+
+  cairo_save(cr);
+
+  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint(cr);
+
+  cairo_save(cr);
+
+  cairo_translate (cr, 0.5, 0.5);
+  width--;
+  height--;
+
+  cairo_set_line_width (cr, 1.0);
+
+  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+  cairo_save(cr);
+
+  // Draw backgound
+  SetSourceRGB(cr, bg, 1.0);
+  cairoGraphics.DrawRoundedRectangle(cr, aspect, current_x, current_y, radius, width, height);
+  cairo_fill_preserve(cr);
+
+  // Draw shaded background
+  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, radius - 1, width - 1, height - 1);
+
+  if (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, radius, width- 2, height - 2);
+  cairo_stroke(cr);
+
+  current_x += 1.0;
+  current_y += 1.0;
+  cairoGraphics.DrawRoundedRectangle(cr, aspect, current_x, current_y, 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_.Adopt(unity::texture_from_cairo_graphics(cairoGraphics));
+  cairo_destroy(cr);
+
+  QueueDraw();
+}

=== added file 'unity-shared/VScrollBarOverlayWindow.h'
--- unity-shared/VScrollBarOverlayWindow.h	1970-01-01 00:00:00 +0000
+++ unity-shared/VScrollBarOverlayWindow.h	2012-11-23 23:52:20 +0000
@@ -0,0 +1,92 @@
+// -*- 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>
+
+
+class VScrollBarOverlayWindow : public nux::BaseWindow
+{
+public:
+  VScrollBarOverlayWindow(nux::Geometry const& geo);
+
+  void UpdateGeometry(nux::Geometry const& geo);
+  void SetThumbOffsetY(int y);
+
+  void MouseDown();
+  void MouseUp();
+
+  void MouseNear();
+  void MouseBeyond();
+
+  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
+  };
+
+  void MouseDragging();
+  void UpdateMouseOffsetX();
+  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_;
+
+  bool mouse_down_;
+  bool mouse_near_;
+  bool inside_slider_;
+
+  ThumbAction current_action_;
+};
+
+#endif