Merge lp:~smspillaz/unity/unity.gesture_tests_no_sed into lp:unity

[Sam Spilsbury]

DO NOT COMMIT OR MERGE

Get the gesture tests to work without using sed scripts and recompiling files on every build.

This only requires testing to make sure it still works, don't worry about actually reviewing the code because the diff is huge and I plan to split it up into managable chunks anwyays.

I can't test this myself because

1) My hardware doesn't work
2) My drivers don't work

I've only gone on the basis that the tests continue to pass. And even then I had to mess around with the tests too as I switched from evaluating stubs to using google mock.

Requires nux from: https://code.launchpad.net/~smspillaz/nux/nux.gesture-targets-unavailable/+merge/136320

[Daniel d'Andrada (dandrader)]

It doesn't build:

Building CXX object gestures/CMakeFiles/gestures-lib.dir/WindowGestureTarget.cpp.o
/home/dandrader/unity/unity.gesture_tests_no_sed/gestures/WindowGestureTarget.cpp: In member function ‘void WindowGestureTarget::OnManipulatedWindowDestruction()’:
/home/dandrader/unity/unity.gesture_tests_no_sed/gestures/WindowGestureTarget.cpp:67:3: error: ‘on_target_unavailable’ was not declared in this scope
make[2]: *** [gestures/CMakeFiles/gestures-lib.dir/WindowGestureTarget.cpp.o] Error 1
make[1]: *** [gestures/CMakeFiles/gestures-lib.dir/all] Error 2
make: *** [all] Error 2

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Ah. Sorry. I forgot that this requires a special version of nux. I'll put
that up tomorrow. Sorry about the bother.
On 26/11/2012 10:39 PM, "Daniel d'Andrada" <email address hidden>
wrote:

> Review: Needs Fixing
>
> It doesn't build:
>
> Building CXX object
> gestures/CMakeFiles/gestures-lib.dir/WindowGestureTarget.cpp.o
> /home/dandrader/unity/unity.gesture_tests_no_sed/gestures/WindowGestureTarget.cpp:
> In member function ‘void
> WindowGestureTarget::OnManipulatedWindowDestruction()’:
> /home/dandrader/unity/unity.gesture_tests_no_sed/gestures/WindowGestureTarget.cpp:67:3:
> error: ‘on_target_unavailable’ was not declared in this scope
> make[2]: ***
> [gestures/CMakeFiles/gestures-lib.dir/WindowGestureTarget.cpp.o] Error 1
> make[1]: *** [gestures/CMakeFiles/gestures-lib.dir/all] Error 2
> make: *** [all] Error 2
>
> --
>
> https://code.launchpad.net/~smspillaz/unity/unity.gesture_tests_no_sed/+merge/136108
> You are the owner of lp:~smspillaz/unity/unity.gesture_tests_no_sed.
>

[Sam Spilsbury (smspillaz)]

Thanks for the note. I've resubmitted this now with the conflicts resolved and a link to the nux changes required to get this building. I'll keep cleaning it up as we go I guess.

[lp:~smspillaz/unity/unity.gesture_tests_no_sed]

2814. By Sam Spilsbury on 2012-11-27

Remove some redundant files, convert GesturalWindowSwitcherMock to gmock

2815. By Sam Spilsbury on 2012-11-27

Remove CompWindowMock

2816. By Sam Spilsbury on 2012-11-27

Reason about the effect of SetupAndShowSwitcher through a gmock instead
of tracking the number of calls with ASSERT_EQ

2817. By Sam Spilsbury on 2012-11-27

Adapt API

2818. By Sam Spilsbury on 2012-11-28

Merge lp:unity

2819. By Sam Spilsbury on 2012-11-28

Separate MockSwitcherController and StubSwitcherController

[Daniel d'Andrada (dandrader)]

When I move a window around with three fingers, I can only move it to the right and it also triggers the grid plugin (half-screen maximization) all the time while doing to.
On top of that, I get a segfault after closing the windows (with alf+f4) I opened during the test mentioned above.

Things still work fine with trunk of unity minus your patches.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Thanks for testing :) Ill see if I can get my system into a state where I
can test this manually again so start working on some regression tests for
the areas you identified.
On 29/11/2012 3:54 AM, "Daniel d'Andrada" <email address hidden>
wrote:

> Review: Needs Fixing
>
> When I move a window around with three fingers, I can only move it to the
> right and it also triggers the grid plugin (half-screen maximization) all
> the time while doing to.
> On top of that, I get a segfault after closing the windows (with alf+f4) I
> opened during the test mentioned above.
>
> Things still work fine with trunk of unity minus your patches.
> --
>
> https://code.launchpad.net/~smspillaz/unity/unity.gesture_tests_no_sed/+merge/136321
> You are the owner of lp:~smspillaz/unity/unity.gesture_tests_no_sed.
>

[lp:~smspillaz/unity/unity.gesture_tests_no_sed]

2820. By Sam Spilsbury on 2012-11-29

[ FAILED ] ApplyDelta.ApplyPosX
[ FAILED ] ApplyDelta.ApplyPosY
[ FAILED ] ApplyDelta.ApplyNegX
[ FAILED ] ApplyDelta.ApplyNegY

2821. By Sam Spilsbury on 2012-11-29

[ RUN ] ApplyDelta.ApplyPosX
[ OK ] ApplyDelta.ApplyPosX (0 ms)
[ RUN ] ApplyDelta.ApplyPosY
[ OK ] ApplyDelta.ApplyPosY (0 ms)
[ RUN ] ApplyDelta.ApplyNegX
[ OK ] ApplyDelta.ApplyNegX (0 ms)
[ RUN ] ApplyDelta.ApplyNegY
[ OK ] ApplyDelta.ApplyNegY (0 ms)

2822. By Sam Spilsbury on 2012-11-29

Do not pass XWarpPointer relative co-ordinates

2823. By Sam Spilsbury on 2012-11-29

Test that indicates broken destroy behaviour of GestureManipulatedWindow
[----------] 7 tests from WindowGestureTargetTest
[ RUN ] WindowGestureTargetTest.GestureManipulatedWindowDeath
pure virtual method called
terminate called without an active exception
Aborted (core dumped)

2824. By Sam Spilsbury on 2012-11-29

[----------] 7 tests from WindowGestureTargetTest
[ RUN ] WindowGestureTargetTest.GestureManipulatedWindowDeath
[ OK ] WindowGestureTargetTest.GestureManipulatedWindowDeath (0 ms)

Track the manipulated window death, don't call pure virtual methods on it
in that case and store the id so we can still use Equals()

[Sam Spilsbury (smspillaz)]

Okay, I've managed to get a working system back (woo, no more running lxde !) and I've identified and fixed the issues you've described.

The only other problem was that I can't get the gestural window switcher to work, but I can't get it to work on trunk either, and I don't really know what the gesture is to make it work. Is it known to be broken at the moment?

If the behaviour is all good, I'll start splitting this up into bits that don't depend on each other.

[lp:~smspillaz/unity/unity.gesture_tests_no_sed]

2825. By Sam Spilsbury on 2012-11-29

Merge lp:unity

[Sam Spilsbury (smspillaz)]

(Ping - let me know once manual testing is ok, and we can discuss how best to break this up into reviewable chunks)

[Daniel d'Andrada (dandrader)]

> [...]
> The only other problem was that I can't get the gestural window switcher to
> work, but I can't get it to work on trunk either, and I don't really know what
> the gesture is to make it work. Is it known to be broken at the moment?
> [...]

The gestures are explained in the documentation of this class. Check GesturalWindowSwitcher.h. And yes, they do work on trunk.

[Daniel d'Andrada (dandrader)]

Now gestures are working again.

review: Approve

[Sam Spilsbury (smspillaz)]

OK, great :)

Now, how do we get this broken up into pieces ... I propose:

1. New mocks (eg, MockWindowManager, MockSwitcherController)
2. Delta restrainment class
3. AbstractInterfaceGenerator
4. "dependency breaking" classes (eg CompizX11MousePointer, CompizGestureManipulatedWindow)
5. Getting the tests working without sed-mocking (probably still going to be huge, but not as huge)

[lp:~smspillaz/unity/unity.gesture_tests_no_sed]

2826. By Sam Spilsbury on 2012-12-03

Merge lp:unity

2827. By Sam Spilsbury on 2012-12-05

Actually add the test to the CMakeLists.txt

2828. By Sam Spilsbury on 2012-12-05

Merge lp:unity

2829. By Sam Spilsbury on 2012-12-07

Adjust MockWindowManager

2830. By Sam Spilsbury on 2012-12-07

Merge lp:unity

2831. By Sam Spilsbury on 2012-12-13

Remove ApplyDelta

2832. By Sam Spilsbury on 2012-12-13

Merge lp:unity

[Jussi Pakkanen (jpakkane)]

An easier way of getting rid of sed mocking is to add a USE_MOCKS definition and then in the source files just do

#ifdef USE_MOCKS
/* include mock headers. */
#else
/* include original versions. */
#endif

[Jussi Pakkanen (jpakkane)]

Okay, the sed scripts are even more evil than I suspected. But still it should be possible to have a header with stuff like this:

#define ClassName ClassNameMock

which would be slightly less evil.

[Sam Spilsbury (smspillaz)]

On Mon, Dec 17, 2012 at 10:28 PM, Jussi Pakkanen
<email address hidden> wrote:
> Okay, the sed scripts are even more evil than I suspected. But still it should be possible to have a header with stuff like this:
>
> #define ClassName ClassNameMock
>
> which would be slightly less evil.

An even better way is to refactor the code so that it doesn't need to
be recompiled twice :)

> --
> https://code.launchpad.net/~smspillaz/unity/unity.gesture_tests_no_sed/+merge/136321
> You are the owner of lp:~smspillaz/unity/unity.gesture_tests_no_sed.

--
Sam Spilsbury

[lp:~smspillaz/unity/unity.gesture_tests_no_sed]

2833. By Sam Spilsbury on 2012-12-18

Merge lp:unity

2834. By Sam Spilsbury on 2012-12-19

Merge from abstract_interaface_generator

2835. By Sam Spilsbury on 2012-12-19

Should be CompWindow * const &

2836. By Sam Spilsbury on 2012-12-19

Merge lp:unity

2837. By Sam Spilsbury on 2012-12-19

Merge new Switcher interface work

2838. By Sam Spilsbury on 2012-12-19

Initialize accumululated_horizontal_drag

Unmerged revisions

2838. By Sam Spilsbury on 2012-12-19

Initialize accumululated_horizontal_drag

2837. By Sam Spilsbury on 2012-12-19

Merge new Switcher interface work

2836. By Sam Spilsbury on 2012-12-19

Merge lp:unity

2835. By Sam Spilsbury on 2012-12-19

Should be CompWindow * const &

2834. By Sam Spilsbury on 2012-12-19

Merge from abstract_interaface_generator

2833. By Sam Spilsbury on 2012-12-18

Merge lp:unity

2832. By Sam Spilsbury on 2012-12-13

Merge lp:unity

2831. By Sam Spilsbury on 2012-12-13

Remove ApplyDelta

2830. By Sam Spilsbury on 2012-12-07

Merge lp:unity

2829. By Sam Spilsbury on 2012-12-07

Adjust MockWindowManager

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-12-13 07:56:59 +0000
+++ CMakeLists.txt	2012-12-19 14:00:32 +0000
@@ -222,6 +222,7 @@
 pkg_check_modules (CACHED_UNITY_DEPS REQUIRED ${UNITY_PLUGIN_DEPS})
 pkg_check_modules (CACHED_UNITY_PRIVATE_DEPS REQUIRED ${UNITY_PROTOCOL_PRIVATE_DEPS})
 add_subdirectory(unity-shared)
+add_subdirectory(gestures)
 add_subdirectory(dash)
 add_subdirectory(launcher)
 if (ENABLE_X_SUPPORT)

=== added directory 'gestures'
=== added file 'gestures/CMakeLists.txt'
--- gestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ gestures/CMakeLists.txt	2012-12-19 14:00:32 +0000
@@ -0,0 +1,59 @@
+set(UNITY_SRC ../plugins/unityshell/src)
+set(UNITY_SHARED_SRC ../unity-shared)
+set(UNITY_SWITCHER_SRC ../launcher)
+set(UNITY_CORE_SRC ../UnityCore)
+set(SERVICES_SRC ../services)
+set(TOP_SRC_DIR ${CMAKE_SOURCE_DIR})
+set(TOP_BINARY_DIR ${CMAKE_BINARY_DIR})
+
+find_package (PkgConfig)
+
+set (CFLAGS
+     ${CACHED_UNITY_DEPS_CFLAGS}
+     ${CACHED_UNITY_DEPS_CFLAGS_OTHER}
+     ${MAINTAINER_CFLAGS}
+     "-fPIC"
+     "-DGETTEXT_PACKAGE=\"unity\""
+     "-I${CMAKE_CURRENT_BINARY_DIR}"
+     )
+
+if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
+  set (CFLAGS ${CFLAGS} "-fPIC")
+endif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
+
+add_definitions (${CFLAGS})
+
+set (LIBS ${CACHED_UNITY_DEPS_LIBRARIES} ${UNITY_STANDALONE_LADD})
+set (LIB_PATHS ${CACHED_UNITY_DEPS_LIBRARY_DIRS})
+
+link_directories (${CMAKE_BINARY_DIR}/UnityCore
+                  ${LIB_PATHS})
+
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}
+                     ${UNITY_SRC}
+                     ${UNITY_CORE_SRC}
+                     ${UNITY_SWITCHER_SRC}
+                     ${UNITY_SHARED_SRC}
+                     ${SERVICES_SRC}
+                     ${TOP_SRC_DIR}
+                     ${TOP_BINARY_DIR})
+
+#
+# Headers & Sources
+#
+set (GESTURES_SOURCES
+     WindowGestureTarget.cpp
+     UnityGestureBroker.cpp
+     CompoundGestureRecognizer.cpp
+     CompoundGestureRecognizer.h
+     GesturalWindowSwitcher.cpp
+     GesturalWindowSwitcher.h
+     )
+
+add_library (gestures-lib STATIC ${GESTURES_SOURCES})
+target_link_libraries (gestures-lib
+                       unity-shared
+                       unity-core-${UNITY_API_VERSION}
+                       unity-shared
+                       switcher-lib
+                       ${LIBS})

=== renamed file 'plugins/unityshell/src/CompoundGestureRecognizer.cpp' => 'gestures/CompoundGestureRecognizer.cpp'
=== renamed file 'plugins/unityshell/src/CompoundGestureRecognizer.h' => 'gestures/CompoundGestureRecognizer.h'
=== renamed file 'plugins/unityshell/src/GesturalWindowSwitcher.cpp' => 'gestures/GesturalWindowSwitcher.cpp'
--- plugins/unityshell/src/GesturalWindowSwitcher.cpp	2012-10-29 09:34:54 +0000
+++ gestures/GesturalWindowSwitcher.cpp	2012-12-19 14:00:32 +0000
@@ -20,25 +20,29 @@
  * Authored by: Daniel d'Andrada <[e-mail]>
  */
 
+#include <tuple>
 #include "GesturalWindowSwitcher.h"
 #include <Nux/Nux.h>
 #include <NuxCore/Logger.h>
-#include "unityshell.h"
+#include <UnityCore/GLibSource.h>
 
 DECLARE_LOGGER(logger, "unity.gesture.switcher");
 
 using namespace nux;
 using namespace unity;
 
-const float GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION = 100.0f;
-const float GesturalWindowSwitcher::MOUSE_DRAG_THRESHOLD = 20.0f;
+const float GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION = 100.0f;
+const float GesturalWindowSwitcherImpl::MOUSE_DRAG_THRESHOLD = 20.0f;
 
 namespace unity
 {
   class GesturalWindowSwitcherPrivate
   {
    public:
-    GesturalWindowSwitcherPrivate();
+    typedef GesturalWindowSwitcherImpl::SetUpAndShowSwitcherFunc SetUpAndShowSwitcherFunc;
+    GesturalWindowSwitcherPrivate(const unity::switcher::Controller::Ptr           &switcher_controller,
+                                  const SetUpAndShowSwitcherFunc                   &set_up_and_show_switcher,
+                                  const GesturalWindowSwitcherActionInvokerFactory &action_invoker_factory);
     virtual ~GesturalWindowSwitcherPrivate();
 
     void CloseSwitcherAfterTimeout(int timeout);
@@ -82,43 +86,44 @@
       WaitingMandatorySwitcherClose,
     } state;
 
-    unity::UnityScreen* unity_screen;
     unity::switcher::Controller::Ptr switcher_controller;
+    GesturalWindowSwitcherImpl::SetUpAndShowSwitcherFunc set_up_and_show_switcher_;
+    GesturalWindowSwitcherActionInvoker::Ptr        action_invoker_;
     CompoundGestureRecognizer gesture_recognizer;
-    CompTimer timer_close_switcher;
     float accumulated_horizontal_drag;
     int index_icon_hit;
 
     sigc::connection view_built_connection;
-    sigc::connection mouse_down_connection;
-    sigc::connection mouse_up_connection;
-    sigc::connection mouse_drag_connection;
+    unity::switcher::View::MouseEventConnections mouse_connections_;
   };
 }
 
 ///////////////////////////////////////////
 // private class
 
-GesturalWindowSwitcherPrivate::GesturalWindowSwitcherPrivate()
+GesturalWindowSwitcherPrivate::GesturalWindowSwitcherPrivate(const unity::switcher::Controller::Ptr           &switcher_controller,
+                                                             const SetUpAndShowSwitcherFunc                   &set_up_and_show_switcher,
+                                                             const GesturalWindowSwitcherActionInvokerFactory &action_invoker_factory) :
+  switcher_controller (switcher_controller),
+  set_up_and_show_switcher_ (set_up_and_show_switcher),
+  action_invoker_ (action_invoker_factory.CreateActionInvoker(std::bind (&GesturalWindowSwitcherPrivate::OnCloseSwitcherTimeout,
+                                                                         this))),
+  accumulated_horizontal_drag(0.0f)
 {
   state = State::WaitingCompoundGesture;
 
-  unity_screen = unity::UnityScreen::get(screen);
-  switcher_controller = unity_screen->switcher_controller();
-
-  timer_close_switcher.setCallback(
-      boost::bind(&GesturalWindowSwitcherPrivate::OnCloseSwitcherTimeout, this));
-
-  view_built_connection = switcher_controller->view_built.connect(
-      sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ConnectToSwitcherViewMouseEvents));
+  action_invoker_->StopPendingInvocation();;
+
+  view_built_connection = switcher_controller->ConnectToViewBuilt(
+        sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ConnectToSwitcherViewMouseEvents));
 }
 
 GesturalWindowSwitcherPrivate::~GesturalWindowSwitcherPrivate()
 {
   view_built_connection.disconnect();
-  mouse_down_connection.disconnect();
-  mouse_up_connection.disconnect();
-  mouse_drag_connection.disconnect();
+  std::get <0> (mouse_connections_).disconnect();
+  std::get <1> (mouse_connections_).disconnect();
+  std::get <2> (mouse_connections_).disconnect();
 }
 
 GestureDeliveryRequest GesturalWindowSwitcherPrivate::GestureEvent(nux::GestureEvent const& event)
@@ -165,7 +170,7 @@
       break;
     case RecognitionResult::DOUBLE_TAP_RECOGNIZED:
       InitiateSwitcherNext();
-      CloseSwitcherAfterTimeout(GesturalWindowSwitcher::SWITCHER_TIME_AFTER_DOUBLE_TAP);
+      CloseSwitcherAfterTimeout(GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_DOUBLE_TAP);
       break;
     default: // RecognitionResult::TAP_AND_HOLD_RECOGNIZED:
       InitiateSwitcherNext();
@@ -197,7 +202,7 @@
   }
   else // event.type == EVENT_GESTURE_END
   {
-    CloseSwitcherAfterTimeout(GesturalWindowSwitcher::SWITCHER_TIME_AFTER_HOLD_RELEASED);
+    CloseSwitcherAfterTimeout(GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_HOLD_RELEASED);
     state = State::WaitingSwitcherManipulation;
   }
 
@@ -218,7 +223,7 @@
   if (event.GetGestureClasses() & nux::DRAG_GESTURE)
   {
     state = State::DraggingSwitcher;
-    timer_close_switcher.stop();
+    action_invoker_->StopPendingInvocation();
     DraggingSwitcher(event);
   }
 
@@ -273,11 +278,7 @@
 
 void GesturalWindowSwitcherPrivate::CloseSwitcherAfterTimeout(int timeout)
 {
-  timer_close_switcher.stop();
-  // min and max timeouts
-  timer_close_switcher.setTimes(timeout,
-                                 timeout+50);
-  timer_close_switcher.start();
+  action_invoker_->InvokeOnTimeout (timeout);
 }
 
 bool GesturalWindowSwitcherPrivate::OnCloseSwitcherTimeout()
@@ -299,24 +300,24 @@
 
 void GesturalWindowSwitcherPrivate::CloseSwitcher()
 {
-  switcher_controller->Hide();
+  switcher_controller->Hide(true);
 }
 
 void GesturalWindowSwitcherPrivate::InitiateSwitcherNext()
 {
-  timer_close_switcher.stop();
+  action_invoker_->StopPendingInvocation();;
 
   if (switcher_controller->Visible())
     switcher_controller->Next();
   else
   {
-    unity_screen->SetUpAndShowSwitcher();
+    set_up_and_show_switcher_ ();
   }
 }
 
 void GesturalWindowSwitcherPrivate::InitiateSwitcherPrevious()
 {
-  timer_close_switcher.stop();
+  action_invoker_->StopPendingInvocation();;
 
   if (switcher_controller->Visible())
   {
@@ -331,11 +332,13 @@
     return;
 
   // Don't close the switcher while the mouse is pressed over it
-  timer_close_switcher.stop();
+  action_invoker_->StopPendingInvocation();;
 
   state = State::RecognizingMouseClickOrDrag;
 
-  index_icon_hit = switcher_controller->GetView()->IconIndexAt(x, y);
+  unity::switcher::View *view = switcher_controller->GetView();
+
+  index_icon_hit = view->IconIndexAt(x, y);
   accumulated_horizontal_drag = 0.0f;
 }
 
@@ -350,7 +353,7 @@
         // it was a click after all.
         switcher_controller->Select(index_icon_hit);
         // it was not a double tap gesture but we use the same timeout
-        CloseSwitcherAfterTimeout(GesturalWindowSwitcher::SWITCHER_TIME_AFTER_DOUBLE_TAP);
+        CloseSwitcherAfterTimeout(GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_DOUBLE_TAP);
         state = State::WaitingMandatorySwitcherClose;
       }
       else
@@ -377,7 +380,7 @@
     case State::RecognizingMouseClickOrDrag:
       accumulated_horizontal_drag += dx;
       if (fabsf(accumulated_horizontal_drag) >=
-          GesturalWindowSwitcher::MOUSE_DRAG_THRESHOLD)
+          GesturalWindowSwitcherImpl::MOUSE_DRAG_THRESHOLD)
       {
         state = State::DraggingSwitcherWithMouse;
         ProcessAccumulatedHorizontalDrag();
@@ -396,13 +399,13 @@
 void GesturalWindowSwitcherPrivate::ProcessAccumulatedHorizontalDrag()
 {
   if (accumulated_horizontal_drag >=
-      GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION)
+      GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION)
   {
     InitiateSwitcherNext();
     accumulated_horizontal_drag = 0.0f;
   }
   else if (accumulated_horizontal_drag <=
-      -GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION)
+      -GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION)
   {
     InitiateSwitcherPrevious();
     accumulated_horizontal_drag = 0.0f;
@@ -411,33 +414,32 @@
 
 void GesturalWindowSwitcherPrivate::ConnectToSwitcherViewMouseEvents()
 {
-  unity::switcher::SwitcherView *switcher_view = switcher_controller->GetView();
+  unity::switcher::View *switcher_view = switcher_controller->GetView();
   g_assert(switcher_view);
 
-  mouse_down_connection = switcher_view->mouse_down.connect(
-      sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ProcessSwitcherViewMouseDown));
-
-  mouse_up_connection = switcher_view->mouse_up.connect(
-      sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ProcessSwitcherViewMouseUp));
-
-  mouse_drag_connection = switcher_view->mouse_drag.connect(
+  mouse_connections_ =
+    switcher_view->ConnectToMouseEvents(sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ProcessSwitcherViewMouseDown),
+      sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ProcessSwitcherViewMouseUp),
       sigc::mem_fun(this, &GesturalWindowSwitcherPrivate::ProcessSwitcherViewMouseDrag));
+
 }
 
 ///////////////////////////////////////////
 // public class
 
-GesturalWindowSwitcher::GesturalWindowSwitcher()
-  : p(new GesturalWindowSwitcherPrivate)
+GesturalWindowSwitcherImpl::GesturalWindowSwitcherImpl(const unity::switcher::Controller::Ptr           &switcher_controller,
+                                                       const SetUpAndShowSwitcherFunc                   &set_up_and_show_switcher,
+                                                       const GesturalWindowSwitcherActionInvokerFactory &action_invoker_factory)
+  : p(new GesturalWindowSwitcherPrivate (switcher_controller, set_up_and_show_switcher, action_invoker_factory))
 {
 }
 
-GesturalWindowSwitcher::~GesturalWindowSwitcher()
+GesturalWindowSwitcherImpl::~GesturalWindowSwitcherImpl()
 {
   delete p;
 }
 
-GestureDeliveryRequest GesturalWindowSwitcher::GestureEvent(nux::GestureEvent const& event)
+GestureDeliveryRequest GesturalWindowSwitcherImpl::GestureEvent(nux::GestureEvent const& event)
 {
   return p->GestureEvent(event);
 }

=== renamed file 'plugins/unityshell/src/GesturalWindowSwitcher.h' => 'gestures/GesturalWindowSwitcher.h'
--- plugins/unityshell/src/GesturalWindowSwitcher.h	2012-08-14 13:57:32 +0000
+++ gestures/GesturalWindowSwitcher.h	2012-12-19 14:00:32 +0000
@@ -55,11 +55,45 @@
      - tap on some window icon -> selects that icon and closes the switcher
 
  */
-class GesturalWindowSwitcher : public nux::GestureTarget
-{
-  public:
-    GesturalWindowSwitcher();
-    virtual ~GesturalWindowSwitcher();
+class GesturalWindowSwitcherInterface : public nux::GestureTarget
+{
+  public:
+
+    virtual ~GesturalWindowSwitcherInterface () {}
+    virtual nux::GestureDeliveryRequest GestureEvent(nux::GestureEvent const& event) = 0;
+};
+
+class GesturalWindowSwitcherActionInvoker
+{
+  public:
+
+    typedef std::shared_ptr <GesturalWindowSwitcherActionInvoker> Ptr;
+
+    virtual ~GesturalWindowSwitcherActionInvoker () {}
+
+    virtual void InvokeOnTimeout (int timeout) = 0;
+    virtual void StopPendingInvocation () = 0;
+};
+
+class GesturalWindowSwitcherActionInvokerFactory
+{
+  public:
+
+    virtual ~GesturalWindowSwitcherActionInvokerFactory () {}
+
+    virtual GesturalWindowSwitcherActionInvoker::Ptr
+    CreateActionInvoker (const std::function <bool ()> &) const = 0;
+};
+
+class GesturalWindowSwitcherImpl : public GesturalWindowSwitcherInterface
+{
+  public:
+    typedef std::function <void ()> SetUpAndShowSwitcherFunc;
+
+    GesturalWindowSwitcherImpl(const unity::switcher::Controller::Ptr           &switcher_controller,
+                               const SetUpAndShowSwitcherFunc                   &set_up_and_show_switcher,
+                               const GesturalWindowSwitcherActionInvokerFactory &action_invoker_factory);
+    virtual ~GesturalWindowSwitcherImpl();
 
     // in milliseconds
     static const int SWITCHER_TIME_AFTER_DOUBLE_TAP = 350;
@@ -78,7 +112,7 @@
   private:
     GesturalWindowSwitcherPrivate* p;
 };
-typedef std::shared_ptr<GesturalWindowSwitcher> ShPtGesturalWindowSwitcher;
+typedef std::shared_ptr<GesturalWindowSwitcherInterface> ShPtGesturalWindowSwitcher;
 
 } // namespace unity
 

=== renamed file 'plugins/unityshell/src/UnityGestureBroker.cpp' => 'gestures/UnityGestureBroker.cpp'
--- plugins/unityshell/src/UnityGestureBroker.cpp	2012-08-14 12:51:45 +0000
+++ gestures/UnityGestureBroker.cpp	2012-12-19 14:00:32 +0000
@@ -19,30 +19,32 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor,
  * Boston, MA  02110-1301  USA
  */
-
+#include <cstdio>
+#include <memory>
 #include "UnityGestureBroker.h"
 #include "UnityGestureTarget.h"
 #include "WindowGestureTarget.h"
 
-#include <X11/cursorfont.h>
+namespace ug = unity::gestures;
 
-UnityGestureBroker::UnityGestureBroker()
-  : nux::GestureBroker()
+UnityGestureBroker::UnityGestureBroker(const std::shared_ptr <unity::gestures::MousePointer>  &ptr,
+                                       const GetWindowGeneratorFunc                           &client_list,
+                                       const GetWindowGeneratorFunc                           &all_windows,
+                                       const unity::ShPtGesturalWindowSwitcher                &gestural_switcher,
+                                       const nux::ShPtGestureTarget                           &unity_target,
+                                       const ug::WindowGestureTargetFactory::Ptr              &gesture_target_factory)
+  : nux::GestureBroker(),
+    gestural_window_switcher_ (gestural_switcher),
+    mouse_pointer_ (ptr),
+    current_client_list_(client_list),
+    current_all_windows_(all_windows),
+    unity_target_ (unity_target),
+    gesture_target_factory_ (gesture_target_factory)
 {
-  g_assert(WindowGestureTarget::fleur_cursor == 0);
-  WindowGestureTarget::fleur_cursor = XCreateFontCursor (screen->dpy (), XC_fleur);
-
-  unity_target.reset(new UnityGestureTarget);
-  gestural_window_switcher_.reset(new unity::GesturalWindowSwitcher);
 }
 
 UnityGestureBroker::~UnityGestureBroker()
 {
-  if (WindowGestureTarget::fleur_cursor)
-  {
-    XFreeCursor (screen->dpy (), WindowGestureTarget::fleur_cursor);
-    WindowGestureTarget::fleur_cursor = 0;
-  }
 }
 
 std::vector<nux::ShPtGestureTarget>
@@ -54,33 +56,35 @@
 
   if (touches.size() == 4)
   {
-    targets.push_back(unity_target);
+    targets.push_back(unity_target_);
   }
   else if (touches.size() == 3)
   {
     targets.push_back(gestural_window_switcher_);
 
-    CompWindow *window = FindWindowHitByGesture(event);
+    ug::GestureManipulatedWindow *window = FindWindowHitByGesture(event);
     if (window)
     {
-      targets.push_back(nux::ShPtGestureTarget(new WindowGestureTarget(window)));
+      ug::MousePointer::Weak mouse_pointer_weak (mouse_pointer_);
+      targets.push_back(gesture_target_factory_->CreateGestureTarget (*window,
+                                                                      mouse_pointer_weak));
     }
   }
 
   return targets;
 }
 
-CompWindow *UnityGestureBroker::FindWindowHitByGesture(const nux::GestureEvent &event)
+ug::GestureManipulatedWindow * UnityGestureBroker::FindWindowHitByGesture(const nux::GestureEvent &event)
 {
   if (event.IsDirectTouch())
   {
     /* If a direct device is being used (e.g., a touchscreen), all touch
        points must hit the same window */
-    CompWindow *last_window = nullptr;
+    ug::GestureManipulatedWindow *last_window = nullptr;
     const std::vector<nux::TouchPoint> &touches = event.GetTouches();
     for (auto touch : touches)
     {
-      CompWindow *window = FindCompWindowAtPos(touch.x, touch.y);
+      ug::GestureManipulatedWindow *window = FindCompWindowAtPos(touch.x, touch.y);
       if (last_window)
       {
         if (window != last_window)
@@ -107,27 +111,22 @@
   }
 }
 
-CompWindow* UnityGestureBroker::FindCompWindowAtPos(int pos_x, int pos_y)
+ug::GestureManipulatedWindow * UnityGestureBroker::FindCompWindowAtPos(int pos_x, int pos_y)
 {
-  const CompWindowVector& client_list_stacking = screen->clientList(true);
-
-  for (auto iter = client_list_stacking.rbegin(),
-       end = client_list_stacking.rend();
-       iter != end; ++iter)
-  {
-    CompWindow* window = *iter;
-
-    if (window->minimized())
-      continue;
-
-    if (window->state() & CompWindowStateHiddenMask)
-      continue;
-
-    if (pos_x >= window->x() && pos_x <= (window->width() + window->x())
-        &&
-        pos_y >= window->y() && pos_y <= (window->height() + window->y()))
-      return window;
-  }
-
-  return nullptr;
+  ug::GestureManipulatedWindow *manipulated_window = nullptr;
+  current_client_list_ ()->VisitEachInterfaceReverse ([&](ug::GestureManipulatedWindow &item)
+                                                      {
+                                                        if (manipulated_window)
+                                                          return;
+
+                                                        if (!item.Visible())
+                                                          return;
+
+                                                        const compiz::window::Geometry &geom(item.Geometry());
+
+                                                        if (geom.contains(CompPoint(pos_x, pos_y)))
+                                                          manipulated_window = &item;
+                                                      });
+
+  return manipulated_window;
 }

=== renamed file 'plugins/unityshell/src/UnityGestureBroker.h' => 'gestures/UnityGestureBroker.h'
--- plugins/unityshell/src/UnityGestureBroker.h	2012-08-14 12:48:21 +0000
+++ gestures/UnityGestureBroker.h	2012-12-19 14:00:32 +0000
@@ -23,30 +23,59 @@
 #ifndef UNITY_GESTURE_BROKER
 #define UNITY_GESTURE_BROKER
 
-#include <core/core.h>
+#include <memory>
+#include <functional>
 
 #include <Nux/GestureBroker.h>
+#include <AbstractInterfaceGenerator.h>
 #include "GesturalWindowSwitcher.h"
+#include "WindowGestureTarget.h"
+
+class GesturalWindowSwitcher;
+
+namespace unity
+{
+namespace gestures
+{
+class GestureManipulatedWindow;
+class MousePointer;
+}
+}
 
 class UnityGestureBroker : public nux::GestureBroker
 {
 public:
-  UnityGestureBroker();
+
+  typedef unity::gestures::GestureManipulatedWindow GestureWindow;
+  typedef unity::AbstractInterfaceGenerator <GestureWindow> WindowGen;
+  typedef std::shared_ptr <WindowGen> WindowGenPtr;
+  typedef std::function <WindowGenPtr ()>  GetWindowGeneratorFunc;
+
+  UnityGestureBroker(const std::shared_ptr <unity::gestures::MousePointer>        &ptr,
+                     const GetWindowGeneratorFunc                                 &client_list,
+                     const GetWindowGeneratorFunc                                 &all_windows,
+                     const unity::ShPtGesturalWindowSwitcher                      &gestural_switcher,
+                     const nux::ShPtGestureTarget                                 &unity_target,
+                     const unity::gestures::WindowGestureTargetFactory::Ptr       &gesture_target_factory);
   virtual ~UnityGestureBroker();
 
 private:
   std::vector<nux::ShPtGestureTarget>
     virtual FindGestureTargets(const nux::GestureEvent &event);
 
-  CompWindow *FindWindowHitByGesture(const nux::GestureEvent &event);
+  unity::gestures::GestureManipulatedWindow * FindWindowHitByGesture(const nux::GestureEvent &event);
 
   /*!
     Returns the top-most CompWindow at the given position, if any.
    */
-  CompWindow* FindCompWindowAtPos(int pos_x, int pos_y);
+  unity::gestures::GestureManipulatedWindow * FindCompWindowAtPos(int pos_x, int pos_y);
 
-  nux::ShPtGestureTarget unity_target;
-  unity::ShPtGesturalWindowSwitcher gestural_window_switcher_;
+  unity::ShPtGesturalWindowSwitcher                      gestural_window_switcher_;
+  std::shared_ptr <unity::gestures::MousePointer>        mouse_pointer_;
+  GetWindowGeneratorFunc                                 current_client_list_;
+  GetWindowGeneratorFunc                                 current_all_windows_;
+  nux::ShPtGestureTarget                                 unity_target_;
+  unity::gestures::WindowGestureTargetFactory::Ptr       gesture_target_factory_;
 };
 
 #endif // UNITY_GESTURE_BROKER

=== renamed file 'plugins/unityshell/src/UnityGestureTarget.h' => 'gestures/UnityGestureTarget.h'
=== renamed file 'plugins/unityshell/src/WindowGestureTarget.cpp' => 'gestures/WindowGestureTarget.cpp'
--- plugins/unityshell/src/WindowGestureTarget.cpp	2012-10-11 01:44:15 +0000
+++ gestures/WindowGestureTarget.cpp	2012-12-19 14:00:32 +0000
@@ -23,52 +23,64 @@
 #include "WindowGestureTarget.h"
 
 #include <Nux/Nux.h> // otherwise unityshell.h inclusion will cause failures
-#include "unityshell.h"
 
 // To make the gesture tests pass, this has to be a local include.
 #include "PluginAdapter.h"
 
 using namespace nux;
-
-Cursor WindowGestureTarget::fleur_cursor = 0;
-
-WindowGestureTarget::WindowGestureTarget(CompWindow *window)
-  : window_(window), drag_grab_(0), started_window_move_(false),
-    window_restored_by_pinch_(false)
-{
-  // A workaround for the lack of weak pointers.
-  unity::UnityWindow *unity_window = unity::UnityWindow::get(window);
-
+namespace ug = unity::gestures;
+namespace ugi = unity::gestures::impl;
+
+ug::GestureManipulatedWindow::~GestureManipulatedWindow ()
+{
+  on_destruction_.emit ();
+}
+
+nux::ShPtGestureTarget
+ugi::WindowGestureTargetFactory::CreateGestureTarget (GestureManipulatedWindow &win,
+                                                      const MousePointer::Weak &mp) const
+{
+  return std::make_shared <WindowGestureTarget> (win, mp);
+}
+
+WindowGestureTarget::WindowGestureTarget(ug::GestureManipulatedWindow &manipulated_window,
+                                         const ug::MousePointer::Weak &mouse_pointer_observer)
+  : manipulated_window_ (manipulated_window),
+    mouse_pointer_ (mouse_pointer_observer),
+    started_window_move_(false),
+    window_restored_by_pinch_(false),
+    stored_manipulated_window_id_(manipulated_window.GetIdentifier()),
+    manipulated_window_dead_(false)
+{
   connection_window_destruction =
-    unity_window->being_destroyed.connect(
-        sigc::mem_fun(this, &WindowGestureTarget::NullifyWindowPointer));
+      manipulated_window.on_destruction_.connect(sigc::mem_fun(this,
+                                                               &WindowGestureTarget::OnManipulatedWindowDestruction));
 }
 
 WindowGestureTarget::~WindowGestureTarget()
 {
+  /* Since we only have manipulated_window_ by
+   * reference, it is unsafe to call virtual methods
+   * on it if it might have been destroyed, so don't
+   * do that here */
+  if (!manipulated_window_dead_)
+    manipulated_window_.Ungrab();
+  mouse_pointer_.lock ()->MakeUngrabbedForMovement();
   connection_window_destruction.disconnect();
-  if (drag_grab_)
-  {
-    if (window_)
-      window_->ungrabNotify();
-    screen->removeGrab(drag_grab_, NULL);
-  }
 }
 
-void WindowGestureTarget::NullifyWindowPointer()
+void WindowGestureTarget::OnManipulatedWindowDestruction()
 {
-  window_ = nullptr;
+  manipulated_window_dead_ = true;
+  died.emit(*this);
 }
 
 GestureDeliveryRequest WindowGestureTarget::GestureEvent(const nux::GestureEvent &event)
 {
-  if (!window_)
-    return GestureDeliveryRequest::NONE;
-
   switch (event.type)
   {
     case nux::EVENT_GESTURE_BEGIN:
-      PluginAdapter::Default().ShowGrabHandles(window_, false);
+      manipulated_window_.ShowGrabHandles (ug::GestureManipulatedWindow::HideMode::HideOnRequest);
       break;
     case EVENT_GESTURE_UPDATE:
       if (event.GetGestureClasses() & PINCH_GESTURE)
@@ -92,7 +104,7 @@
         EndWindowMove(event);
         started_window_move_ = false;
       }
-      PluginAdapter::Default().ShowGrabHandles(window_, true);
+      manipulated_window_.ShowGrabHandles (ug::GestureManipulatedWindow::HideMode::HideOnTimeout);
       break;
   };
 
@@ -101,11 +113,12 @@
 
 bool WindowGestureTarget::WindowCanMove()
 {
-  if (!(window_->actions() & CompWindowActionMoveMask))
+  if (!(manipulated_window_.IsMovable()))
     return false;
 
   /* Don't allow windows to be dragged if completely maximized */
-  if ((window_->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE)
+  if (manipulated_window_.IsHorizontallyMaximized() &&
+      manipulated_window_.IsVerticallyMaximized())
     return false;
 
   /* Don't start moving a window that has just been restored. The user is likely
@@ -120,15 +133,14 @@
 {
   if (event.GetRadius() > 1.25f)
   {
-    window_->maximize(MAXIMIZE_STATE);
+    manipulated_window_.MaximizeVerticallyAndHorizontally();
     RemoveDragGrab();
     window_restored_by_pinch_ = false;
   }
   else if (event.GetRadius() < 0.8f)
   {
-    if (window_->state() & MAXIMIZE_STATE)
+    if (manipulated_window_.Demaximize())
     {
-      window_->maximize(0);
       RemoveDragGrab();
       window_restored_by_pinch_ = true;
     }
@@ -139,75 +151,61 @@
 {
   if (!event.IsDirectTouch())
   {
-    drag_grab_ = screen->pushGrab(fleur_cursor, "unity");
-    window_->grabNotify(window_->serverGeometry().x(),
-                        window_->serverGeometry().y(),
-                        0,
-                        CompWindowGrabMoveMask | CompWindowGrabButtonMask);
+    mouse_pointer_.lock ()->MakeGrabbedForMovement ();
+    manipulated_window_.Grab ();
   }
 }
 
 void WindowGestureTarget::MoveWindow(const nux::GestureEvent &event)
 {
   const nux::Point2D<float> &delta = event.GetDelta();
-
-  unsigned int px = std::max(std::min(pointerX + static_cast<int>(delta.x),
-                                      screen->width()),
-                             0);
-
-  unsigned int py = std::max(std::min(pointerY + static_cast<int>(delta.y),
-                                      screen->height()),
-                             0);
-
-  if (window_->state() & CompWindowStateMaximizedVertMask)
-    py = pointerY;
-  if (window_->state() & CompWindowStateMaximizedHorzMask)
-    px = pointerX;
+  int px = static_cast<int> (delta.x);
+  int py = static_cast<int> (delta.y);
+
+  mouse_pointer_.lock ()->RestrainDeltaToScreenSize (px, py);
+
+  if (manipulated_window_.IsVerticallyMaximized())
+    py = 0;
+  if (manipulated_window_.IsHorizontallyMaximized())
+    px = 0;
+
+  nux::Point2D<int> p (px, py);
 
   if (!event.IsDirectTouch())
   {
     /* FIXME: CompScreen::warpPointer filters out motion events which
        other plugins may need to process, but for most cases in core
        they should be filtered out. */
-    XWarpPointer(screen->dpy (),
-        None, screen->root (),
-        0, 0, 0, 0,
-        px, py);
+    mouse_pointer_.lock ()->WarpPositionByDelta (p);
   }
-
-  XSync(screen->dpy (), false);
-  window_->move(px - pointerX, py - pointerY, false);
-
-  pointerX = px;
-  pointerY = py;
+  manipulated_window_.MoveByDelta (p);
 }
 
 void WindowGestureTarget::EndWindowMove(const nux::GestureEvent &event)
 {
-  window_->ungrabNotify();
+  manipulated_window_.Ungrab ();
   RemoveDragGrab();
-  window_->syncPosition();
 }
 
 void WindowGestureTarget::RemoveDragGrab()
 {
-  if (drag_grab_)
-  {
-    screen->removeGrab(drag_grab_, NULL);
-    drag_grab_ = 0;
-  }
+  mouse_pointer_.lock ()->MakeUngrabbedForMovement ();
 }
 
 bool WindowGestureTarget::Equals(const nux::GestureTarget& other) const
 {
   const WindowGestureTarget *window_target = dynamic_cast<const WindowGestureTarget *>(&other);
 
+  /* Do not use GetIdentifier () here
+   * Equals () is indirectly called here from ~GestureManipulatedWindow (), by
+   * that time, the vptr will have gone away and calling any methods on
+   * a reference to GestureManipulatedWindow will result in a pure virtual
+   * method call
+   */
   if (window_target)
   {
-    if (window_ && window_target->window_)
-      return window_->id() == window_target->window_->id();
-    else
-      return window_ == window_target->window_;
+    return stored_manipulated_window_id_ ==
+        window_target->stored_manipulated_window_id_;
   }
   else
   {

=== renamed file 'plugins/unityshell/src/WindowGestureTarget.h' => 'gestures/WindowGestureTarget.h'
--- plugins/unityshell/src/WindowGestureTarget.h	2012-07-27 20:20:29 +0000
+++ gestures/WindowGestureTarget.h	2012-12-19 14:00:32 +0000
@@ -23,21 +23,91 @@
 #ifndef WINDOW_GESTURE_TARGET_H
 #define WINDOW_GESTURE_TARGET_H
 
+#include <memory>
+#include <sigc++/signal.h>
 #include <Nux/Gesture.h>
 
-#include <core/core.h> // compiz stuff
+#include <core/windowgeometry.h>
+
+class WindowGestureTarget;
+
+namespace unity
+{
+namespace gestures
+{
+
+class GestureManipulatedWindow
+{
+  public:
+
+    typedef std::shared_ptr <GestureManipulatedWindow> Ptr;
+
+    enum class HideMode
+    {
+      HideOnRequest,
+      HideOnTimeout
+    };
+
+    virtual ~GestureManipulatedWindow ();
+
+    virtual void MaximizeVerticallyAndHorizontally () = 0;
+    virtual bool Demaximize () = 0;
+    virtual void Grab () = 0;
+    virtual void Ungrab () = 0;
+    virtual void MoveByDelta (const nux::Point &p) = 0;
+    virtual bool IsVerticallyMaximized () const = 0;
+    virtual bool IsHorizontallyMaximized () const = 0;
+    virtual bool IsMovable () const = 0;
+    virtual bool Visible ()  const = 0;
+    virtual const compiz::window::Geometry & Geometry () const = 0;
+    virtual void ShowGrabHandles (HideMode) = 0;
+
+    /* This kind of information should not be exposed to users
+     * of this interface, but nux::GestureTarget::Equals is designed
+     * with dynamic casts in mind */
+    virtual unsigned long GetIdentifier () const = 0;
+
+    sigc::signal <void> on_destruction_;
+};
+
+class MousePointer
+{
+  public:
+
+    typedef std::shared_ptr <MousePointer> Ptr;
+    typedef std::weak_ptr <MousePointer> Weak;
+
+    virtual ~MousePointer () {}
+
+    virtual void MakeGrabbedForMovement () = 0;
+    virtual void MakeUngrabbedForMovement () = 0;
+    virtual void WarpPositionByDelta (const nux::Point &p) = 0;
+    virtual void RestrainDeltaToScreenSize (int &x, int &y) const = 0;
+};
+
+class WindowGestureTargetFactory
+{
+  public:
+
+    typedef std::shared_ptr <WindowGestureTargetFactory> Ptr;
+
+    virtual ~WindowGestureTargetFactory () {}
+
+    virtual nux::ShPtGestureTarget
+    CreateGestureTarget (GestureManipulatedWindow &,
+                         const MousePointer::Weak &) const = 0;
+};
+}
+}
 
 class WindowGestureTarget : public nux::GestureTarget
 {
   public:
-    WindowGestureTarget(CompWindow *window);
+    WindowGestureTarget(unity::gestures::GestureManipulatedWindow &manipulated_window,
+                        const unity::gestures::MousePointer::Weak &mouse_pointer_observer);
     virtual ~WindowGestureTarget();
-
     virtual nux::GestureDeliveryRequest GestureEvent(const nux::GestureEvent &event);
 
-    static Cursor fleur_cursor;
-
-    CompWindow *window() {return window_;}
   private:
     virtual bool Equals(const nux::GestureTarget& other) const;
     void StartWindowMove(const nux::GestureEvent &event);
@@ -45,13 +115,36 @@
     void EndWindowMove(const nux::GestureEvent &event);
     void MaximizeOrRestoreWindowDueToPinch(const nux::GestureEvent &event);
     bool WindowCanMove();
-    void NullifyWindowPointer();
+    void OnManipulatedWindowDestruction();
     void RemoveDragGrab();
-    CompWindow *window_;
-    CompScreen::GrabHandle drag_grab_;
+
+    unity::gestures::GestureManipulatedWindow &manipulated_window_;
+    unity::gestures::MousePointer::Weak       mouse_pointer_;
+
     bool started_window_move_;
     bool window_restored_by_pinch_;
     sigc::connection connection_window_destruction;
-};
+    unsigned long stored_manipulated_window_id_;
+    bool manipulated_window_dead_;
+};
+
+namespace unity
+{
+namespace gestures
+{
+namespace impl
+{
+class WindowGestureTargetFactory :
+  public unity::gestures::WindowGestureTargetFactory
+{
+  public:
+
+    nux::ShPtGestureTarget
+    CreateGestureTarget (GestureManipulatedWindow &,
+                         const MousePointer::Weak &) const;
+};
+}
+}
+}
 
 #endif // WINDOW_GESTURE_TARGET_H

=== modified file 'launcher/StandaloneSwitcher.cpp'
--- launcher/StandaloneSwitcher.cpp	2012-11-12 17:27:48 +0000
+++ launcher/StandaloneSwitcher.cpp	2012-12-19 14:00:32 +0000
@@ -43,7 +43,18 @@
 
 static bool enable_flipping = false;
 
-static Controller *view;
+class StandaloneController : public ShellController
+{
+  public:
+
+    StandaloneController() :
+      ShellController()
+    {
+      timeout_length = 0;
+    }
+};
+
+static Controller::Ptr controller;
 
 static gboolean on_timeout(gpointer data)
 {
@@ -63,73 +74,74 @@
 
 void OnBorderSizeChanged (nux::RangeValueInteger *self)
 {
-  view->GetView ()->border_size = self->GetValue ();
-  view->GetView ()->QueueDraw ();
+  controller->GetView ()->SetBorderSize(self->GetValue ());
+  controller->GetView ()->QueueDraw ();
 }
 
 void OnFlatSpacingSizeChanged (nux::RangeValueInteger *self)
 {
-  view->GetView ()->flat_spacing = self->GetValue ();
-  view->GetView ()->QueueDraw ();
+  controller->GetView ()->SetFlatSpacing(self->GetValue ());
+  controller->GetView ()->QueueDraw ();
 }
 
 void OnTextSizeChanged (nux::RangeValueInteger *self)
 {
-  view->GetView ()->text_size = self->GetValue ();
-  view->GetView ()->QueueDraw ();
+  controller->GetView ()->SetTextSize(self->GetValue ());
+  controller->GetView ()->QueueDraw ();
 }
 
 void OnIconSizeChanged (nux::RangeValueInteger *self)
 {
-  view->GetView ()->icon_size = self->GetValue ();
-  view->GetView ()->QueueDraw ();
+  controller->GetView ()->SetIconSize(self->GetValue ());
+  controller->GetView ()->QueueDraw ();
 }
 
 void OnTileSizeChanged (nux::RangeValueInteger *self)
 {
-  view->GetView ()->tile_size = self->GetValue ();
-  view->GetView ()->QueueDraw ();
+  controller->GetView ()->SetTileSize(self->GetValue ());
+  controller->GetView ()->QueueDraw ();
 }
 
 void OnAnimationLengthChanged (nux::RangeValueInteger *self)
 {
-  view->GetView ()->animation_length = self->GetValue ();
-  view->GetView ()->QueueDraw ();
+  controller->GetView ()->SetAnimationLength(self->GetValue ());
+  controller->GetView ()->QueueDraw ();
 }
 
 void OnNumIconsChanged (nux::SpinBox *self)
 {
-  view->Hide();
+  controller->Hide();
 
   std::vector<nux::ObjectPtr<AbstractLauncherIcon>> icons;
   for (int i = 0; i < self->GetValue (); i++)
     icons.push_back(nux::ObjectPtr<AbstractLauncherIcon>(new MockLauncherIcon()));
 
-  view->Show(ShowMode::ALL, SortMode::FOCUS_ORDER, icons);
+  controller->Show(ShowMode::ALL, SortMode::FOCUS_ORDER, icons);
 }
 
 void OnNextClicked (nux::View *sender)
 {
-  view->Next ();
+  controller->Next ();
 }
 
 void OnDetailClicked (nux::View *sender)
 {
-  view->NextDetail ();
+  controller->NextDetail ();
 }
 
 void OnPreviousClicked (nux::View *sender)
 {
-  view->Prev();
+  controller->Prev();
 }
 
 void ThreadWidgetInit(nux::NThread* thread, void* InitData)
 {
   nux::VLayout* layout = new nux::VLayout(TEXT(""), NUX_TRACKER_LOCATION);
 
-  view = new Controller();
-  view->timeout_length = 0;
-  view->SetWorkspace(nux::Geometry(0, 0, 900, 600), 0);
+  controller = std::make_shared<Controller>([]{
+    return Controller::ImplPtr(new StandaloneController());
+  });
+  controller->SetWorkspace(nux::Geometry(0, 0, 900, 600), 0);
 
   layout->SetContentDistribution(nux::MAJOR_POSITION_CENTER);
   layout->SetHorizontalExternalMargin (10);
@@ -139,9 +151,9 @@
   for (int i = 0; i < 9; i++)
     icons.push_back(nux::ObjectPtr<AbstractLauncherIcon>(new MockLauncherIcon()));
 
-  view->Show(ShowMode::ALL, SortMode::FOCUS_ORDER, icons);
+  controller->Show(ShowMode::ALL, SortMode::FOCUS_ORDER, icons);
 
-  view->GetView ()->render_boxes = true;
+  controller->GetView ()->SetRenderBoxes(true);
 
   nux::CheckBox* flipping_check = new nux::CheckBox(TEXT("Enable Automatic Flipping"), false, NUX_TRACKER_LOCATION);
   flipping_check->SetMaximumWidth(250);
@@ -173,7 +185,7 @@
   nux::StaticText* border_label = new nux::StaticText(TEXT("Border Size:"), NUX_TRACKER_LOCATION);
   border_layout->AddView(border_label, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
 
-  nux::RangeValueInteger * border_size_range = new nux::RangeValueInteger (view->GetView ()->border_size, 0, 200, NUX_TRACKER_LOCATION);
+  nux::RangeValueInteger * border_size_range = new nux::RangeValueInteger (controller->GetView ()->GetBorderSize(), 0, 200, NUX_TRACKER_LOCATION);
   border_size_range->sigValueChanged.connect (sigc::ptr_fun (OnBorderSizeChanged));
   border_layout->AddView(border_size_range, 1, nux::MINOR_POSITION_END, nux::MINOR_SIZE_FIX);
 
@@ -189,7 +201,7 @@
   nux::StaticText* flat_spacing_label = new nux::StaticText(TEXT("Flat Spacing:"), NUX_TRACKER_LOCATION);
   flat_spacing_layout->AddView(flat_spacing_label, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
 
-  nux::RangeValueInteger * flat_spacing_size_range = new nux::RangeValueInteger (view->GetView ()->flat_spacing, 0, 200, NUX_TRACKER_LOCATION);
+  nux::RangeValueInteger * flat_spacing_size_range = new nux::RangeValueInteger (controller->GetView ()->GetFlatSpacing(), 0, 200, NUX_TRACKER_LOCATION);
   flat_spacing_size_range->sigValueChanged.connect (sigc::ptr_fun (OnFlatSpacingSizeChanged));
   flat_spacing_layout->AddView(flat_spacing_size_range, 1, nux::MINOR_POSITION_END, nux::MINOR_SIZE_FIX);
 
@@ -204,7 +216,7 @@
   nux::StaticText* text_size_label = new nux::StaticText(TEXT("Text Size:"), NUX_TRACKER_LOCATION);
   text_size_layout->AddView(text_size_label, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
 
-  nux::RangeValueInteger * text_size_size_range = new nux::RangeValueInteger (view->GetView ()->text_size, 0, 200, NUX_TRACKER_LOCATION);
+  nux::RangeValueInteger * text_size_size_range = new nux::RangeValueInteger (controller->GetView ()->GetTextSize(), 0, 200, NUX_TRACKER_LOCATION);
   text_size_size_range->sigValueChanged.connect (sigc::ptr_fun (OnTextSizeChanged));
   text_size_layout->AddView(text_size_size_range, 1, nux::MINOR_POSITION_END, nux::MINOR_SIZE_FIX);
 
@@ -219,7 +231,7 @@
   nux::StaticText* icon_size_label = new nux::StaticText(TEXT("Icon Size:"), NUX_TRACKER_LOCATION);
   icon_size_layout->AddView(icon_size_label, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
 
-  nux::RangeValueInteger * icon_size_size_range = new nux::RangeValueInteger (view->GetView ()->icon_size, 0, 200, NUX_TRACKER_LOCATION);
+  nux::RangeValueInteger * icon_size_size_range = new nux::RangeValueInteger (controller->GetView ()->GetIconSize(), 0, 200, NUX_TRACKER_LOCATION);
   icon_size_size_range->sigValueChanged.connect (sigc::ptr_fun (OnIconSizeChanged));
   icon_size_layout->AddView(icon_size_size_range, 1, nux::MINOR_POSITION_END, nux::MINOR_SIZE_FIX);
 
@@ -234,7 +246,7 @@
   nux::StaticText* tile_size_label = new nux::StaticText(TEXT("Tile Size:"), NUX_TRACKER_LOCATION);
   tile_size_layout->AddView(tile_size_label, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
 
-  nux::RangeValueInteger * tile_size_size_range = new nux::RangeValueInteger (view->GetView ()->tile_size, 0, 200, NUX_TRACKER_LOCATION);
+  nux::RangeValueInteger * tile_size_size_range = new nux::RangeValueInteger (controller->GetView ()->GetTileSize(), 0, 200, NUX_TRACKER_LOCATION);
   tile_size_size_range->sigValueChanged.connect (sigc::ptr_fun (OnTileSizeChanged));
   tile_size_layout->AddView(tile_size_size_range, 1, nux::MINOR_POSITION_END, nux::MINOR_SIZE_FIX);
 
@@ -249,7 +261,7 @@
   nux::StaticText* animation_length_label = new nux::StaticText(TEXT("Animation Length:"), NUX_TRACKER_LOCATION);
   animation_length_layout->AddView(animation_length_label, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
 
-  nux::RangeValueInteger * animation_length_size_range = new nux::RangeValueInteger (view->GetView ()->animation_length, 0, 2000, NUX_TRACKER_LOCATION);
+  nux::RangeValueInteger * animation_length_size_range = new nux::RangeValueInteger (controller->GetView ()->GetAnimationLength(), 0, 2000, NUX_TRACKER_LOCATION);
   animation_length_size_range->sigValueChanged.connect (sigc::ptr_fun (OnAnimationLengthChanged));
   animation_length_layout->AddView(animation_length_size_range, 1, nux::MINOR_POSITION_END, nux::MINOR_SIZE_FIX);
 
@@ -282,7 +294,7 @@
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = background->GetDeviceTexture();
 
 
-  g_timeout_add(1500, on_timeout, view);
+  g_timeout_add(1500, on_timeout, controller.get());
 }
 
 int main(int argc, char** argv)

=== modified file 'launcher/SwitcherController.cpp'
--- launcher/SwitcherController.cpp	2012-11-23 04:05:35 +0000
+++ launcher/SwitcherController.cpp	2012-12-19 14:00:32 +0000
@@ -43,9 +43,116 @@
 namespace switcher
 {
 
-Controller::Controller(unsigned int load_timeout)
+/* Delegation to impl */
+Controller::Controller(CreateImplFunc const& create)
+  : impl_(create())
+{
+}
+
+bool Controller::CanShowSwitcher(const std::vector<AbstractLauncherIcon::Ptr>& results) const
+{
+  return impl_->CanShowSwitcher(results);
+}
+
+void Controller::Show(ShowMode show,
+                      SortMode sort,
+                      std::vector<AbstractLauncherIcon::Ptr> results)
+{
+  impl_->Show(show, sort, results);
+}
+
+void Controller::Select(int index)
+{
+  impl_->Select(index);
+}
+
+void Controller::SetWorkspace(nux::Geometry geo, int monitor)
+{
+  impl_->SetWorkspace(geo, monitor);
+}
+
+void Controller::Hide(bool accept_state)
+{
+  impl_->Hide(accept_state);
+}
+
+bool Controller::Visible()
+{
+  return impl_->Visible();
+}
+
+void Controller::Next()
+{
+  impl_->Next();
+}
+
+void Controller::Prev()
+{
+  impl_->Prev();
+}
+
+View* Controller::GetView()
+{
+  return impl_->GetView();
+}
+
+void Controller::SetDetail(bool value, unsigned int min_windows)
+{
+  impl_->SetDetail(value, min_windows);
+}
+
+void Controller::NextDetail()
+{
+  impl_->NextDetail();
+}
+
+void Controller::PrevDetail()
+{
+  impl_->PrevDetail();
+}
+
+LayoutWindow::Vector Controller::ExternalRenderTargets()
+{
+  return impl_->ExternalRenderTargets();
+}
+
+guint Controller::GetSwitcherInputWindowId() const
+{
+  return impl_->GetSwitcherInputWindowId();
+}
+
+bool Controller::IsShowDesktopDisabled() const
+{
+  return impl_->IsShowDesktopDisabled();
+}
+
+void Controller::SetShowDesktopDisabled(bool disabled)
+{
+  impl_->SetShowDesktopDisabled(disabled);
+}
+
+int Controller::StartIndex() const
+{
+  return impl_->StartIndex();
+}
+
+void Controller::SelectFirstItem()
+{
+  impl_->SelectFirstItem();
+}
+
+sigc::connection Controller::ConnectToViewBuilt(const sigc::slot<void> &f)
+{
+  return impl_->view_built.connect(f);
+}
+
+void Controller::SetDetailOnTimeout(bool timeout)
+{
+  impl_->detail_on_timeout = timeout;
+}
+
+ShellController::ShellController(unsigned int load_timeout)
   :  timeout_length(75)
-  ,  detail_on_timeout(true)
   ,  detail_timeout_length(500)
   ,  initial_detail_timeout_length(1500)
   ,  construct_timeout_(load_timeout)
@@ -55,29 +162,30 @@
   ,  show_desktop_disabled_(false)
   ,  bg_color_(0, 0, 0, 0.5)
 {
-  ubus_manager_.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, sigc::mem_fun(this, &Controller::OnBackgroundUpdate));
+  detail_on_timeout = true;
+  ubus_manager_.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, sigc::mem_fun(this, &ShellController::OnBackgroundUpdate));
 
   sources_.AddTimeoutSeconds(construct_timeout_, [&] { ConstructWindow(); return false; }, LAZY_TIMEOUT);
 }
 
-void Controller::OnBackgroundUpdate(GVariant* data)
+void ShellController::OnBackgroundUpdate(GVariant* data)
 {
   gdouble red, green, blue, alpha;
   g_variant_get(data, "(dddd)", &red, &green, &blue, &alpha);
   bg_color_ = nux::Color(red, green, blue, alpha);
 
   if (view_)
-    view_->background_color = bg_color_;
+    view_->SetBackgroundColor(bg_color_);
 }
 
-bool Controller::CanShowSwitcher(const std::vector<AbstractLauncherIcon::Ptr>& results) const
+bool ShellController::CanShowSwitcher(const std::vector<AbstractLauncherIcon::Ptr>& results) const
 {
   bool empty = (show_desktop_disabled_ ? results.empty() : results.size() == 1);
 
   return (!empty && !WindowManager::Default().IsWallActive());
 }
 
-void Controller::Show(ShowMode show, SortMode sort, std::vector<AbstractLauncherIcon::Ptr> results)
+void ShellController::Show(ShowMode show, SortMode sort, std::vector<AbstractLauncherIcon::Ptr> results)
 {
   if (results.empty())
     return;
@@ -89,7 +197,7 @@
 
   model_.reset(new SwitcherModel(results));
   AddChild(model_.get());
-  model_->selection_changed.connect(sigc::mem_fun(this, &Controller::OnModelSelectionChanged));
+  model_->selection_changed.connect(sigc::mem_fun(this, &ShellController::OnModelSelectionChanged));
   model_->only_detail_on_viewport = (show == ShowMode::CURRENT_VIEWPORT);
 
   SelectFirstItem();
@@ -113,7 +221,7 @@
 
   if (detail_on_timeout)
   {
-    auto cb_func = sigc::mem_fun(this, &Controller::OnDetailTimer);
+    auto cb_func = sigc::mem_fun(this, &ShellController::OnDetailTimer);
     sources_.AddTimeout(initial_detail_timeout_length, cb_func, DETAIL_TIMEOUT);
   }
 
@@ -121,13 +229,13 @@
   ubus_manager_.SendMessage(UBUS_SWITCHER_SHOWN, g_variant_new("(bi)", true, monitor_));
 }
 
-void Controller::Select(int index)
+void ShellController::Select(int index)
 {
   if (visible_)
     model_->Select(index);
 }
 
-bool Controller::OnDetailTimer()
+bool ShellController::OnDetailTimer()
 {
   if (visible_ && !model_->detail_selection)
   {
@@ -138,11 +246,11 @@
   return false;
 }
 
-void Controller::OnModelSelectionChanged(AbstractLauncherIcon::Ptr const& icon)
+void ShellController::OnModelSelectionChanged(AbstractLauncherIcon::Ptr const& icon)
 {
   if (detail_on_timeout)
   {
-    auto cb_func = sigc::mem_fun(this, &Controller::OnDetailTimer);
+    auto cb_func = sigc::mem_fun(this, &ShellController::OnDetailTimer);
     sources_.AddTimeout(detail_timeout_length, cb_func, DETAIL_TIMEOUT);
   }
 
@@ -158,7 +266,7 @@
   }
 }
 
-void Controller::ShowView()
+void ShellController::ShowView()
 {
   if (!visible_)
     return;
@@ -177,7 +285,7 @@
   }
 }
 
-void Controller::ConstructWindow()
+void ShellController::ConstructWindow()
 {
   sources_.Remove(LAZY_TIMEOUT);
 
@@ -196,39 +304,44 @@
   }
 }
 
-void Controller::ConstructView()
+void ShellController::ConstructView()
 {
   if (view_ || !model_)
     return;
 
   sources_.Remove(VIEW_CONSTRUCT_IDLE);
 
-  view_ = SwitcherView::Ptr(new SwitcherView());
-  AddChild(view_.GetPointer());
+  view_.reset (new switcher::View ([this]{
+    switcher::NuxView *p(new switcher::NuxView());
+    introspectable_view_ = p;
+    nux_view_ = p;
+    return std::unique_ptr<switcher::View::Impl>(p);
+  }));
+  AddChild(introspectable_view_);
   view_->SetModel(model_);
-  view_->background_color = bg_color_;
-  view_->monitor = monitor_;
+  view_->SetBackgroundColor(bg_color_);
+  view_->SetMonitor(monitor_);
   view_->SetupBackground();
 
   ConstructWindow();
-  main_layout_->AddView(view_.GetPointer(), 1);
-  view_window_->SetEnterFocusInputArea(view_.GetPointer());
+  main_layout_->AddView(nux_view_, 1);
+  view_window_->SetEnterFocusInputArea(nux_view_);
   view_window_->SetGeometry(workarea_);
   view_window_->SetOpacity(0.0f);
 
   view_built.emit();
 }
 
-void Controller::SetWorkspace(nux::Geometry geo, int monitor)
+void ShellController::SetWorkspace(nux::Geometry geo, int monitor)
 {
   monitor_ = monitor;
   workarea_ = geo;
 
   if (view_)
-    view_->monitor = monitor_;
+    view_->SetMonitor(monitor_);
 }
 
-void Controller::Hide(bool accept_state)
+void ShellController::Hide(bool accept_state)
 {
   if (!visible_)
     return;
@@ -267,7 +380,7 @@
   visible_ = false;
 
   if (view_)
-    main_layout_->RemoveChildObject(view_.GetPointer());
+    main_layout_->RemoveChildObject(nux_view_);
 
   if (view_window_)
   {
@@ -281,15 +394,17 @@
 
   last_active_selection_ = nullptr;
 
-  view_.Release();
+  view_.reset();
+  nux_view_ = nullptr;
+  introspectable_view_ = nullptr;
 }
 
-bool Controller::Visible()
+bool ShellController::Visible()
 {
   return visible_;
 }
 
-void Controller::Next()
+void ShellController::Next()
 {
   if (!model_)
     return;
@@ -318,7 +433,7 @@
   }
 }
 
-void Controller::Prev()
+void ShellController::Prev()
 {
   if (!model_)
     return;
@@ -347,12 +462,12 @@
   }
 }
 
-SwitcherView* Controller::GetView()
+View *ShellController::GetView()
 {
-  return view_.GetPointer();
+  return view_.get();
 }
 
-void Controller::SetDetail(bool value, unsigned int min_windows)
+void ShellController::SetDetail(bool value, unsigned int min_windows)
 {
   if (value && model_->DetailXids().size () >= min_windows)
   {
@@ -365,7 +480,7 @@
   }
 }
 
-void Controller::NextDetail()
+void ShellController::NextDetail()
 {
   if (!model_)
     return;
@@ -381,7 +496,7 @@
   }
 }
 
-void Controller::PrevDetail()
+void ShellController::PrevDetail()
 {
   if (!model_)
     return;
@@ -398,7 +513,7 @@
   }
 }
 
-LayoutWindow::Vector Controller::ExternalRenderTargets()
+LayoutWindow::Vector ShellController::ExternalRenderTargets()
 {
   if (!view_)
   {
@@ -408,27 +523,27 @@
   return view_->ExternalTargets();
 }
 
-guint Controller::GetSwitcherInputWindowId() const
+guint ShellController::GetSwitcherInputWindowId() const
 {
   return view_window_->GetInputWindowId();
 }
 
-bool Controller::IsShowDesktopDisabled() const
+bool ShellController::IsShowDesktopDisabled() const
 {
   return show_desktop_disabled_;
 }
 
-void Controller::SetShowDesktopDisabled(bool disabled)
+void ShellController::SetShowDesktopDisabled(bool disabled)
 {
   show_desktop_disabled_ = disabled;
 }
 
-int Controller::StartIndex() const
+int ShellController::StartIndex() const
 {
   return (show_desktop_disabled_ ? 0 : 1);
 }
 
-bool Controller::CompareSwitcherItemsPriority(AbstractLauncherIcon::Ptr const& first,
+bool ShellController::CompareSwitcherItemsPriority(AbstractLauncherIcon::Ptr const& first,
                                               AbstractLauncherIcon::Ptr const& second)
 {
   if (first->GetIconType() == second->GetIconType())
@@ -443,7 +558,7 @@
   return first->GetIconType() < second->GetIconType();
 }
 
-void Controller::SelectFirstItem()
+void ShellController::SelectFirstItem()
 {
   if (!model_)
     return;
@@ -500,13 +615,13 @@
 
 /* Introspection */
 std::string
-Controller::GetName() const
+ShellController::GetName() const
 {
   return "SwitcherController";
 }
 
 void
-Controller::AddProperties(GVariantBuilder* builder)
+ShellController::AddProperties(GVariantBuilder* builder)
 {
   unity::variant::BuilderWrapper(builder)
   .add("timeout_length", timeout_length())

=== modified file 'launcher/SwitcherController.h'
--- launcher/SwitcherController.h	2012-11-16 15:58:49 +0000
+++ launcher/SwitcherController.h	2012-12-19 14:00:32 +0000
@@ -20,6 +20,8 @@
 #ifndef SWITCHERCONTROLLER_H
 #define SWITCHERCONTROLLER_H
 
+#include <memory>
+
 #include <UnityCore/Variant.h>
 #include <UnityCore/GLibSource.h>
 
@@ -54,33 +56,134 @@
   CURRENT_VIEWPORT,
 };
 
-
-class Controller : public debug::Introspectable, public sigc::trackable
+class Controller
+{
+  public:
+
+    class Impl;
+    typedef std::unique_ptr<Impl> ImplPtr;
+    typedef std::function<ImplPtr()> CreateImplFunc;
+    typedef std::shared_ptr<Controller> Ptr;
+
+  public:
+
+    Controller(CreateImplFunc const&);
+
+    void Show(ShowMode show,
+              SortMode sort,
+              std::vector<launcher::AbstractLauncherIcon::Ptr> results);
+    void Hide(bool accept_state=true);
+
+    bool CanShowSwitcher(const std::vector<launcher::AbstractLauncherIcon::Ptr>& resutls) const;
+
+    bool Visible();
+
+    void Next();
+    void Prev();
+
+    void NextDetail();
+    void PrevDetail();
+
+    void Select(int index);
+
+    void SetDetail(bool detail,
+                   unsigned int min_windows = 1);
+
+    void SelectFirstItem();
+
+    void SetWorkspace(nux::Geometry geo,
+                      int monitor);
+
+    View * GetView ();
+
+    ui::LayoutWindow::Vector ExternalRenderTargets ();
+
+    guint GetSwitcherInputWindowId() const;
+
+    bool IsShowDesktopDisabled() const;
+    void SetShowDesktopDisabled(bool disabled);
+    int StartIndex() const;
+
+    sigc::connection ConnectToViewBuilt (sigc::slot<void> const&);
+    void SetDetailOnTimeout(bool timeout);
+
+  private:
+    ImplPtr impl_;
+};
+
+class Controller::Impl
+{
+  public:
+
+    virtual ~Impl () {}
+
+    virtual void Show(ShowMode show,
+                      SortMode sort,
+                      std::vector<launcher::AbstractLauncherIcon::Ptr> results) = 0;
+
+    virtual void Hide(bool accept_state) = 0;
+
+    virtual bool CanShowSwitcher(const std::vector<launcher::AbstractLauncherIcon::Ptr>& resutls) const = 0;
+
+    virtual bool Visible() = 0;
+
+    virtual void Next() = 0;
+    virtual void Prev() = 0;
+
+    virtual void NextDetail() = 0;
+    virtual void PrevDetail() = 0;
+
+    virtual void Select(int index) = 0;
+
+    virtual void SetDetail(bool detail,
+                           unsigned int min_windows) = 0;
+
+    virtual void SelectFirstItem() = 0;
+
+    virtual void SetWorkspace(nux::Geometry geo,
+                              int monitor) = 0;
+
+    virtual View * GetView () = 0;
+
+    virtual ui::LayoutWindow::Vector ExternalRenderTargets () = 0;
+
+    virtual guint GetSwitcherInputWindowId() const = 0;
+
+    virtual bool IsShowDesktopDisabled() const = 0;
+    virtual void SetShowDesktopDisabled(bool disabled) = 0;
+    virtual int StartIndex() const = 0;
+
+    sigc::signal<void> view_built;
+    nux::Property<bool> detail_on_timeout;
+};
+
+class ShellController : public Controller::Impl,
+                        public debug::Introspectable,
+                        public sigc::trackable
 {
 public:
-  typedef std::shared_ptr<Controller> Ptr;
-
-  Controller(unsigned int load_timeout = 20);
+  typedef std::shared_ptr<ShellController> Ptr;
 
   nux::Property<int> timeout_length;
-  nux::Property<bool> detail_on_timeout;
   nux::Property<int>  detail_timeout_length;
   nux::Property<int> initial_detail_timeout_length;
 
-  void Show(ShowMode show, SortMode sort, std::vector<launcher::AbstractLauncherIcon::Ptr> results);
-  void Hide(bool accept_state=true);
+  ShellController(unsigned int load_timeout = 20);
+
+  virtual void Show(ShowMode show, SortMode sort, std::vector<launcher::AbstractLauncherIcon::Ptr> results);
+  virtual void Hide(bool accept_state);
 
   bool CanShowSwitcher(const std::vector<launcher::AbstractLauncherIcon::Ptr>& resutls) const;
 
-  bool Visible();
+  virtual bool Visible();
 
-  void Next();
-  void Prev();
+  virtual void Next();
+  virtual void Prev();
 
   void NextDetail();
   void PrevDetail();
 
-  void Select (int index);
+  virtual void Select (int index);
 
   void SetDetail(bool detail, unsigned int min_windows = 1);
 
@@ -88,7 +191,7 @@
 
   void SetWorkspace(nux::Geometry geo, int monitor);
 
-  SwitcherView * GetView ();
+  virtual View* GetView();
 
   ui::LayoutWindow::Vector ExternalRenderTargets ();
 
@@ -98,8 +201,6 @@
   void SetShowDesktopDisabled(bool disabled);
   int StartIndex() const;
 
-  sigc::signal<void> view_built;
-
 protected:
   // Introspectable methods
   std::string GetName() const;
@@ -126,7 +227,9 @@
   static bool CompareSwitcherItemsPriority(launcher::AbstractLauncherIcon::Ptr const& first, launcher::AbstractLauncherIcon::Ptr const& second);
 
   SwitcherModel::Ptr model_;
-  SwitcherView::Ptr view_;
+  debug::Introspectable *introspectable_view_;
+  NuxView               *nux_view_;
+  View::Ptr             view_;
 
   nux::Geometry workarea_;
   nux::ObjectPtr<nux::BaseWindow> view_window_;

=== modified file 'launcher/SwitcherView.cpp'
--- launcher/SwitcherView.cpp	2012-12-14 12:14:34 +0000
+++ launcher/SwitcherView.cpp	2012-12-19 14:00:32 +0000
@@ -32,9 +32,137 @@
 namespace switcher
 {
 
-NUX_IMPLEMENT_OBJECT_TYPE(SwitcherView);
-
-SwitcherView::SwitcherView()
+View::View(const ViewFactoryFunc &create)
+  : impl_(create())
+{
+}
+
+
+ui::LayoutWindow::Vector View::ExternalTargets()
+{
+  return impl_->ExternalTargets();
+}
+
+void View::SetModel(SwitcherModel::Ptr model)
+{
+  impl_->SetModel(model);
+}
+
+SwitcherModel::Ptr View::GetModel()
+{
+  return impl_->GetModel();
+}
+
+View::MouseEventConnections
+View::ConnectToMouseEvents(const View::MouseButtonCallback &mouse_down_callback,
+                           const View::MouseButtonCallback &mouse_up_callback,
+                           const View::MouseDragCallback   &mouse_drag_callback)
+{
+  return impl_->ConnectToMouseEvents(mouse_down_callback,
+                                     mouse_up_callback,
+                                     mouse_drag_callback);
+}
+
+void View::QueueDraw()
+{
+  impl_->QueueDraw();
+}
+
+nux::Geometry View::GetAbsoluteGeometry() const
+{
+  return impl_->GetAbsoluteGeometry();
+}
+
+// Returns the index of the icon at the given position, in window coordinates.
+// If there's no icon there, -1 is returned.
+int View::IconIndexAt(int x, int y)
+{
+  return impl_->IconIndexAt(x, y);
+}
+
+// Property setters
+void View::SetBackgroundColor(nux::Color const& color)
+{
+  impl_->SetBackgroundColor(color);
+}
+
+void View::SetMonitor(unsigned int monitor)
+{
+  impl_->monitor = monitor;
+}
+
+void View::SetBorderSize(unsigned int size)
+{
+  impl_->border_size = size;
+}
+
+void View::SetFlatSpacing(int spacing)
+{
+  impl_->flat_spacing = spacing;
+}
+
+void View::SetTextSize(unsigned int size)
+{
+  impl_->text_size = size;
+}
+
+void View::SetIconSize(unsigned int size)
+{
+  impl_->icon_size = size;
+}
+
+void View::SetTileSize(unsigned int size)
+{
+  impl_->tile_size = size;
+}
+
+void View::SetAnimationLength(unsigned int length)
+{
+  impl_->animation_length = length;
+}
+
+void View::SetRenderBoxes(bool render)
+{
+  impl_->render_boxes = render;
+}
+
+// Property getters
+unsigned int View::GetBorderSize()
+{
+  return impl_->border_size;
+}
+
+unsigned int View::GetFlatSpacing()
+{
+  return impl_->flat_spacing;
+}
+
+unsigned int View::GetTextSize()
+{
+  return impl_->text_size;
+}
+
+unsigned int View::GetIconSize()
+{
+  return impl_->icon_size;
+}
+
+unsigned int View::GetTileSize()
+{
+  return impl_->tile_size;
+}
+
+unsigned int View::GetAnimationLength()
+{
+  return impl_->animation_length;
+}
+
+void View::SetupBackground(bool enabled)
+{
+  return impl_->SetupBackground(enabled);
+}
+
+View::Impl::Impl()
   : render_boxes(false)
   , border_size(50)
   , flat_spacing(10)
@@ -46,6 +174,14 @@
   , animation_length(250)
   , monitor(-1)
   , spread_size(3.5f)
+{
+}
+
+NUX_IMPLEMENT_OBJECT_TYPE(NuxView);
+
+NuxView::NuxView()
+  : UnityWindowView()
+  , switcher::View::Impl ()
   , icon_renderer_(std::make_shared<IconRenderer>())
   , text_view_(new StaticCairoText(""))
   , animation_draw_(false)
@@ -60,18 +196,28 @@
   text_view_->SetTextColor(nux::color::White);
   text_view_->SetFont("Ubuntu Bold 10");
 
-  icon_size.changed.connect (sigc::mem_fun (this, &SwitcherView::OnIconSizeChanged));
-  tile_size.changed.connect (sigc::mem_fun (this, &SwitcherView::OnTileSizeChanged));
+  icon_size.changed.connect (sigc::mem_fun (this, &NuxView::OnIconSizeChanged));
+  tile_size.changed.connect (sigc::mem_fun (this, &NuxView::OnTileSizeChanged));
 
   CaptureMouseDownAnyWhereElse(true);
 }
 
-std::string SwitcherView::GetName() const
+void NuxView::SetBackgroundColor(nux::Color const& color)
+{
+  background_color = color;
+}
+
+void NuxView::SetupBackground(bool enabled)
+{
+  UnityWindowView::SetupBackground(enabled);
+}
+
+std::string NuxView::GetName() const
 {
   return "SwitcherView";
 }
 
-void SwitcherView::AddProperties(GVariantBuilder* builder)
+void NuxView::AddProperties(GVariantBuilder* builder)
 {
   unity::variant::BuilderWrapper(builder)
   .add("render-boxes", render_boxes)
@@ -88,17 +234,17 @@
   .add("label_visible", text_view_->IsVisible());
 }
 
-LayoutWindow::Vector SwitcherView::ExternalTargets ()
+LayoutWindow::Vector NuxView::ExternalTargets ()
 {
   return render_targets_;
 }
 
-void SwitcherView::SetModel(SwitcherModel::Ptr model)
+void NuxView::SetModel(SwitcherModel::Ptr model)
 {
   model_ = model;
-  model->selection_changed.connect(sigc::mem_fun(this, &SwitcherView::OnSelectionChanged));
-  model->detail_selection.changed.connect (sigc::mem_fun (this, &SwitcherView::OnDetailSelectionChanged));
-  model->detail_selection_index.changed.connect (sigc::mem_fun (this, &SwitcherView::OnDetailSelectionIndexChanged));
+  model->selection_changed.connect(sigc::mem_fun(this, &NuxView::OnSelectionChanged));
+  model->detail_selection.changed.connect (sigc::mem_fun (this, &NuxView::OnDetailSelectionChanged));
+  model->detail_selection_index.changed.connect (sigc::mem_fun (this, &NuxView::OnDetailSelectionIndexChanged));
 
   if (!model->Selection())
     return;
@@ -109,30 +255,30 @@
     text_view_->SetText(model->Selection()->tooltip_text());
 }
 
-void SwitcherView::OnIconSizeChanged (int size)
+void NuxView::OnIconSizeChanged (int size)
 {
   icon_renderer_->SetTargetSize(tile_size, icon_size, 10);
 }
 
-void SwitcherView::OnTileSizeChanged (int size)
+void NuxView::OnTileSizeChanged (int size)
 {
   icon_renderer_->SetTargetSize(tile_size, icon_size, 10);
   vertical_size = tile_size + 80;
 }
 
-void SwitcherView::SaveLast ()
+void NuxView::SaveLast ()
 {
   saved_args_ = last_args_;
   saved_background_ = last_background_;
   clock_gettime(CLOCK_MONOTONIC, &save_time_);
 }
 
-void SwitcherView::OnDetailSelectionIndexChanged(unsigned int index)
+void NuxView::OnDetailSelectionIndexChanged(unsigned int index)
 {
   QueueDraw ();
 }
 
-void SwitcherView::OnDetailSelectionChanged(bool detail)
+void NuxView::OnDetailSelectionChanged (bool detail)
 {
   text_view_->SetVisible(!detail);
 
@@ -143,7 +289,7 @@
   QueueDraw();
 }
 
-void SwitcherView::OnSelectionChanged(AbstractLauncherIcon::Ptr const& selection)
+void NuxView::OnSelectionChanged(AbstractLauncherIcon::Ptr const& selection)
 {
   if (selection)
     text_view_->SetText(selection->tooltip_text());
@@ -152,12 +298,12 @@
   QueueDraw();
 }
 
-SwitcherModel::Ptr SwitcherView::GetModel()
+SwitcherModel::Ptr NuxView::GetModel()
 {
   return model_;
 }
 
-RenderArg SwitcherView::CreateBaseArgForIcon(AbstractLauncherIcon::Ptr const& icon)
+RenderArg NuxView::CreateBaseArgForIcon(AbstractLauncherIcon::Ptr const& icon)
 {
   RenderArg arg;
   arg.icon = icon.GetPointer();
@@ -185,7 +331,7 @@
   return arg;
 }
 
-RenderArg SwitcherView::InterpolateRenderArgs(RenderArg const& start, RenderArg const& end, float progress)
+RenderArg NuxView::InterpolateRenderArgs(RenderArg const& start, RenderArg const& end, float progress)
 {
   // easing
   progress = -pow(progress - 1.0f, 2) + 1;
@@ -205,7 +351,7 @@
   return result;
 }
 
-nux::Geometry SwitcherView::InterpolateBackground (nux::Geometry const& start, nux::Geometry const& end, float progress)
+nux::Geometry NuxView::InterpolateBackground (nux::Geometry const& start, nux::Geometry const& end, float progress)
 {
   progress = -pow(progress - 1.0f, 2) + 1;
 
@@ -219,7 +365,7 @@
   return result;
 }
 
-nux::Geometry SwitcherView::UpdateRenderTargets(nux::Point const& center, timespec const& current)
+nux::Geometry NuxView::UpdateRenderTargets (nux::Point const& center, timespec const& current)
 {
   std::vector<Window> const& xids = model_->DetailXids();
 
@@ -262,7 +408,7 @@
   return final_bounds;
 }
 
-void SwitcherView::OffsetRenderTargets (int x, int y)
+void NuxView::OffsetRenderTargets (int x, int y)
 {
   for (LayoutWindow::Ptr const& target : render_targets_)
   {
@@ -271,7 +417,7 @@
   }
 }
 
-nux::Size SwitcherView::SpreadSize()
+nux::Size NuxView::SpreadSize()
 {
   nux::Geometry const& base = GetGeometry();
   nux::Size result(base.width - border_size * 2, base.height - border_size * 2);
@@ -282,13 +428,13 @@
   return result;
 }
 
-void SwitcherView::GetFlatIconPositions (int n_flat_icons,
-                                         int size,
-                                         int selection,
-                                         int &first_flat,
-                                         int &last_flat,
-                                         int &half_fold_left,
-                                         int &half_fold_right)
+void NuxView::GetFlatIconPositions(int n_flat_icons,
+                                   int size,
+                                   int selection,
+                                   int &first_flat,
+                                   int &last_flat,
+                                   int &half_fold_left,
+                                   int &half_fold_right)
 {
   half_fold_left = -1;
   half_fold_right = -1;
@@ -356,7 +502,9 @@
   }
 }
 
-std::list<RenderArg> SwitcherView::RenderArgsFlat(nux::Geometry& background_geo, int selection, timespec const& current)
+std::list<RenderArg> NuxView::RenderArgsFlat(nux::Geometry& background_geo,
+                                             int selection,
+                                             timespec const& current)
 {
   std::list<RenderArg> results;
   nux::Geometry const& base = GetGeometry();
@@ -506,7 +654,7 @@
   return results;
 }
 
-void SwitcherView::PreDraw(nux::GraphicsEngine& GfxContext, bool force_draw)
+void NuxView::PreDraw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
   clock_gettime(CLOCK_MONOTONIC, &current_);
 
@@ -523,12 +671,22 @@
   icon_renderer_->PreprocessIcons(last_args_, GetGeometry());
 }
 
-nux::Geometry SwitcherView::GetBackgroundGeometry()
+nux::Geometry NuxView::GetBackgroundGeometry()
 {
   return last_background_;
 }
 
-void SwitcherView::DrawOverlay(nux::GraphicsEngine& GfxContext, bool force_draw, nux::Geometry internal_clip)
+void NuxView::QueueDraw()
+{
+  ui::UnityWindowView::QueueDraw();
+}
+
+nux::Geometry NuxView::GetAbsoluteGeometry() const
+{
+  return ui::UnityWindowView::GetAbsoluteGeometry();
+}
+
+void NuxView::DrawOverlay(nux::GraphicsEngine& GfxContext, bool force_draw, nux::Geometry internal_clip)
 {
   nux::Geometry base = GetGeometry();
 
@@ -600,7 +758,7 @@
   animation_draw_ = false;
 }
 
-int SwitcherView::IconIndexAt(int x, int y)
+int NuxView::IconIndexAt(int x, int y)
 {
   int half_size = icon_size.Get() / 2;
   int icon_index = -1;
@@ -633,5 +791,15 @@
   return icon_index;
 }
 
+NuxView::MouseEventConnections
+NuxView::ConnectToMouseEvents(const MouseButtonCallback &mouse_down_callback,
+                              const MouseButtonCallback &mouse_up_callback,
+                              const MouseDragCallback   &mouse_drag_callback)
+{
+  return NuxView::MouseEventConnections
+      (mouse_down.connect (mouse_down_callback),
+       mouse_up.connect (mouse_up_callback),
+       mouse_drag.connect (mouse_drag_callback));
+}
 }
 }

=== modified file 'launcher/SwitcherView.h'
--- launcher/SwitcherView.h	2012-12-14 12:14:34 +0000
+++ launcher/SwitcherView.h	2012-12-19 14:00:32 +0000
@@ -20,6 +20,8 @@
 #ifndef SWITCHERVIEW_H
 #define SWITCHERVIEW_H
 
+#include <tuple>
+
 #include "SwitcherModel.h"
 #include "unity-shared/AbstractIconRenderer.h"
 #include "unity-shared/StaticCairoText.h"
@@ -41,19 +43,93 @@
 }
 namespace switcher
 {
-
-class SwitcherView : public ui::UnityWindowView
-{
-  NUX_DECLARE_OBJECT_TYPE(SwitcherView, ui::UnityWindowView);
+class View
+{
+  public:
+
+    typedef sigc::slot<void, int, int, int, int> MouseButtonCallback;
+    typedef sigc::slot <void, int, int, int, int, unsigned int, unsigned int> MouseDragCallback;
+
+    typedef std::tuple <sigc::connection,
+                        sigc::connection,
+                        sigc::connection> MouseEventConnections;
+
+    class Impl;
+    typedef std::unique_ptr<Impl> ImplPtr;
+    typedef std::shared_ptr<View> Ptr;
+    typedef std::function<ImplPtr()> ViewFactoryFunc;
+
+    View(ViewFactoryFunc const&);
+
+    ui::LayoutWindow::Vector ExternalTargets();
+
+    void SetModel(SwitcherModel::Ptr model);
+    SwitcherModel::Ptr GetModel();
+
+    MouseEventConnections ConnectToMouseEvents(const MouseButtonCallback &mouse_down_callback,
+                                               const MouseButtonCallback &mouse_up_callback,
+                                               const MouseDragCallback   &mouse_drag_callback);
+    void QueueDraw();
+    nux::Geometry GetAbsoluteGeometry() const;
+
+    // Returns the index of the icon at the given position, in window coordinates.
+    // If there's no icon there, -1 is returned.
+    int IconIndexAt(int x, int y);
+
+    // Property setters
+    void SetBackgroundColor(nux::Color const& color);
+    void SetMonitor(unsigned int monitor);
+    void SetBorderSize(unsigned int);
+    void SetFlatSpacing(int);
+    void SetTextSize(unsigned int);
+    void SetIconSize(unsigned int);
+    void SetTileSize(unsigned int);
+    void SetAnimationLength(unsigned int);
+    void SetRenderBoxes(bool);
+
+    // Property getters
+    unsigned int GetBorderSize();
+    unsigned int GetFlatSpacing();
+    unsigned int GetTextSize();
+    unsigned int GetIconSize();
+    unsigned int GetTileSize();
+    unsigned int GetAnimationLength();
+
+    void SetupBackground(bool enabled = true);
+
+  private:
+    std::unique_ptr<Impl> impl_;
+};
+
+class View::Impl
+{
 public:
-  typedef nux::ObjectPtr<SwitcherView> Ptr;
-
-  SwitcherView();
-
-  ui::LayoutWindow::Vector ExternalTargets();
-
-  void SetModel(SwitcherModel::Ptr model);
-  SwitcherModel::Ptr GetModel();
+
+  typedef switcher::View::MouseButtonCallback MouseButtonCallback;
+  typedef switcher::View::MouseDragCallback MouseDragCallback;
+  typedef switcher::View::MouseEventConnections MouseEventConnections;
+
+  Impl();
+
+  virtual ~Impl() {};
+
+  virtual ui::LayoutWindow::Vector ExternalTargets() = 0;
+
+  virtual void SetModel(SwitcherModel::Ptr model) = 0;
+  virtual SwitcherModel::Ptr GetModel() = 0;
+
+  virtual MouseEventConnections ConnectToMouseEvents(const MouseButtonCallback &mouse_down_callback,
+                                                     const MouseButtonCallback &mouse_up_callback,
+                                                     const MouseDragCallback   &mouse_drag_callback) = 0;
+  virtual void QueueDraw() = 0;
+  virtual nux::Geometry GetAbsoluteGeometry() const = 0;
+
+  // Returns the index of the icon at the given position, in window coordinates.
+  // If there's no icon there, -1 is returned.
+  virtual int IconIndexAt(int x, int y) = 0;
+
+  virtual void SetBackgroundColor(nux::Color const&) = 0;
+  virtual void SetupBackground(bool enabled) = 0;
 
   nux::Property<bool> render_boxes;
   nux::Property<int> border_size;
@@ -66,48 +142,71 @@
   nux::Property<int> animation_length;
   nux::Property<int> monitor;
   nux::Property<double> spread_size;
+};
+
+class NuxView : public ui::UnityWindowView,
+                public unity::switcher::View::Impl
+{
+  NUX_DECLARE_OBJECT_TYPE(NuxView, ui::UnityWindowView);
+public:
+  typedef nux::ObjectPtr<NuxView> Ptr;
+
+  NuxView();
+
+  ui::LayoutWindow::Vector ExternalTargets();
+
+  void SetModel(SwitcherModel::Ptr model);
+  SwitcherModel::Ptr GetModel();
 
   // Returns the index of the icon at the given position, in window coordinates.
   // If there's no icon there, -1 is returned.
   int IconIndexAt(int x, int y);
 
+  MouseEventConnections ConnectToMouseEvents(MouseButtonCallback const& mouse_down_callback,
+                                             MouseButtonCallback const& mouse_up_callback,
+                                             MouseDragCallback const&   mouse_drag_callback);
+
 protected:
   // Introspectable methods
+  void SetBackgroundColor(const nux::Color &);
+  void SetupBackground(bool enabled);
   std::string GetName() const;
   void AddProperties(GVariantBuilder* builder);
 
   void PreDraw(nux::GraphicsEngine& GfxContext, bool force_draw);
   void DrawOverlay(nux::GraphicsEngine& GfxContext, bool force_draw, nux::Geometry clip);
+  void QueueDraw();
+  nux::Geometry GetAbsoluteGeometry() const;
   nux::Geometry GetBackgroundGeometry();
 
   ui::RenderArg InterpolateRenderArgs(ui::RenderArg const& start, ui::RenderArg const& end, float progress);
-  nux::Geometry InterpolateBackground (nux::Geometry const& start, nux::Geometry const& end, float progress);
+  nux::Geometry InterpolateBackground(nux::Geometry const& start, nux::Geometry const& end, float progress);
 
   std::list<ui::RenderArg> RenderArgsFlat(nux::Geometry& background_geo, int selection, timespec const& current);
 
   ui::RenderArg CreateBaseArgForIcon(launcher::AbstractLauncherIcon::Ptr const& icon);
 private:
   void OnSelectionChanged(launcher::AbstractLauncherIcon::Ptr const& selection);
-  void OnDetailSelectionChanged (bool detail);
-  void OnDetailSelectionIndexChanged (unsigned int index);
-
-  void OnIconSizeChanged (int size);
-  void OnTileSizeChanged (int size);
-
-  nux::Geometry UpdateRenderTargets (nux::Point const& center, timespec const& current);
-  void OffsetRenderTargets (int x, int y);
-
-  nux::Size SpreadSize ();
-
-  void GetFlatIconPositions (int n_flat_icons, 
-                             int size, 
-                             int selection, 
-                             int &first_flat, 
-                             int &last_flat, 
-                             int &half_fold_left, 
-                             int &half_fold_right);
-
-  void SaveLast ();
+  void OnDetailSelectionChanged(bool detail);
+  void OnDetailSelectionIndexChanged(unsigned int index);
+
+  void OnIconSizeChanged(int size);
+  void OnTileSizeChanged(int size);
+
+  nux::Geometry UpdateRenderTargets(nux::Point const& center, timespec const& current);
+  void OffsetRenderTargets(int x, int y);
+
+  nux::Size SpreadSize();
+
+  void GetFlatIconPositions(int n_flat_icons,
+                            int size,
+                            int selection,
+                            int &first_flat,
+                            int &last_flat,
+                            int &half_fold_left,
+                            int &half_fold_right);
+
+  void SaveLast();
 
   SwitcherModel::Ptr model_;
   ui::LayoutSystem layout_system_;
@@ -131,7 +230,6 @@
 
   glib::Source::UniquePtr redraw_idle_;
 };
-
 }
 }
 

=== modified file 'plugins/unityshell/CMakeLists.txt'
--- plugins/unityshell/CMakeLists.txt	2012-11-28 07:58:44 +0000
+++ plugins/unityshell/CMakeLists.txt	2012-12-19 14:00:32 +0000
@@ -7,11 +7,14 @@
 compiz_plugin (unityshell
                PKGDEPS ${UNITY_PLUGIN_DEPS}
                PLUGINDEPS composite opengl compiztoolbox scale
-               CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${PKGDATADIR}\"' -I${CMAKE_BINARY_DIR} -I${CMAKE_SOURCE_DIR} ${BOOT_LOGGER_FLAG} -DGETTEXT_PACKAGE='\"unity\"' ${MAINTAINER_CXXFLAGS} -I${CMAKE_SOURCE_DIR}/dash/ -I${CMAKE_SOURCE_DIR}/launcher/ -I${CMAKE_SOURCE_DIR}/hud/ -I${CMAKE_SOURCE_DIR}/panel/ -I${CMAKE_SOURCE_DIR}/shortcuts/ -I${CMAKE_SOURCE_DIR}/unity-shared/"
-               LIBDIRS "${CMAKE_BINARY_DIR}/UnityCore"
+               CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${PKGDATADIR}\"' -I${CMAKE_BINARY_DIR} -I${CMAKE_SOURCE_DIR} ${BOOT_LOGGER_FLAG} -DGETTEXT_PACKAGE='\"unity\"' ${MAINTAINER_CXXFLAGS} -I${CMAKE_SOURCE_DIR}/dash/ -I${CMAKE_SOURCE_DIR}/launcher/ -I${CMAKE_SOURCE_DIR}/hud/ -I${CMAKE_SOURCE_DIR}/panel/ -I${CMAKE_SOURCE_DIR}/shortcuts/ -I${CMAKE_SOURCE_DIR}/unity-shared/ -I${CMAKE_SOURCE_DIR}/gestures/"
+               LIBDIRS "${CMAKE_BINARY_DIR}/UnityCore" "${CMAKE_BINARY_DIR}/gestures"
+               LIBRARIES unity-core-${UNITY_API_VERSION} launcher-lib dash-lib gestures-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-compiz
                )
-add_dependencies(unityshell unity-core-${UNITY_API_VERSION} dash-lib launcher-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-compiz)
-target_link_libraries(unityshell unity-core-${UNITY_API_VERSION} launcher-lib dash-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-bamf unity-shared-compiz)
+
+add_dependencies(unityshell unity-core-${UNITY_API_VERSION} dash-lib gestures-lib launcher-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-compiz)
+target_link_libraries(unityshell unity-core-${UNITY_API_VERSION} launcher-lib dash-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-bamf unity-shared-compiz gestures-lib)
+
 set_target_properties(unityshell 
                       PROPERTIES INSTALL_RPATH "${CACHED_UNITY_PRIVATE_DEPS_LIBRARY_DIRS}"
                       INSTALL_RPATH_USE_LINK_PATH TRUE)

=== modified file 'plugins/unityshell/src/unity-switcher-accessible.cpp'
--- plugins/unityshell/src/unity-switcher-accessible.cpp	2012-10-11 01:44:15 +0000
+++ plugins/unityshell/src/unity-switcher-accessible.cpp	2012-12-19 14:00:32 +0000
@@ -139,7 +139,7 @@
 {
   AtkObject* accessible = NULL;
 
-  g_return_val_if_fail(dynamic_cast<SwitcherView*>(object), NULL);
+  g_return_val_if_fail(dynamic_cast<View*>(object), NULL);
 
   accessible = ATK_OBJECT(g_object_new(UNITY_TYPE_SWITCHER_ACCESSIBLE, NULL));
 
@@ -154,7 +154,7 @@
 unity_switcher_accessible_initialize(AtkObject* accessible,
                                      gpointer data)
 {
-  SwitcherView* switcher = NULL;
+  View* switcher = NULL;
   nux::Object* nux_object = NULL;
   UnitySwitcherAccessible* self = NULL;
   SwitcherModel::Ptr model;
@@ -165,7 +165,8 @@
 
   self = UNITY_SWITCHER_ACCESSIBLE(accessible);
   nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(accessible));
-  switcher = dynamic_cast<SwitcherView*>(nux_object);
+  switcher = dynamic_cast<View*>(nux_object);
+
   if (switcher == NULL)
     return;
 
@@ -276,7 +277,7 @@
 unity_switcher_accessible_ref_selection(AtkSelection* selection,
                                         gint i)
 {
-  SwitcherView* switcher = NULL;
+  View* switcher = NULL;
   SwitcherModel::Ptr switcher_model;
   nux::Object* nux_object = NULL;
   gint selected_index = 0;
@@ -292,7 +293,7 @@
   if (!nux_object) /* state is defunct */
     return 0;
 
-  switcher = dynamic_cast<SwitcherView*>(nux_object);
+  switcher = dynamic_cast<View*>(nux_object);
 
   switcher_model = switcher->GetModel();
   selected_index = switcher_model->SelectionIndex();
@@ -309,7 +310,7 @@
 static gint
 unity_switcher_accessible_get_selection_count(AtkSelection* selection)
 {
-  SwitcherView* switcher = NULL;
+  View* switcher = NULL;
   SwitcherModel::Ptr switcher_model;
   nux::Object* nux_object = NULL;
 
@@ -319,7 +320,7 @@
   if (!nux_object) /* state is defunct */
     return 0;
 
-  switcher = dynamic_cast<SwitcherView*>(nux_object);
+  switcher = dynamic_cast<View*>(nux_object);
   switcher_model = switcher->GetModel();
 
   if (!switcher_model->Selection())
@@ -332,7 +333,7 @@
 unity_switcher_accessible_is_child_selected(AtkSelection* selection,
                                             gint i)
 {
-  SwitcherView* switcher = NULL;
+  View* switcher = NULL;
   SwitcherModel::Ptr switcher_model;
   SwitcherModel::iterator it;
   nux::Object* nux_object = NULL;
@@ -344,7 +345,7 @@
   if (!nux_object) /* state is defunct */
     return 0;
 
-  switcher = dynamic_cast<SwitcherView*>(nux_object);
+  switcher = dynamic_cast<View*>(nux_object);
   switcher_model = switcher->GetModel();
   selected_index = switcher_model->SelectionIndex();
 
@@ -385,7 +386,7 @@
 {
   gint index = 0;
   nux::Object* nux_object = NULL;
-  SwitcherView* switcher = NULL;
+  View* switcher = NULL;
   SwitcherModel::iterator it;
   AtkObject* child_accessible = NULL;
 
@@ -393,7 +394,7 @@
   if (!nux_object) /* state is defunct */
     return;
 
-  switcher = dynamic_cast<SwitcherView*>(nux_object);
+  switcher = dynamic_cast<View*>(nux_object);
   SwitcherModel::Ptr const& switcher_model = switcher->GetModel();
 
   if (!switcher_model)

=== modified file 'plugins/unityshell/src/unitya11y.cpp'
--- plugins/unityshell/src/unitya11y.cpp	2012-12-14 12:14:34 +0000
+++ plugins/unityshell/src/unitya11y.cpp	2012-12-19 14:00:32 +0000
@@ -183,7 +183,7 @@
   if (object->Type().IsDerivedFromType(unity::SearchBar::StaticObjectType))
     return unity_search_bar_accessible_new(object);
 
-  if (object->Type().IsDerivedFromType(unity::switcher::SwitcherView::StaticObjectType))
+  if (object->Type().IsDerivedFromType(unity::switcher::NuxView::StaticObjectType))
     return unity_switcher_accessible_new(object);
 
   /* NUX classes  */

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-12-18 01:21:03 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-12-19 14:00:32 +0000
@@ -32,6 +32,7 @@
 #include "Launcher.h"
 #include "LauncherIcon.h"
 #include "LauncherController.h"
+#include "SwitcherController.h"
 #include "PluginAdapter.h"
 #include "QuicklistManager.h"
 #include "StartupNotifyService.h"
@@ -41,6 +42,9 @@
 #include "unityshell.h"
 #include "BackgroundEffectHelper.h"
 #include "UnityGestureBroker.h"
+#include "UnityGestureTarget.h"
+#include "CompizX11MousePointer.h"
+#include "CompizGestureManipulatedWindow.h"
 #include "launcher/XdndCollectionWindowImp.h"
 #include "launcher/XdndManagerImp.h"
 #include "launcher/XdndStartStopNotifierImp.h"
@@ -74,6 +78,9 @@
 /* Set up vtable symbols */
 COMPIZ_PLUGIN_20090315(unityshell, unity::UnityPluginVTable);
 
+namespace ug = unity::gestures;
+namespace ugi = unity::gestures::impl;
+
 namespace unity
 {
 using namespace launcher;
@@ -374,7 +381,7 @@
      auto init_plugins_cb = sigc::mem_fun(this, &UnityScreen::initPluginActions);
      sources_.Add(std::make_shared<glib::Idle>(init_plugins_cb, glib::Source::Priority::DEFAULT));
 
-     InitGesturesSupport();
+     InitGesturesSupport (screen->dpy (), screen);
 
      CompString name(PKGDATADIR"/panel-shadow.png");
      CompString pname("unityshell");
@@ -1140,6 +1147,12 @@
   return ret;
 }
 
+unity::gestures::GestureManipulatedWindow &
+UnityWindow::GestureWindow ()
+{
+  return *gesture_window_;
+}
+
 unsigned int
 UnityWindow::GetNoCoreInstanceMask ()
 {
@@ -1437,7 +1450,7 @@
 
   if (switcher_controller_ && switcher_controller_->Visible())
   {
-    unity::switcher::SwitcherView* view = switcher_controller_->GetView();
+    unity::switcher::View* view = switcher_controller_->GetView();
 
     if (G_LIKELY(view))
     {
@@ -2980,7 +2993,7 @@
       launcher_controller_->UpdateSuperTapDuration(optionGetDashTapDuration());
       break;
     case UnityshellOptions::AltTabTimeout:
-      switcher_controller_->detail_on_timeout = optionGetAltTabTimeout();
+      switcher_controller_->SetDetailOnTimeout(optionGetAltTabTimeout());
     case UnityshellOptions::AltTabBiasViewport:
       PluginAdapter::Default().bias_active_to_viewport = optionGetAltTabBiasViewport();
       break;
@@ -3117,8 +3130,12 @@
   launcher_controller_->UpdateSuperTapDuration(optionGetDashTapDuration());
   AddChild(launcher_controller_.get());
 
-  switcher_controller_ = std::make_shared<switcher::Controller>();
-  AddChild(switcher_controller_.get());
+  switcher_controller_ = std::make_shared<switcher::Controller>([this]{
+    std::unique_ptr<switcher::ShellController> p(new switcher::ShellController());
+    introspectable_switcher_controller_ = p.get();
+    return p;
+  });
+  AddChild(introspectable_switcher_controller_);
 
   LOG_INFO(logger) << "initLauncher-Launcher " << timer.ElapsedSeconds() << "s";
 
@@ -3436,9 +3453,98 @@
                                                     COMPIZ_RESIZE_OPTION_INITIATE_BUTTON));
 }
 
-void UnityScreen::InitGesturesSupport()
-{
-  std::unique_ptr<nux::GestureBroker> gesture_broker(new UnityGestureBroker);
+namespace
+{
+gestures::GestureManipulatedWindow &
+getGestureWindowFromCompWindow (CompWindow * &w)
+{
+  return UnityWindow::get (w)->GestureWindow ();
+}
+
+class GesturalWindowSwitcherActionInvokerGLib : public unity::GesturalWindowSwitcherActionInvoker
+{
+  public:
+
+    GesturalWindowSwitcherActionInvokerGLib (const std::function <bool ()> &func) :
+      callback_ (func)
+    {
+    }
+
+    void InvokeOnTimeout (int timeout)
+    {
+      source_.reset (new glib::Timeout (timeout, callback_));
+    }
+
+    void StopPendingInvocation ()
+    {
+      source_.reset ();
+    }
+
+  private:
+
+    std::function <bool ()>  callback_;
+    unity::glib::Source::Ptr source_;
+};
+
+class GesturalWindowSwitcherActionInvokerFactoryGLib : public unity::GesturalWindowSwitcherActionInvokerFactory
+{
+  public:
+
+    GesturalWindowSwitcherActionInvoker::Ptr
+    CreateActionInvoker(const std::function<bool ()> &func) const
+    {
+      return std::make_shared <GesturalWindowSwitcherActionInvokerGLib> (func);
+    }
+};
+}
+
+void UnityScreen::InitGesturesSupport (Display *dpy, CompScreen *screen)
+{
+  typedef gestures::GestureManipulatedWindow GestureWindow;
+  typedef unity::AbstractInterfaceCollectionGenerator<GestureWindow, CompWindowList> WindowListGenerator;
+  typedef unity::AbstractInterfaceCollectionGenerator<GestureWindow, CompWindowVector> WindowVectorGenerator;
+  typedef unity::AbstractInterfaceGenerator<GestureWindow> GestureWindowGenerator;
+  typedef std::shared_ptr <GestureWindowGenerator> GestureWindowGeneratorPtr;
+
+  auto get_gesture_window_from_window =
+    [](CompWindow * const& w) -> GestureWindow &
+    {
+      return UnityWindow::get (w)->GestureWindow ();
+    };
+
+  gestures::MousePointer::Ptr                pointer (
+        std::make_shared<gestures::impl::CompX11MousePointer>(dpy, screen));
+
+  UnityGestureBroker::GetWindowGeneratorFunc client_list_func
+    ([screen, &get_gesture_window_from_window]() -> GestureWindowGeneratorPtr
+     {
+       return std::make_shared <WindowVectorGenerator>(screen->clientList(),
+                                                       get_gesture_window_from_window);
+     });
+  UnityGestureBroker::GetWindowGeneratorFunc all_windows_func
+    ([screen, &get_gesture_window_from_window]() -> GestureWindowGeneratorPtr
+     {
+       return std::make_shared <WindowListGenerator>(screen->windows(),
+                                                     get_gesture_window_from_window);
+     });
+
+  GesturalWindowSwitcherActionInvokerFactoryGLib gesture_action_invoker_factory;
+  const unity::switcher::Controller::Ptr controller_interface (switcher_controller ());
+  auto gestural_window_switcher (std::make_shared <GesturalWindowSwitcherImpl> (controller_interface,
+                                                                                std::bind (&UnityScreen::SetUpAndShowSwitcher,
+                                                                                           this,
+                                                                                           switcher::ShowMode::CURRENT_VIEWPORT),
+                                                                                gesture_action_invoker_factory));
+
+  auto unity_gesture_target (std::make_shared <UnityGestureTarget> ());
+  auto gesture_target_factory (std::make_shared <ugi::WindowGestureTargetFactory> ());
+
+  std::unique_ptr<nux::GestureBroker> gesture_broker(new UnityGestureBroker (pointer,
+                                                                             client_list_func,
+                                                                             all_windows_func,
+                                                                             gestural_window_switcher,
+                                                                             unity_gesture_target,
+                                                                             gesture_target_factory));
   wt->GetWindowCompositor().SetGestureBroker(std::move(gesture_broker));
 
   gestures_sub_launcher_.reset(new nux::GesturesSubscription);
@@ -3536,6 +3642,7 @@
   , PluginClassHandler<UnityWindow, CompWindow>(window)
   , window(window)
   , gWindow(GLWindow::get(window))
+  , gesture_window_ (new gestures::impl::CompGestureManipulatedWindow(window))
 {
   WindowInterface::setHandler(window);
   GLWindowInterface::setHandler(gWindow);

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-12-13 06:52:18 +0000
+++ plugins/unityshell/src/unityshell.h	2012-12-19 14:00:32 +0000
@@ -55,6 +55,7 @@
 #include "UnityshellPrivate.h"
 #include "UnityShowdesktopHandler.h"
 #include "ThumbnailGenerator.h"
+#include "WindowGestureTarget.h"
 
 #include "compizminimizedwindowhandler.h"
 #include "BGHash.h"
@@ -244,7 +245,7 @@
 
   void OnPanelStyleChanged();
 
-  void InitGesturesSupport();
+  void InitGesturesSupport (Display *dpy, CompScreen *screen);
 
   void DrawTopPanelBackground();
   bool TopPanelBackgroundTextureNeedsUpdate() const;
@@ -267,6 +268,7 @@
   launcher::Controller::Ptr launcher_controller_;
   dash::Controller::Ptr     dash_controller_;
   panel::Controller::Ptr    panel_controller_;
+  debug::Introspectable     *introspectable_switcher_controller_;
   switcher::Controller::Ptr switcher_controller_;
   hud::Controller::Ptr      hud_controller_;
   shortcut::Controller::Ptr shortcut_controller_;
@@ -404,6 +406,7 @@
   //! Emited when CompWindowNotifyBeforeDestroy is received
   sigc::signal<void> being_destroyed;
 
+  gestures::GestureManipulatedWindow & GestureWindow();
 
 protected:
   std::string GetName() const;
@@ -483,6 +486,7 @@
   nux::Geometry close_button_geo_;
   bool middle_clicked_;
   glib::Source::UniquePtr focus_desktop_timeout_;
+  unity::gestures::GestureManipulatedWindow::Ptr gesture_window_;
 
   friend class UnityScreen;
 };

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-12-17 19:35:34 +0000
+++ tests/CMakeLists.txt	2012-12-19 14:00:32 +0000
@@ -106,6 +106,7 @@
 # The actual test executable (xless) - do not put anything that requires X in here
   set (GTEST_XLESS_SOURCES
        test_main_xless.cpp
+       test_abstract_interface_generator.cpp
        test_launcher_model.cpp
        test_glib_object.cpp
        test_glib_object_utils.cpp

=== added file 'tests/MockSwitcherController.h'
--- tests/MockSwitcherController.h	1970-01-01 00:00:00 +0000
+++ tests/MockSwitcherController.h	2012-12-19 14:00:32 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *
+ */
+#ifndef _UNITY_MOCK_SWITCHER_CONTROLLER_H
+#define _UNITY_MOCK_SWITCHER_CONTROLLER_H
+
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include <SwitcherController.h>
+#include <SwitcherView.h>
+#include <AbstractLauncherIcon.h>
+
+namespace unity
+{
+namespace switcher
+{
+class MockSwitcherController : public Controller::Impl
+{
+public:
+  typedef std::shared_ptr <MockSwitcherController> Ptr;
+
+  MOCK_METHOD3(Show, void(ShowMode, SortMode, std::vector<launcher::AbstractLauncherIcon::Ptr>));
+  MOCK_METHOD1(Hide, void(bool));
+  MOCK_METHOD0(Visible, bool());
+  MOCK_METHOD0(Next, void());
+  MOCK_METHOD0(Prev, void());
+  MOCK_METHOD1(Select, void(int));
+  MOCK_METHOD0(GetView, unity::switcher::View * ());
+  MOCK_CONST_METHOD1(CanShowSwitcher, bool(const std::vector<launcher::AbstractLauncherIcon::Ptr> &));
+  MOCK_METHOD0(NextDetail, void());
+  MOCK_METHOD0(PrevDetail, void());
+  MOCK_METHOD2(SetDetail, void(bool, unsigned int));
+  MOCK_METHOD0(SelectFirstItem, void());
+  MOCK_METHOD2(SetWorkspace, void(nux::Geometry, int));
+  MOCK_METHOD0(ExternalRenderTargets, unity::ui::LayoutWindow::Vector ());
+  MOCK_CONST_METHOD0(GetSwitcherInputWindowId, guint());
+  MOCK_CONST_METHOD0(IsShowDesktopDisabled, bool());
+  MOCK_METHOD1(SetShowDesktopDisabled, void(bool));
+  MOCK_CONST_METHOD0(StartIndex, int());
+};
+}
+}
+
+#endif

=== added file 'tests/MockSwitcherController.h.moved'
--- tests/MockSwitcherController.h.moved	1970-01-01 00:00:00 +0000
+++ tests/MockSwitcherController.h.moved	2012-12-19 14:00:32 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *
+ */
+#ifndef _UNITY_MOCK_SWITCHER_CONTROLLER_H
+#define _UNITY_MOCK_SWITCHER_CONTROLLER_H
+
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include <time.h>
+
+#include <SwitcherController.h>
+#include <SwitcherView.h>
+#include <AbstractLauncherIcon.h>
+
+namespace unity
+{
+namespace switcher
+{
+class MockSwitcherController : public ControllerInterface
+{
+public:
+  typedef std::shared_ptr <MockSwitcherController> Ptr;
+
+  MOCK_METHOD3(Show, void(ShowMode, SortMode, std::vector<launcher::AbstractLauncherIcon::Ptr>));
+  MOCK_METHOD1(Hide, void(bool));
+  MOCK_METHOD0(Visible, bool());
+  MOCK_METHOD0(Next, void());
+  MOCK_METHOD0(Prev, void());
+  MOCK_METHOD1(Select, void(int));
+  MOCK_METHOD0(GetView, unity::switcher::SwitcherViewInterface * ());
+  MOCK_CONST_METHOD1(CanShowSwitcher, bool(const std::vector<launcher::AbstractLauncherIcon::Ptr> &));
+  MOCK_METHOD0(NextDetail, void());
+  MOCK_METHOD0(PrevDetail, void());
+  MOCK_METHOD2(SetDetail, void(bool, unsigned int));
+  MOCK_METHOD0(SelectFirstItem, void());
+  MOCK_METHOD2(SetWorkspace, void(nux::Geometry, int));
+  MOCK_METHOD0(ExternalRenderTargets, unity::ui::LayoutWindow::Vector ());
+  MOCK_CONST_METHOD0(GetSwitcherInputWindowId, guint());
+  MOCK_CONST_METHOD0(IsShowDesktopDisabled, bool());
+  MOCK_METHOD1(SetShowDesktopDisabled, void(bool));
+  MOCK_CONST_METHOD0(StartIndex, int());
+};
+}
+}
+
+#endif

=== added file 'tests/MockSwitcherView.h'
--- tests/MockSwitcherView.h	1970-01-01 00:00:00 +0000
+++ tests/MockSwitcherView.h	2012-12-19 14:00:32 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ *
+ */
+#ifndef _UNITY_MOCK_SWITCHER_VIEW_H
+#define _UNITY_MOCK_SWITCHER_VIEW_H
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <memory>
+
+#include <SwitcherView.h>
+#include <AbstractLauncherIcon.h>
+
+namespace unity
+{
+namespace switcher
+{
+class MockSwitcherView :
+  public View::Impl
+{
+  public:
+
+    MOCK_METHOD0(ExternalTargets, ui::LayoutWindow::Vector ());
+    MOCK_METHOD1(SetModel, void (SwitcherModel::Ptr));
+    MOCK_METHOD0(GetModel, SwitcherModel::Ptr ());
+    MOCK_METHOD3(ConnectToMouseEvents,
+                 View::MouseEventConnections (const View::MouseButtonCallback &mouse_down_callback,
+                                              const View::MouseButtonCallback &mouse_up_callback,
+                                              const View::MouseDragCallback   &mouse_drag_callback));
+    MOCK_METHOD0(QueueDraw, void ());
+    MOCK_CONST_METHOD0(GetAbsoluteGeometry, nux::Geometry ());
+    MOCK_METHOD2(IconIndexAt, int (int, int));
+    MOCK_METHOD1(SetBackgroundColor, void(nux::Color const&));
+    MOCK_METHOD1(SetupBackground, void(bool));
+};
+}
+}
+
+#endif

=== added file 'tests/MockSwitcherView.h.moved'
--- tests/MockSwitcherView.h.moved	1970-01-01 00:00:00 +0000
+++ tests/MockSwitcherView.h.moved	2012-12-19 14:00:32 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ *
+ */
+#ifndef _UNITY_MOCK_SWITCHER_VIEW_H
+#define _UNITY_MOCK_SWITCHER_VIEW_H
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <memory>
+
+#include <time.h>
+
+#include <SwitcherController.h>
+#include <AbstractLauncherIcon.h>
+
+namespace unity
+{
+namespace switcher
+{
+class MockSwitcherView :
+  public SwitcherViewInterface
+{
+  public:
+
+    MOCK_METHOD0 (ExternalTargets, ui::LayoutWindow::Vector ());
+    MOCK_METHOD1 (SetModel, void (SwitcherModel::Ptr));
+    MOCK_METHOD0 (GetModel, SwitcherModel::Ptr ());
+    MOCK_METHOD3 (ConnectToMouseEvents,
+                  SwitcherViewInterface::MouseEventConnections (const SwitcherViewInterface::MouseButtonCallback &mouse_down_callback,
+                                                                const SwitcherViewInterface::MouseButtonCallback &mouse_up_callback,
+                                                                const SwitcherViewInterface::MouseDragCallback   &mouse_drag_callback));
+    MOCK_METHOD0 (QueueDraw, void ());
+    MOCK_CONST_METHOD0 (GetAbsoluteGeometry, nux::Geometry ());
+    MOCK_METHOD2 (IconIndexAt, int (int, int));
+};
+}
+}
+
+#endif

=== modified file 'tests/MockWindowManager.h'
--- tests/MockWindowManager.h	2012-12-04 09:04:06 +0000
+++ tests/MockWindowManager.h	2012-12-19 14:00:32 +0000
@@ -99,6 +99,10 @@
     MOCK_CONST_METHOD1(GetWindowName, std::string(Window));
 
     MOCK_METHOD1(AddProperties, void(GVariantBuilder*));
+
+    MOCK_CONST_METHOD0 (GetCurrentViewport, nux::Point ());
+    MOCK_CONST_METHOD0 (GetViewportHSize, int ());
+    MOCK_CONST_METHOD0 (GetViewportVSize, int ());
 };
 }
 

=== added file 'tests/StubSwitcherController.h'
--- tests/StubSwitcherController.h	1970-01-01 00:00:00 +0000
+++ tests/StubSwitcherController.h	2012-12-19 14:00:32 +0000
@@ -0,0 +1,155 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *
+ */
+#ifndef _UNITY_STUB_SWITCHER_CONTROLLER_H
+#define _UNITY_STUB_SWITCHER_CONTROLLER_H
+
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include <SwitcherController.h>
+#include <SwitcherView.h>
+#include <AbstractLauncherIcon.h>
+
+namespace unity
+{
+namespace switcher
+{
+class StubSwitcherController : public ShellController
+{
+  public:
+    typedef std::shared_ptr <StubSwitcherController> Ptr;
+
+    StubSwitcherController()
+      : ShellController()
+      , window_constructed_(false)
+      , view_constructed_(false)
+      , view_shown_(false)
+      , detail_timeout_reached_(false)
+      , mock_view_ (nullptr)
+    {
+      Reset ();
+    };
+
+    StubSwitcherController(unsigned int load_timeout)
+      : ShellController(load_timeout)
+      , window_constructed_(false)
+      , view_constructed_(false)
+      , view_shown_(false)
+      , detail_timeout_reached_(false)
+      , mock_view_ (nullptr)
+    {
+      Reset ();
+    };
+
+    void SetView (View *view)
+    {
+      mock_view_ = view;
+    }
+
+    View * GetView ()
+    {
+      return mock_view_;
+    }
+
+    virtual void ConstructWindow()
+    {
+      window_constructed_ = true;
+    }
+
+    virtual void ConstructView()
+    {
+      view_constructed_ = true;
+    }
+
+    virtual void ShowView()
+    {
+      view_shown_ = true;
+    }
+
+    virtual bool OnDetailTimer()
+    {
+      detail_timeout_reached_ = true;
+      clock_gettime(CLOCK_MONOTONIC, &detail_timespec_);
+      return false;
+    }
+
+    void Reset()
+    {
+      is_visible_ = false;
+      prev_count_ = 0;
+      next_count_ = 0;
+      index_selected_ = -1;
+    }
+
+    void Next()
+    {
+      ++next_count_;
+    }
+
+    void Prev()
+    {
+      ++prev_count_;
+    }
+
+    void Select(int index)
+    {
+      index_selected_ = index;
+    }
+
+    bool Visible()
+    {
+      return is_visible_;
+    }
+
+    void Hide(bool accept_state = true)
+    {
+      is_visible_ = false;
+    }
+
+    unsigned int GetConstructTimeout() const
+    {
+      return construct_timeout_;
+    }
+
+    void FakeSelectionChange()
+    {
+      unity::launcher::AbstractLauncherIcon::Ptr icon;
+      OnModelSelectionChanged(icon);
+    }
+
+    bool window_constructed_;
+    bool view_constructed_;
+    bool view_shown_;
+    bool detail_timeout_reached_;
+    struct timespec detail_timespec_;
+
+    bool is_visible_;
+    int prev_count_;
+    int next_count_;
+    int index_selected_;
+
+  private:
+    View *mock_view_;
+};
+}
+}
+
+#endif

=== added file 'tests/StubSwitcherController.h.moved'
--- tests/StubSwitcherController.h.moved	1970-01-01 00:00:00 +0000
+++ tests/StubSwitcherController.h.moved	2012-12-19 14:00:32 +0000
@@ -0,0 +1,157 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *
+ */
+#ifndef _UNITY_STUB_SWITCHER_CONTROLLER_H
+#define _UNITY_STUB_SWITCHER_CONTROLLER_H
+
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include <time.h>
+
+#include <SwitcherController.h>
+#include <SwitcherView.h>
+#include <AbstractLauncherIcon.h>
+
+namespace unity
+{
+namespace switcher
+{
+class StubSwitcherController : public Controller
+{
+  public:
+    typedef std::shared_ptr <StubSwitcherController> Ptr;
+
+    StubSwitcherController()
+      : Controller()
+      , window_constructed_(false)
+      , view_constructed_(false)
+      , view_shown_(false)
+      , detail_timeout_reached_(false)
+      , mock_view_ (nullptr)
+    {
+      Reset ();
+    };
+
+    StubSwitcherController(unsigned int load_timeout)
+      : Controller(load_timeout)
+      , window_constructed_(false)
+      , view_constructed_(false)
+      , view_shown_(false)
+      , detail_timeout_reached_(false)
+      , mock_view_ (nullptr)
+    {
+      Reset ();
+    };
+
+    void SetView (SwitcherViewInterface *view)
+    {
+      mock_view_ = view;
+    }
+
+    SwitcherViewInterface * GetView ()
+    {
+      return mock_view_;
+    }
+
+    virtual void ConstructWindow()
+    {
+      window_constructed_ = true;
+    }
+
+    virtual void ConstructView()
+    {
+      view_constructed_ = true;
+    }
+
+    virtual void ShowView()
+    {
+      view_shown_ = true;
+    }
+
+    virtual bool OnDetailTimer()
+    {
+      detail_timeout_reached_ = true;
+      clock_gettime(CLOCK_MONOTONIC, &detail_timespec_);
+      return false;
+    }
+
+    void Reset()
+    {
+      is_visible_ = false;
+      prev_count_ = 0;
+      next_count_ = 0;
+      index_selected_ = -1;
+    }
+
+    void Next()
+    {
+      ++next_count_;
+    }
+
+    void Prev()
+    {
+      ++prev_count_;
+    }
+
+    void Select(int index)
+    {
+      index_selected_ = index;
+    }
+
+    bool Visible()
+    {
+      return is_visible_;
+    }
+
+    void Hide(bool accept_state = true)
+    {
+      is_visible_ = false;
+    }
+
+    unsigned int GetConstructTimeout() const
+    {
+      return construct_timeout_;
+    }
+
+    void FakeSelectionChange()
+    {
+      unity::launcher::AbstractLauncherIcon::Ptr icon;
+      OnModelSelectionChanged(icon);
+    }
+
+    bool window_constructed_;
+    bool view_constructed_;
+    bool view_shown_;
+    bool detail_timeout_reached_;
+    struct timespec detail_timespec_;
+
+    bool is_visible_;
+    int prev_count_;
+    int next_count_;
+    int index_selected_;
+
+  private:
+    SwitcherViewInterface *mock_view_;
+};
+}
+}
+
+#endif

=== modified file 'tests/test-gestures/CMakeLists.txt'
--- tests/test-gestures/CMakeLists.txt	2012-12-17 15:26:26 +0000
+++ tests/test-gestures/CMakeLists.txt	2012-12-19 14:00:32 +0000
@@ -1,57 +1,6 @@
 if (GTEST_SRC_DIR)
   set(UNITY_SRC ${CMAKE_SOURCE_DIR}/plugins/unityshell/src)
-
-  add_custom_command(OUTPUT CompoundGestureRecognizer.cpp
-                            CompoundGestureRecognizer.h
-                            GesturalWindowSwitcher.cpp
-                            GesturalWindowSwitcher.h
-                            UnityGestureBroker.cpp
-                            UnityGestureBroker.h
-                            UBusMessages.h
-                            WindowGestureTarget.h
-                            WindowGestureTarget.cpp
-
-                     COMMAND cp ${UNITY_SRC}/CompoundGestureRecognizer.cpp
-                                ${UNITY_SRC}/CompoundGestureRecognizer.h
-                                ${CMAKE_CURRENT_BINARY_DIR}
-
-                     COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/sed_script_broker
-                             ${UNITY_SRC}/UnityGestureBroker.cpp >
-                             ${CMAKE_CURRENT_BINARY_DIR}/UnityGestureBroker.cpp
-
-                     COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/sed_script_broker
-                             ${UNITY_SRC}/UnityGestureBroker.h >
-                             ${CMAKE_CURRENT_BINARY_DIR}/UnityGestureBroker.h
-
-                     COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/sed_script_gesture
-                             ${UNITY_SRC}/WindowGestureTarget.h >
-                             ${CMAKE_CURRENT_BINARY_DIR}/WindowGestureTarget.h
-
-                     COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/sed_script_gesture
-                             ${UNITY_SRC}/WindowGestureTarget.cpp >
-                             ${CMAKE_CURRENT_BINARY_DIR}/WindowGestureTarget.cpp
-
-                     COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/sed_script_switcher
-                             ${UNITY_SRC}/GesturalWindowSwitcher.cpp >
-                             ${CMAKE_CURRENT_BINARY_DIR}/GesturalWindowSwitcher.cpp
-
-                     COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/sed_script_switcher
-                             ${UNITY_SRC}/GesturalWindowSwitcher.h >
-                             ${CMAKE_CURRENT_BINARY_DIR}/GesturalWindowSwitcher.h
-
-                     DEPENDS ${UNITY_SRC}/CompoundGestureRecognizer.cpp
-                             ${UNITY_SRC}/CompoundGestureRecognizer.h
-                             ${UNITY_SRC}/GesturalWindowSwitcher.cpp
-                             ${UNITY_SRC}/GesturalWindowSwitcher.h
-                             ${UNITY_SRC}/UnityGestureBroker.cpp
-                             ${UNITY_SRC}/UnityGestureBroker.h
-                             ${CMAKE_SOURCE_DIR}/unity-shared/UBusMessages.h
-                             ${UNITY_SRC}/WindowGestureTarget.h
-                             ${UNITY_SRC}/WindowGestureTarget.cpp
-                             sed_script_broker
-                             sed_script_gesture
-
-                     COMMENT "Copying and modifying sources under test.")
+  set(UNITY_SHARED_SRC ${CMAKE_SOURCE_DIR}/unity-shared)
 
   # Clean-up includes and definitions made in ../CmakeLists.txt
   remove_definitions(${CFLAGS})
@@ -59,38 +8,35 @@
 
   include_directories (${CMAKE_SOURCE_DIR})
   include_directories (${CMAKE_SOURCE_DIR}/unity-shared)
+  include_directories (${CMAKE_SOURCE_DIR}/gestures)
 
   # And make our own
   pkg_check_modules (TEST_GESTURES_DEPS REQUIRED QUIET "${UNITY_PLUGIN_DEPS}")
   set(TEST_GESTURES_CFLAGS
       "-g"
       "-I${CMAKE_CURRENT_SOURCE_DIR}"
+      "-I${CMAKE_SOURCE_DIR}/tests"
       "-I${CMAKE_CURRENT_BINARY_DIR}"
+      "-I${CMAKE_SOURCE_DIR}/unity-shared"
+      "-I${CMAKE_SOURCE_DIR}/launcher"
+      "-I${CMAKE_SOURCE_DIR}"
+      "-I${CMAKE_BINARY_DIR}"
+      "-I${CMAKE_SOURCE_DIR}/gestures"
       ${TEST_GESTURES_DEPS_CFLAGS}
      )
   add_definitions(${TEST_GESTURES_CFLAGS})
 
   pkg_check_modules (COMPIZ REQUIRED QUIET compiz)
-  link_directories (${COMPIZ_LIBDIR})
+  link_directories (${COMPIZ_LIBDIR} ${CMAKE_BINARY_DIR}/unity-shared ${CMAKE_BINARY_DIR}/gestures)
 
   add_executable(test-gestures
-                 CompoundGestureRecognizer.cpp
-                 CompoundGestureRecognizer.h
-                 GesturalWindowSwitcher.cpp
-                 GesturalWindowSwitcher.h
                  test_compound_gesture_recognizer.cpp
                  test_gestural_window_switcher.cpp
                  test_gestures_main.cpp
                  test_gesture_broker.cpp
                  test_window_gesture_target.cpp
-                 X11_mock.cpp
-                 UnityGestureBroker.cpp
-                 WindowGestureTarget.cpp
-                 PluginAdapterMock.cpp
-                 ubus-server-mock.cpp
-                 UnityGestureTargetMock.h
                 )
-  target_link_libraries(test-gestures gtest ${TEST_GESTURES_DEPS_LIBRARIES} compiz_core)
+  target_link_libraries(test-gestures gtest gmock gmock_main unity_mock_window_manager ${TEST_GESTURES_DEPS_LIBRARIES} compiz_core unity-shared gestures-lib switcher-lib launcher-lib)
   add_test(UnityGTestGestures test-gestures)
   add_dependencies(test-gestures gtest unity-core-${UNITY_API_VERSION})
 

=== modified file 'tests/test-gestures/FakeGestureEvent.h'
--- tests/test-gestures/FakeGestureEvent.h	2012-07-27 20:20:29 +0000
+++ tests/test-gestures/FakeGestureEvent.h	2012-12-19 14:00:32 +0000
@@ -4,6 +4,12 @@
 #include <NuxGraphics/GestureEvent.h>
 #include <map>
 
+#define CompWindowStateMaximizedVertMask (1 << 1)
+#define CompWindowStateMaximizedHorzMask (1 << 2)
+#define CompWindowStateHiddenMask (1 << 3)
+#define CompWindowActionMoveMask (1 << 4)
+#define MAXIMIZE_STATE (CompWindowStateMaximizedVertMask | CompWindowStateMaximizedHorzMask)
+
 namespace nux {
 class FakeGestureEvent
 {

=== modified file 'tests/test-gestures/GesturalWindowSwitcherMock.h'
--- tests/test-gestures/GesturalWindowSwitcherMock.h	2012-08-14 12:48:21 +0000
+++ tests/test-gestures/GesturalWindowSwitcherMock.h	2012-12-19 14:00:32 +0000
@@ -19,22 +19,29 @@
 #ifndef GESTURAL_WINDOW_SWITCHER_MOCK_H
 #define GESTURAL_WINDOW_SWITCHER_MOCK_H
 
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
 #include <Nux/Gesture.h>
+#include <GesturalWindowSwitcher.h>
+
+using ::testing::_;
+using ::testing::Return;
 
 namespace unity
 {
 
-class GesturalWindowSwitcherMock : public nux::GestureTarget
+class GesturalWindowSwitcherMock : public GesturalWindowSwitcherInterface
 {
   public:
-    GesturalWindowSwitcherMock() {}
-
-    virtual nux::GestureDeliveryRequest GestureEvent(const nux::GestureEvent &event)
+
+    MOCK_METHOD1(GestureEvent, nux::GestureDeliveryRequest(nux::GestureEvent const &));
+
+    GesturalWindowSwitcherMock ()
     {
-      return nux::GestureDeliveryRequest::NONE;
+      ON_CALL(*this, GestureEvent (_)).WillByDefault (Return(nux::GestureDeliveryRequest::NONE));
     }
 };
-typedef std::shared_ptr<GesturalWindowSwitcherMock> ShPtGesturalWindowSwitcherMock;
 
 } //namespace unity
 #endif // GESTURAL_WINDOW_SWITCHER_MOCK_H

=== added file 'tests/test-gestures/MockGestureManipulatedWindow.h'
--- tests/test-gestures/MockGestureManipulatedWindow.h	1970-01-01 00:00:00 +0000
+++ tests/test-gestures/MockGestureManipulatedWindow.h	2012-12-19 14:00:32 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ *
+ */
+#ifndef _UNITY_MOCK_GESTURE_MANIPULATED_WINDOW_H
+#define _UNITY_MOCK_GESTURE_MANIPULATED_WINDOW_H
+
+#include <memory>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <WindowGestureTarget.h>
+
+using ::testing::AtLeast;
+
+class MockGestureManipulatedWindow :
+  public unity::gestures::GestureManipulatedWindow
+{
+  public:
+
+    MockGestureManipulatedWindow()
+    {
+      EXPECT_CALL (*this, GetIdentifier()).Times(AtLeast(0));
+    }
+
+    typedef std::shared_ptr <MockGestureManipulatedWindow> Ptr;
+
+    MOCK_METHOD1 (MoveByDelta, void (const nux::Point &));
+    MOCK_METHOD0 (MaximizeVerticallyAndHorizontally, void ());
+    MOCK_METHOD0 (Demaximize, bool ());
+    MOCK_METHOD0 (Grab, void ());
+    MOCK_METHOD0 (Ungrab, void ());
+    MOCK_METHOD1 (ShowGrabHandles, void (HideMode));
+    MOCK_CONST_METHOD0 (Geometry, const compiz::window::Geometry & ());
+    MOCK_CONST_METHOD0 (IsVerticallyMaximized, bool ());
+    MOCK_CONST_METHOD0 (IsHorizontallyMaximized, bool ());
+    MOCK_CONST_METHOD0 (IsMovable, bool ());
+    MOCK_CONST_METHOD0 (Visible, bool ());
+    MOCK_CONST_METHOD0 (GetIdentifier, unsigned long ());
+};
+
+#endif

=== added file 'tests/test-gestures/MockGestureTarget.h'
--- tests/test-gestures/MockGestureTarget.h	1970-01-01 00:00:00 +0000
+++ tests/test-gestures/MockGestureTarget.h	2012-12-19 14:00:32 +0000
@@ -0,0 +1,15 @@
+#ifndef UNITY_MOCK_GESTURE_TARGET_H
+#define UNITY_MOCK_GESTURE_TARGET_H
+
+#include <memory>
+#include <Nux/Gesture.h>
+
+class MockGestureTarget : public nux::GestureTarget
+{
+  public:
+
+    MOCK_METHOD1 (GestureEvent, nux::GestureDeliveryRequest (const nux::GestureEvent &event));
+    MOCK_CONST_METHOD1 (Equals, bool (const nux::GestureTarget &other));
+};
+
+#endif // UNITY_MOCK_GESTURE_TARGET_H

=== added file 'tests/test-gestures/MockMousePointer.h'
--- tests/test-gestures/MockMousePointer.h	1970-01-01 00:00:00 +0000
+++ tests/test-gestures/MockMousePointer.h	2012-12-19 14:00:32 +0000
@@ -0,0 +1,17 @@
+#ifndef _UNITY_MOCK_MOUSE_POINTER_H
+#define _UNITY_MOCK_MOUSE_POINTER_H
+
+#include <WindowGestureTarget.h>
+
+class MockMousePointer :
+  public unity::gestures::MousePointer
+{
+  public:
+
+    MOCK_METHOD0 (MakeGrabbedForMovement, void ());
+    MOCK_METHOD0 (MakeUngrabbedForMovement, void ());
+    MOCK_METHOD1 (WarpPositionByDelta, void (const nux::Point &));
+    MOCK_CONST_METHOD2 (RestrainDeltaToScreenSize, void (int &, int &));
+};
+
+#endif

=== removed file 'tests/test-gestures/NuxMock.h'
--- tests/test-gestures/NuxMock.h	2012-07-27 20:24:01 +0000
+++ tests/test-gestures/NuxMock.h	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-#ifndef NUX_MOCK_H
-#define NUX_MOCK_H
-
-#include <Nux/Nux.h>
-
-namespace nux
-{
-
-class InputAreaMock : public Object
-{
-  public:
-    void GestureEvent(const GestureEvent &event)
-    {
-    } 
-};
-
-class ViewMock : public InputAreaMock
-{
-  public:
-    sigc::signal<void, int, int, unsigned long, unsigned long> mouse_down;
-    sigc::signal<void, int, int, unsigned long, unsigned long> mouse_up;
-    sigc::signal<void, int, int, int, int, unsigned long, unsigned long> mouse_drag;
-};
-
-} // namespace nux
-
-#endif // NUX_MOCK_H

=== removed file 'tests/test-gestures/PluginAdapterMock.cpp'
--- tests/test-gestures/PluginAdapterMock.cpp	2012-10-11 01:44:15 +0000
+++ tests/test-gestures/PluginAdapterMock.cpp	1970-01-01 00:00:00 +0000
@@ -1,33 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#include "PluginAdapterMock.h"
-
-PluginAdapterMock *PluginAdapterMock::_default = 0;
-
-PluginAdapterMock& PluginAdapterMock::Default() {
-  if (!_default) {
-    _default = new PluginAdapterMock;
-  }
-  return *_default;
-}
-
-void PluginAdapterMock::ShowGrabHandles(CompWindowMock* window, bool use_timer) {
-}

=== removed file 'tests/test-gestures/PluginAdapterMock.h'
--- tests/test-gestures/PluginAdapterMock.h	2012-10-11 01:44:15 +0000
+++ tests/test-gestures/PluginAdapterMock.h	1970-01-01 00:00:00 +0000
@@ -1,38 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#ifndef PLUGINADAPTER_MOCK_H
-#define PLUGINADAPTER_MOCK_H
-
-#include <compiz_mock/core/core.h>
-
-
-class PluginAdapterMock {
-public:
-  static PluginAdapterMock& Default();
-
-  void ShowGrabHandles(CompWindowMock* window, bool use_timer);
-
-private:
-  PluginAdapterMock() {}
-  static PluginAdapterMock* _default;
-};
-
-#endif

=== removed file 'tests/test-gestures/SwitcherControllerMock.h'
--- tests/test-gestures/SwitcherControllerMock.h	2012-08-03 13:26:22 +0000
+++ tests/test-gestures/SwitcherControllerMock.h	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-/*
- * 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: Daniel d'Andrada <[e-mail]>
- */
-
-#ifndef SWITCHER_CONTROLLER_MOCK_H
-#define SWITCHER_CONTROLLER_MOCK_H
-
-#include "NuxMock.h"
-
-namespace unity {
-namespace switcher {
-
-class SwitcherViewMock : public nux::ViewMock
-{
-public:
-  int IconIndexAt(int x, int y)
-  {
-    return x*y;
-  }
-};
-
-class ControllerMock
-{
-public:
-  ControllerMock()
-  {
-    Reset();
-  }
-
-  void Reset()
-  {
-    is_visible_ = false;
-    prev_count_ = 0;
-    next_count_ = 0;
-    index_selected_ = -1;
-  }
-
-  typedef std::shared_ptr<ControllerMock> Ptr;
-
-  sigc::signal<void> view_built;
-
-  void Next()
-  {
-    ++next_count_;
-  }
-
-  void Prev()
-  {
-    ++prev_count_;
-  }
-
-  void Select(int index)
-  {
-    index_selected_ = index;
-  }
-
-  bool Visible()
-  {
-    return is_visible_;
-  }
-
-  void Hide()
-  {
-    is_visible_ = false;
-  }
-
-  SwitcherViewMock *GetView()
-  {
-    return &view_;
-  }
-
-  bool is_visible_;
-  SwitcherViewMock view_;
-  int prev_count_;
-  int next_count_;
-  int index_selected_;
-};
-
-} // namespace switcher
-} // namespace unity
-
-
-#endif // SWITCHER_CONTROLLER_MOCK_H

=== removed file 'tests/test-gestures/UnityGestureTargetMock.h'
--- tests/test-gestures/UnityGestureTargetMock.h	2012-07-27 20:20:29 +0000
+++ tests/test-gestures/UnityGestureTargetMock.h	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
-#ifndef UNITY_GESTURE_TARGET_MOCK_H
-#define UNITY_GESTURE_TARGET_MOCK_H
-
-#include <Nux/Gesture.h>
-
-class UnityGestureTargetMock : public nux::GestureTarget
-{
-  public:
-    virtual nux::GestureDeliveryRequest GestureEvent(const nux::GestureEvent &event)
-    {
-      return nux::GestureDeliveryRequest::NONE;
-    }
-};
-
-#endif // UNITY_GESTURE_TARGET_MOCK_H

=== modified file 'tests/test-gestures/WindowGestureTargetMock.h'
--- tests/test-gestures/WindowGestureTargetMock.h	2012-07-27 20:20:29 +0000
+++ tests/test-gestures/WindowGestureTargetMock.h	2012-12-19 14:00:32 +0000
@@ -1,9 +1,19 @@
 #ifndef WINDOW_GESTURE_TARGET_MOCK_H
 #define WINDOW_GESTURE_TARGET_MOCK_H
 
+#include <memory>
+#include <set>
 #include <Nux/Gesture.h>
+#include <WindowGestureTarget.h>
 
-#include <set>
+namespace unity
+{
+namespace gestures
+{
+class GestureManipulatedWindow;
+class MousePointer;
+}
+}
 
 class CompWindowMock;
 class WindowGestureTargetMock;
@@ -13,7 +23,8 @@
 class WindowGestureTargetMock : public nux::GestureTarget
 {
   public:
-    WindowGestureTargetMock(CompWindowMock *window) : window(window)
+    WindowGestureTargetMock(unity::gestures::GestureManipulatedWindow &manipulated,
+                            const std::weak_ptr <unity::gestures::MousePointer> &mc) : manipulated_window (manipulated), pointer(mc)
     {
       g_window_target_mocks.insert(this);
     }
@@ -29,10 +40,9 @@
       return nux::GestureDeliveryRequest::NONE;
     }
 
-    CompWindowMock *window;
     std::list<nux::GestureEvent> events_received;
-
-    static Cursor fleur_cursor;
+    unity::gestures::GestureManipulatedWindow &manipulated_window;
+    const std::weak_ptr <unity::gestures::MousePointer> &pointer;
   private:
     virtual bool Equals(const nux::GestureTarget& other) const
     {
@@ -40,10 +50,7 @@
 
       if (window_target)
       {
-        if (window && window_target->window)
-          return window->id() == window_target->window->id();
-        else
-          return window == window_target->window;
+        return manipulated_window.GetIdentifier () == window_target->manipulated_window.GetIdentifier ();
       }
       else
       {

=== removed file 'tests/test-gestures/X11_mock.cpp'
--- tests/test-gestures/X11_mock.cpp	2012-04-04 14:33:07 +0000
+++ tests/test-gestures/X11_mock.cpp	1970-01-01 00:00:00 +0000
@@ -1,40 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#include <X11/Xlib.h>
-
-Cursor XCreateFontCursorMock(Display * /*display*/, unsigned int /*shape*/) {
-    return 1;
-}
-
-int XFreeCursorMock(Display * /*display*/, Cursor /*cursor*/) {
-    return 1;
-}
-
-int XSyncMock(Display *display, Bool discard) {
-  return 1;
-}
-
-int XWarpPointerMock(Display *display, Window src_w, Window dest_w,
-                     int src_x, int src_y,
-                     unsigned int src_width, unsigned int src_height,
-                     int dest_x, int dest_y) {
-  return 1;
-}

=== removed file 'tests/test-gestures/X11_mock.h'
--- tests/test-gestures/X11_mock.h	2012-04-04 14:33:07 +0000
+++ tests/test-gestures/X11_mock.h	1970-01-01 00:00:00 +0000
@@ -1,37 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#ifndef X11_MOCK_H
-#define X11_MOCK_H
-
-#include <X11/Xlib.h>
-
-Cursor XCreateFontCursorMock(Display *display, unsigned int shape);
-
-int XFreeCursorMock(Display *display, Cursor cursor);
-
-int XSyncMock(Display *display, Bool discard);
-
-int XWarpPointerMock(Display *display, Window src_w, Window dest_w,
-                     int src_x, int src_y,
-                     unsigned int src_width, unsigned int src_height,
-                     int dest_x, int dest_y);
-
-#endif // X11_MOCK_H

=== removed directory 'tests/test-gestures/compiz_mock'
=== removed directory 'tests/test-gestures/compiz_mock/core'
=== removed file 'tests/test-gestures/compiz_mock/core/core.h'
--- tests/test-gestures/compiz_mock/core/core.h	2012-04-04 14:33:07 +0000
+++ tests/test-gestures/compiz_mock/core/core.h	1970-01-01 00:00:00 +0000
@@ -1,29 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#ifndef COMPIZ_CORE_MOCK_H
-#define COMPIZ_CORE_MOCK_H
-
-#include <X11_mock.h>
-
-#include <compiz_mock/core/window.h>
-#include <compiz_mock/core/screen.h>
-
-#endif

=== removed file 'tests/test-gestures/compiz_mock/core/screen.h'
--- tests/test-gestures/compiz_mock/core/screen.h	2012-07-27 20:20:29 +0000
+++ tests/test-gestures/compiz_mock/core/screen.h	1970-01-01 00:00:00 +0000
@@ -1,77 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#ifndef COMPIZ_SCREEN_MOCK_H
-#define COMPIZ_SCREEN_MOCK_H
-
-#include <X11/Xlib.h>
-#include <vector>
-
-// The real CompScreen
-#include <core/screen.h>
-
-typedef std::vector<CompWindowMock*> CompWindowMockVector;
-
-class CompScreenMock {
-public:
-  CompScreenMock() : grab_count_(0), next_grab_handle_(1) {}
-
-  typedef int GrabHandle;
-
-  int width() const {return width_;}
-  int height() const {return height_;}
-
-  Display *dpy() {return dpy_;}
-
-  const CompWindowMockVector & clientList(bool stackingOrder = true) {
-    if (stackingOrder)
-      return client_list_stacking_;
-    else
-      return client_list_;
-  }
-
-  Window root() {return root_;}
-
-  GrabHandle pushGrab(Cursor cursor, const char *name) {
-    grab_count_++;
-    return next_grab_handle_++;
-  }
-  void removeGrab(GrabHandle handle, CompPoint *restorePointer) {
-    grab_count_--;
-  }
-
-  Cursor invisibleCursor() {return 1;}
-
-  int width_;
-  int height_;
-  Display *dpy_;
-  CompWindowMockVector client_list_;
-  CompWindowMockVector client_list_stacking_;
-  Window root_;
-  int grab_count_;
-  int next_grab_handle_;
-};
-
-extern CompScreenMock *screen_mock;
-extern int pointerX_mock;
-extern int pointerY_mock;
-
-#endif
-

=== removed file 'tests/test-gestures/compiz_mock/core/timer.h'
--- tests/test-gestures/compiz_mock/core/timer.h	2012-07-27 20:24:01 +0000
+++ tests/test-gestures/compiz_mock/core/timer.h	1970-01-01 00:00:00 +0000
@@ -1,79 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#ifndef COMPIZ_TIMER_MOCK_H
-#define COMPIZ_TIMER_MOCK_H
-
-#include <boost/function.hpp>
-
-class CompTimerMock
-{
-  public:
-	typedef boost::function<bool ()> CallBack;
-
-  CompTimerMock()
-  {
-    is_running = false;
-    callback = NULL;
-
-    // OBS: no support for more than one simultaneous timer
-    instance = this;
-  }
-
-  virtual ~CompTimerMock()
-  {
-    instance = nullptr;
-  }
-
-	void setCallback (CallBack callback)
-  {
-    this->callback = callback;
-  }
-
-	void setTimes(unsigned int min, unsigned int max = 0)
-  {
-  }
-
-	void start()
-  {
-    is_running = true;
-  }
-
-	void stop()
-  {
-    is_running = false;
-  }
-
-  void ForceTimeout()
-  {
-    if (is_running && callback)
-    {
-      callback();
-      is_running = false;
-    }
-  }
-
-  CallBack callback;
-  bool is_running;
-
-  static CompTimerMock *instance;
-};
-
-#endif // COMPIZ_TIMER_MOCK_H

=== removed file 'tests/test-gestures/compiz_mock/core/window.h'
--- tests/test-gestures/compiz_mock/core/window.h	2012-07-27 20:20:29 +0000
+++ tests/test-gestures/compiz_mock/core/window.h	1970-01-01 00:00:00 +0000
@@ -1,79 +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 General Public License version 3, as published
- * by the  Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 3 along with this program.  If not, see
- * <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- *
- */
-
-#ifndef COMPIZ_WINDOW_MOCK_H
-#define COMPIZ_WINDOW_MOCK_H
-
-/* The real CompWindow */
-#include <core/window.h>
-
-class CompWindowMock
-{
-public:
-  CompWindowMock() : moved_(false), maximize_count_(0), maximize_state_(0),
-                     minimized_(false) {}
-
-  int x() const {return geometry_.x();}
-  int y() const {return geometry_.y();}
-  int width() const {return geometry_.width() + (geometry_.border()*2);}
-  int height() const {return geometry_.height() + (geometry_.border()*2);}
-  int id() { return id_; }
-
-  void move(int dx, int dy, bool immediate = true)
-  {
-    moved_ = true;
-    movement_x_ = dx;
-    movement_y_ = dy;
-  }
-
-  unsigned int actions () {return actions_;}
-
-  bool minimized() { return minimized_; }
-
-  void maximize(int state) {++maximize_count_; maximize_state_ = state;}
-
-  /* OBS: I wonder why it returns a reference */
-  unsigned int &state() {return state_;}
-
-  void grabNotify(int x, int y, unsigned int state, unsigned int mask) {}
-  void ungrabNotify() {}
-
-  void syncPosition() {}
-
-  compiz::window::Geometry &serverGeometry() {return server_geometry_;}
-
-  unsigned int actions_;
-  unsigned int state_;
-  compiz::window::Geometry server_geometry_;
-  compiz::window::Geometry geometry_;
-
-  bool moved_;
-  int movement_x_;
-  int movement_y_;
-
-  int maximize_count_;
-  int maximize_state_;
-
-  int id_;
-
-  bool minimized_;
-};
-
-#endif

=== removed file 'tests/test-gestures/sed_script_broker'
--- tests/test-gestures/sed_script_broker	2012-07-27 20:24:01 +0000
+++ tests/test-gestures/sed_script_broker	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-s|<core/core.h>|<compiz_mock/core/core.h>|
-s|\<CompScreen\>|CompScreenMock|g
-s|\<CompWindow\>|CompWindowMock|g
-s|\<CompWindowVector\>|CompWindowMockVector|g
-s|\<screen\>|screen_mock|g
-s|\<pointerX\>|pointerX_mock|g
-s|\<pointerY\>|pointerY_mock|g
-s|\<XFreeCursor\>|XFreeCursorMock|g
-s|\<XCreateFontCursor\>|XCreateFontCursorMock|g
-s|\<WindowGestureTarget\>|WindowGestureTargetMock|g
-s|\<UnityGestureTarget\>|UnityGestureTargetMock|g
-s|GesturalWindowSwitcher|GesturalWindowSwitcherMock|g

=== removed file 'tests/test-gestures/sed_script_gesture'
--- tests/test-gestures/sed_script_gesture	2012-07-27 20:20:29 +0000
+++ tests/test-gestures/sed_script_gesture	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-s|<core/core.h>|<compiz_mock/core/core.h>|
-s|\<CompScreen\>|CompScreenMock|g
-s|\<CompWindow\>|CompWindowMock|g
-s|\<CompWindowVector\>|CompWindowMockVector|g
-s|\<screen\>|screen_mock|g
-s|\<pointerX\>|pointerX_mock|g
-s|\<pointerY\>|pointerY_mock|g
-s|\<XSync\>|XSyncMock|g
-s|\<XWarpPointer\>|XWarpPointerMock|g
-s|\<XFreeCursor\>|XFreeCursorMock|g
-s|\<XCreateFontCursor\>|XCreateFontCursorMock|g
-s|\<ubus-server.h\>|ubus-server-mock.h|g
-s|\<unityshell.h\>|unityshell_mock.h|g
-s|\<PluginAdapter\>|PluginAdapterMock|g
-s|\<UnityWindow\>|UnityWindowMock|g
-s|\<UnityScreen\>|UnityScreenMock|g
-s|\<InputArea\>|InputAreaMock|g
-s|\<Nux/Nux\.h\>|NuxMock.h|g

=== removed file 'tests/test-gestures/sed_script_switcher'
--- tests/test-gestures/sed_script_switcher	2012-07-27 20:24:01 +0000
+++ tests/test-gestures/sed_script_switcher	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-s|<core/core.h>|<compiz_mock/core/core.h>|
-s|<core/timer.h>|<compiz_mock/core/timer.h>|
-s|\<CompScreen\>|CompScreenMock|g
-s|\<CompWindow\>|CompWindowMock|g
-s|\<CompWindowVector\>|CompWindowMockVector|g
-s|\<screen\>|screen_mock|g
-s|\<pointerX\>|pointerX_mock|g
-s|\<pointerY\>|pointerY_mock|g
-s|\<XSync\>|XSyncMock|g
-s|\<XWarpPointer\>|XWarpPointerMock|g
-s|\<XFreeCursor\>|XFreeCursorMock|g
-s|\<XCreateFontCursor\>|XCreateFontCursorMock|g
-s|\<ubus-server.h\>|ubus-server-mock.h|g
-s|\<unityshell.h\>|unityshell_mock.h|g
-s|\<PluginAdapter\>|PluginAdapterMock|g
-s|\<UnityWindow\>|UnityWindowMock|g
-s|\<UnityScreen\>|UnityScreenMock|g
-s|\<InputArea\>|InputAreaMock|g
-s|\<Nux/Nux\.h\>|NuxMock.h|g
-s|\<CompTimer\>|CompTimerMock|g
-s|\<LauncherController\>|LauncherControllerMock|g
-s|\<SwitcherController\>|SwitcherControllerMock|g
-s|\<switcher\:\:Controller\>|switcher\:\:ControllerMock|g
-s|\<launcher\:\:Controller\>|launcher\:\:ControllerMock|g
-s|\<SwitcherView\>|SwitcherViewMock|g

=== modified file 'tests/test-gestures/test_gestural_window_switcher.cpp'
--- tests/test-gestures/test_gestural_window_switcher.cpp	2012-08-14 12:48:21 +0000
+++ tests/test-gestures/test_gestural_window_switcher.cpp	2012-12-19 14:00:32 +0000
@@ -19,205 +19,327 @@
  * Authored by: Daniel d'Andrada <[e-mail]>
  */
 
+#include <tuple>
+
+#include <glib.h>
+
 #include <gtest/gtest.h>
+#include "MockSwitcherController.h"
+#include "MockSwitcherView.h"
 #include "GesturalWindowSwitcher.h"
 #include "FakeGestureEvent.h"
-#include "unityshell_mock.h"
-#include "compiz_mock/core/timer.h"
 
 using namespace unity;
+namespace us = unity::switcher;
+
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::AtLeast;
+using ::testing::StrictMock;
+using ::testing::_;
+
+class ForcedActionInvoker : public GesturalWindowSwitcherActionInvoker
+{
+  public:
+
+    void SetCallbackToInvoke (const std::function <bool ()> &callback)
+    {
+      callback_  = callback;
+    }
+
+    void InvokeCallbackAndExpectResult (bool expected_result)
+    {
+      ASSERT_TRUE (active_);
+
+      bool result = false;
+      EXPECT_NO_THROW ({
+                         result = callback_ ();
+                       });
+      EXPECT_EQ (expected_result, result);
+
+      if (!result)
+        callback_ = std::function <bool ()> ();
+    }
+
+    void InvokeOnTimeout(int timeout)
+    {
+      active_ = true;
+    }
+
+    void StopPendingInvocation()
+    {
+      active_  = false;
+    }
+
+  private:
+
+    std::function <bool ()> callback_;
+    bool active_;
+};
+
+class MockGesturalWindowSwitcherActionInvoker : public GesturalWindowSwitcherActionInvoker
+{
+  public:
+
+    typedef std::shared_ptr <MockGesturalWindowSwitcherActionInvoker> Ptr;
+
+    MOCK_METHOD1(InvokeOnTimeout, void(int));
+    MOCK_METHOD0(StopPendingInvocation, void());
+
+    MockGesturalWindowSwitcherActionInvoker (ForcedActionInvoker &forced_invoker) :
+      forced_invoker_ (forced_invoker)
+    {
+      ON_CALL (*this, InvokeOnTimeout(_))
+        .WillByDefault(Invoke (&forced_invoker_,
+                               &ForcedActionInvoker::InvokeOnTimeout));
+      ON_CALL (*this, StopPendingInvocation())
+          .WillByDefault(Invoke (&forced_invoker_,
+                                 &ForcedActionInvoker::StopPendingInvocation));
+
+      /* FIXME: Not sure where from though */
+      EXPECT_CALL (*this, StopPendingInvocation()).Times (AtLeast (0));
+    }
+
+    void SetCallbackToInvoke (const std::function <bool ()> &callback)
+    {
+      forced_invoker_.SetCallbackToInvoke(callback);
+    }
+
+  private:
+
+    ForcedActionInvoker &forced_invoker_;
+};
+
+class GesturalWindowSwitcherActionInvokerFactoryMock : public GesturalWindowSwitcherActionInvokerFactory
+{
+  public:
+
+    GesturalWindowSwitcherActionInvokerFactoryMock (const MockGesturalWindowSwitcherActionInvoker::Ptr &mock_invoker) :
+      mock_action_invoker_ (mock_invoker)
+    {
+    }
+
+    GesturalWindowSwitcherActionInvoker::Ptr
+    CreateActionInvoker(const std::function<bool ()> &callback) const
+    {
+      mock_action_invoker_->SetCallbackToInvoke (callback);
+      return mock_action_invoker_;
+    }
+
+  private:
+
+    mutable MockGesturalWindowSwitcherActionInvoker::Ptr mock_action_invoker_;
+};
 
 class GesturalWindowSwitcherTest: public ::testing::Test
 {
- public:
-  virtual void SetUp()
-  {
-    unity_screen = unity::UnityScreenMock::get(screen_mock);
-    unity_screen->Reset();
-
-    fake_event.gesture_id = 0;
-    fake_event.timestamp = 12345; // some arbitrary, big value
-
-    unity_screen->switcher_controller()->view_built.emit();
-  }
-
-  void PerformTap()
-  {
-    fake_event.type = nux::EVENT_GESTURE_BEGIN;
-    fake_event.gesture_id += 1;
-    fake_event.gesture_classes = nux::TOUCH_GESTURE;
-    gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-
-    fake_event.type = nux::EVENT_GESTURE_UPDATE;
-    fake_event.timestamp += 0.2 * CompoundGestureRecognizer::MAX_TAP_TIME;
-    gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-
-    fake_event.type = nux::EVENT_GESTURE_END;
-    fake_event.timestamp += 0.6 * CompoundGestureRecognizer::MAX_TAP_TIME;
-    gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-  }
-
-  void PerformTapAndHold()
-  {
-    PerformTap();
-
-    // Hold
-
-    fake_event.type = nux::EVENT_GESTURE_BEGIN;
-    fake_event.gesture_id += 1;
-    fake_event.timestamp += 0.6 * CompoundGestureRecognizer::MAX_TIME_BETWEEN_GESTURES;
-    gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-
-    fake_event.type = nux::EVENT_GESTURE_UPDATE;
-    fake_event.timestamp += 0.2 * CompoundGestureRecognizer::MAX_TAP_TIME;
-    gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-
-    fake_event.type = nux::EVENT_GESTURE_UPDATE;
-    fake_event.timestamp += 1.0 * CompoundGestureRecognizer::HOLD_TIME;
-    gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-  }
-
-  GesturalWindowSwitcher gestural_switcher;
-  nux::FakeGestureEvent fake_event;
-  unity::UnityScreenMock *unity_screen;
+  public:
+
+    GesturalWindowSwitcherTest ()
+    : mock_action_invoker_ (new MockGesturalWindowSwitcherActionInvoker (forced_action_invoker_))
+    , mock_action_invoker_factory_ (mock_action_invoker_)
+    , mock_switcher_controller (new StrictMock <unity::switcher::MockSwitcherController> ())
+    , mock_switcher_view (new unity::switcher::MockSwitcherView)
+    , switcher_view (new unity::switcher::View ([this](){
+        return unity::switcher::View::ImplPtr(mock_switcher_view);
+      }))
+    , gestural_switcher (std::unique_ptr<unity::switcher::Controller> (new unity::switcher::Controller ([this](){
+                          return std::unique_ptr<unity::switcher::Controller::Impl> (
+                                mock_switcher_controller);
+                         })),
+                         std::bind (&GesturalWindowSwitcherTest::SetupAndShowSwitcher, this),
+                         mock_action_invoker_factory_)
+    {
+      ON_CALL (*mock_switcher_view, ConnectToMouseEvents (_, _, _))
+          .WillByDefault (Invoke (this, &GesturalWindowSwitcherTest::ConnectToMouseEventsDelegate));
+      ON_CALL (*mock_switcher_controller, GetView ()).WillByDefault (Return(switcher_view.get()));
+
+      EXPECT_CALL(*mock_switcher_controller, GetView ()).Times(AtLeast(0));
+    }
+
+    MOCK_METHOD0(SetupAndShowSwitcher, void());
+
+    virtual void SetUp()
+    {
+      fake_event.gesture_id = 0;
+      fake_event.timestamp = 12345; // some arbitrary, big value
+
+      // Expect a call to ConnectToMouseEvents
+      EXPECT_CALL (*mock_switcher_view, ConnectToMouseEvents (_, _, _));
+      mock_switcher_controller->view_built.emit();
+    }
+
+    void PerformTap()
+    {
+      fake_event.type = nux::EVENT_GESTURE_BEGIN;
+      fake_event.gesture_id += 1;
+      fake_event.gesture_classes = nux::TOUCH_GESTURE;
+      gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
+
+      fake_event.type = nux::EVENT_GESTURE_UPDATE;
+      fake_event.timestamp += 0.2 * CompoundGestureRecognizer::MAX_TAP_TIME;
+      gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
+
+      fake_event.type = nux::EVENT_GESTURE_END;
+      fake_event.timestamp += 0.6 * CompoundGestureRecognizer::MAX_TAP_TIME;
+      gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
+    }
+
+    void PerformTapAndHold()
+    {
+      PerformTap();
+
+      // Hold
+
+      fake_event.type = nux::EVENT_GESTURE_BEGIN;
+      fake_event.gesture_id += 1;
+      fake_event.timestamp += 0.6 * CompoundGestureRecognizer::MAX_TIME_BETWEEN_GESTURES;
+      gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
+
+      fake_event.type = nux::EVENT_GESTURE_UPDATE;
+      fake_event.timestamp += 0.2 * CompoundGestureRecognizer::MAX_TAP_TIME;
+      gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
+
+      fake_event.type = nux::EVENT_GESTURE_UPDATE;
+      fake_event.timestamp += 1.0 * CompoundGestureRecognizer::HOLD_TIME;
+      gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
+    }
+
+    us::View::MouseEventConnections
+    ConnectToMouseEventsDelegate (const us::View::MouseButtonCallback &mouse_down_f,
+                                  const us::View::MouseButtonCallback &mouse_up_f,
+                                  const us::View::MouseDragCallback &mouse_drag_f)
+    {
+      return std::make_tuple (mouse_down.connect (mouse_down_f),
+                              mouse_up.connect (mouse_up_f),
+                              mouse_drag.connect (mouse_drag_f));
+    }
+
+    ForcedActionInvoker forced_action_invoker_;
+    MockGesturalWindowSwitcherActionInvoker::Ptr mock_action_invoker_;
+    GesturalWindowSwitcherActionInvokerFactoryMock mock_action_invoker_factory_;
+    unity::switcher::MockSwitcherController        *mock_switcher_controller;
+
+    /* MockSwitcherView is owned by switcher_view */
+    unity::switcher::MockSwitcherView              *mock_switcher_view;
+    unity::switcher::View::Ptr                     switcher_view;
+    GesturalWindowSwitcherImpl gestural_switcher;
+    nux::FakeGestureEvent fake_event;
+
+    sigc::signal<void, int, int, unsigned long, unsigned long> mouse_down;
+    sigc::signal<void, int, int, unsigned long, unsigned long> mouse_up;
+    sigc::signal<void, int, int, int, int, unsigned long, unsigned long> mouse_drag;
+
 };
 
 TEST_F(GesturalWindowSwitcherTest, DoubleTapSwitchesWindow)
 {
+  EXPECT_CALL(*mock_action_invoker_, InvokeOnTimeout (GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_DOUBLE_TAP));
+
+  // Show the switcher
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(false));
+  EXPECT_CALL(*this, SetupAndShowSwitcher());
+
   PerformTap();
   fake_event.timestamp += 0.6 * CompoundGestureRecognizer::MAX_TIME_BETWEEN_GESTURES;
   PerformTap();
 
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Hide the switcher
+  EXPECT_CALL(*mock_switcher_controller, Hide (true));
 
   // simulate that enough time has passed
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_FALSE(unity_screen->switcher_controller()->is_visible_);
+  forced_action_invoker_.InvokeCallbackAndExpectResult(false);
 }
 
 TEST_F(GesturalWindowSwitcherTest, TapAndHoldShowsSwitcher)
 {
+  // Show the switcher
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(false));
+  EXPECT_CALL(*this, SetupAndShowSwitcher());
+
   PerformTapAndHold();
 
-  // switcher should show up
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
-
-  // simulate that enough idle time has passed
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  // nothing should change
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  EXPECT_CALL (*mock_action_invoker_,
+               InvokeOnTimeout (GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_HOLD_RELEASED));
 
   // lift fingers. End hold.
   fake_event.type = nux::EVENT_GESTURE_END;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
+
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
-  // nothing should change
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // switcher will be closed
+  EXPECT_CALL(*mock_switcher_controller, Hide (true));
 
   // simulate that enough idle time has passed
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  // switcher should finally be closed
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_FALSE(unity_screen->switcher_controller()->is_visible_);
+  forced_action_invoker_.InvokeCallbackAndExpectResult(false);
 }
 
 TEST_F(GesturalWindowSwitcherTest, TapAndHoldAndDragSelectsNextWindow)
 {
+  // Show the switcher
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(false));
+  EXPECT_CALL(*this, SetupAndShowSwitcher());
+
   PerformTapAndHold();
 
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Expect a call to Next ()
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(true));
+  EXPECT_CALL (*mock_switcher_controller, Next ());
 
   // Drag far enough to the right.
   fake_event.type = nux::EVENT_GESTURE_UPDATE;
   fake_event.gesture_classes = nux::TOUCH_GESTURE | nux::DRAG_GESTURE;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
-  fake_event.delta.x = 0.6 * GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION;
+  fake_event.delta.x = 0.6 * GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
-  fake_event.delta.x = 0.6 * GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION;
+  fake_event.delta.x = 0.6 * GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
-  // Selection should have jumped to the next window
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Expect a call to Prev ()
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(true));
+  EXPECT_CALL (*mock_switcher_controller, Prev ());
 
   // Drag far enough to the left.
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
-  fake_event.delta.x = -0.6 * GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION;
+  fake_event.delta.x = -0.6 * GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
-  fake_event.delta.x = -0.6 * GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION;
+  fake_event.delta.x = -0.6 * GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
-  // Selection should have jumped to the previous window
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Expect a call to Hide ()
+  EXPECT_CALL (*mock_switcher_controller, Hide (true));
 
   // End gesture
   fake_event.type = nux::EVENT_GESTURE_END;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-
-  // Switcher should have been closed at once
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_FALSE(unity_screen->switcher_controller()->is_visible_);
 }
 
 TEST_F(GesturalWindowSwitcherTest, NewDragAfterTapAndHoldSelectsNextWindow)
 {
+  // Show the switcher
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(false));
+  EXPECT_CALL(*this, SetupAndShowSwitcher());
+
   PerformTapAndHold();
 
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  EXPECT_CALL (*mock_action_invoker_,
+               InvokeOnTimeout (GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_HOLD_RELEASED));
 
   // End hold gesture
   fake_event.type = nux::EVENT_GESTURE_END;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
+  // Expect a call to Next ()
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(true));
+  EXPECT_CALL (*mock_switcher_controller, Next ());
+
   // Start a new gesture and drag far enough to the right.
 
   fake_event.type = nux::EVENT_GESTURE_BEGIN;
@@ -229,95 +351,87 @@
   fake_event.type = nux::EVENT_GESTURE_UPDATE;
   fake_event.gesture_classes |= nux::DRAG_GESTURE;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
-  fake_event.delta.x = 0.6 * GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION;
+  fake_event.delta.x = 0.6 * GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
-  fake_event.delta.x = 0.6 * GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION;
+  fake_event.delta.x = 0.6 * GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Expect a call to Hide ()
+  EXPECT_CALL (*mock_switcher_controller, Hide (true));
 
   fake_event.type = nux::EVENT_GESTURE_END;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
-
-  // switcher should have been closed
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(1, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_FALSE(unity_screen->switcher_controller()->is_visible_);
 }
 
 TEST_F(GesturalWindowSwitcherTest, ClickAfterTapAndHoldSelectsWindow)
 {
+  // Show the switcher
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(false));
+  EXPECT_CALL(*this, SetupAndShowSwitcher());
+
   PerformTapAndHold();
 
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
+  const int x_click = 12;
+  const int y_click = 23;
+  const int index = 2;
 
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Expect a call to Select () with index
+  EXPECT_CALL (*mock_switcher_view, IconIndexAt (x_click, y_click))
+      .WillOnce (Return (index));
+  EXPECT_CALL (*mock_switcher_controller, Select (index));
+  EXPECT_CALL (*mock_action_invoker_, InvokeOnTimeout (GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_HOLD_RELEASED));
 
   // lift fingers. End hold.
   fake_event.type = nux::EVENT_GESTURE_END;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;
   gestural_switcher.GestureEvent(fake_event.ToGestureEvent());
 
+  EXPECT_CALL (*mock_action_invoker_, InvokeOnTimeout (GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_DOUBLE_TAP));
+
   // click on position (12, 23)
-  unity_screen->switcher_controller()->view_.mouse_down.emit(12, 23, 0, 0);
-  unity_screen->switcher_controller()->view_.mouse_up.emit(12, 23, 0, 0);
+  mouse_down.emit(x_click, y_click, 0, 0);
+  mouse_up.emit(x_click, y_click, 0, 0);
 
-  // Should have selected the icon index corresponding to the
-  // position clicked.
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
-  ASSERT_EQ(12*23, unity_screen->switcher_controller()->index_selected_);
+  // Expect the switcher to close
+  EXPECT_CALL (*mock_switcher_controller, Hide (true));
 
   // simulate that enough time has passed
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  ASSERT_FALSE(unity_screen->switcher_controller()->is_visible_);
+  forced_action_invoker_.InvokeCallbackAndExpectResult(false);
 }
 
 TEST_F(GesturalWindowSwitcherTest, MouseDragAfterTapAndHoldSelectsNextWindow)
 {
-  unity::switcher::SwitcherViewMock &switcher_view =
-    unity_screen->switcher_controller()->view_;
-  int drag_delta = GesturalWindowSwitcher::DRAG_DELTA_FOR_CHANGING_SELECTION * 1.5f;
+  int drag_delta = GesturalWindowSwitcherImpl::DRAG_DELTA_FOR_CHANGING_SELECTION * 1.5f;
+
+  // Show the switcher
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(false));
+  EXPECT_CALL(*this, SetupAndShowSwitcher());
 
   PerformTapAndHold();
 
-  if (CompTimerMock::instance)
-    CompTimerMock::instance->ForceTimeout();
-
-  ASSERT_EQ(1, unity_screen->SetUpAndShowSwitcher_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->next_count_);
-  ASSERT_EQ(0, unity_screen->switcher_controller()->prev_count_);
-  ASSERT_TRUE(unity_screen->switcher_controller()->is_visible_);
+  // Expect a call to Next () and then Hide ()
+  EXPECT_CALL(*mock_switcher_controller, Visible ()).WillOnce (Return(true));
+  EXPECT_CALL (*mock_action_invoker_, InvokeOnTimeout (GesturalWindowSwitcherImpl::SWITCHER_TIME_AFTER_HOLD_RELEASED));
 
   // lift fingers. End hold.
   fake_event.type = nux::EVENT_GESTURE_END;
   fake_event.timestamp += 0.1 * CompoundGestureRecognizer::HOLD_TIME;