Merge lp:~3v1n0/unity/spread-launcher-desaturate into lp:unity

[Marco Trevisan (Treviño)]

Launcher: desaturate the inactive icons when in Spread mode

Desaturate the Launcher and hide tooltips when spread is initiated as designed.

Added unit and autopilot tests.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3577
http://jenkins.qa.ubuntu.com/job/unity-ci/438/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/327/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/325/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/326/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/438/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3578
http://jenkins.qa.ubuntu.com/job/unity-ci/439/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/328/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/326/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/327/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/439/rebuild

review: Needs Fixing (continuous-integration)

[Christopher Townsend (townsend)]

Seems Jenkins CI is segfaulting:

[ RUN ] TestLauncher.DesaturateAllIconsOnSpread
Segmentation fault

I don't see that locally:(

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3578
http://jenkins.qa.ubuntu.com/job/unity-ci/440/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/329/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/327/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/328/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/440/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3582
http://jenkins.qa.ubuntu.com/job/unity-ci/441/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/331/console
    None: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/328/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/329/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/441/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3584
http://jenkins.qa.ubuntu.com/job/unity-ci/442/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/332
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/329
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/330

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/442/rebuild

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

LGTM

review: Approve

[Brandon Schaefer (brandontschaefer)]

Still looks good!

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'dash/DashController.h'
--- dash/DashController.h	2013-10-03 13:18:57 +0000
+++ dash/DashController.h	2013-10-21 23:51:09 +0000
@@ -41,7 +41,7 @@
 namespace dash
 {
 
-class Controller : public unity::debug::Introspectable
+class Controller : public unity::debug::Introspectable, public sigc::trackable
 {
 public:
   typedef std::shared_ptr<Controller> Ptr;

=== modified file 'hud/HudController.h'
--- hud/HudController.h	2013-10-16 03:42:03 +0000
+++ hud/HudController.h	2013-10-21 23:51:09 +0000
@@ -40,7 +40,7 @@
 namespace hud
 {
 
-class Controller : public unity::debug::Introspectable
+class Controller : public unity::debug::Introspectable, public sigc::trackable
 {
 public:
   typedef std::shared_ptr<Controller> Ptr;

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2013-10-04 03:55:52 +0000
+++ launcher/Launcher.cpp	2013-10-21 23:51:09 +0000
@@ -94,6 +94,7 @@
 const std::string START_DRAGICON_TIMEOUT = "start-dragicon-timeout";
 const std::string SCROLL_TIMEOUT = "scroll-timeout";
 const std::string ANIMATION_IDLE = "animation-idle";
+const std::string SCALE_DESATURATE_IDLE = "scale-desaturate-idle";
 const std::string URGENT_TIMEOUT = "urgent-timeout";
 }
 
@@ -173,9 +174,9 @@
   ql_manager.quicklist_closed.connect(sigc::mem_fun(this, &Launcher::RecvQuicklistClosed));
 
   WindowManager& wm = WindowManager::Default();
-  wm.initiate_spread.connect(sigc::mem_fun(this, &Launcher::OnPluginStateChanged));
+  wm.initiate_spread.connect(sigc::mem_fun(this, &Launcher::OnSpreadChanged));
+  wm.terminate_spread.connect(sigc::mem_fun(this, &Launcher::OnSpreadChanged));
   wm.initiate_expo.connect(sigc::mem_fun(this, &Launcher::OnPluginStateChanged));
-  wm.terminate_spread.connect(sigc::mem_fun(this, &Launcher::OnPluginStateChanged));
   wm.terminate_expo.connect(sigc::mem_fun(this, &Launcher::OnPluginStateChanged));
   wm.screen_viewport_switch_ended.connect(sigc::mem_fun(this, &Launcher::QueueDraw));
 
@@ -1125,23 +1126,30 @@
   }
 }
 
+// FIXME: add monitor-aware quirks!
 void Launcher::DesaturateIcons()
 {
-  for (auto icon : *model_)
+  bool inactive_only = WindowManager::Default().IsScaleActiveForGroup();
+
+  for (auto const& icon : *model_)
   {
+    bool desaturate = false;
+
     if (icon->GetIconType () != AbstractLauncherIcon::IconType::HOME &&
-        icon->GetIconType () != AbstractLauncherIcon::IconType::HUD)
+        icon->GetIconType () != AbstractLauncherIcon::IconType::HUD &&
+        (!inactive_only || !icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE)))
     {
-      icon->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, true);
+      desaturate = true;
     }
 
+    icon->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, desaturate);
     icon->HideTooltip();
   }
 }
 
 void Launcher::SaturateIcons()
 {
-  for (auto icon : *model_)
+  for (auto const& icon : *model_)
   {
     icon->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, false);
   }
@@ -1243,7 +1251,7 @@
 
 bool Launcher::IsOverlayOpen() const
 {
-  return dash_is_open_ || hud_is_open_;
+  return dash_is_open_ || hud_is_open_ || WindowManager::Default().IsScaleActive();
 }
 
 void Launcher::SetHidden(bool hide_launcher)
@@ -1303,8 +1311,34 @@
 void Launcher::OnPluginStateChanged()
 {
   WindowManager& wm = WindowManager::Default();
-  hide_machine_.SetQuirk(LauncherHideMachine::EXPO_ACTIVE, wm.IsExpoActive());
-  hide_machine_.SetQuirk(LauncherHideMachine::SCALE_ACTIVE, wm.IsScaleActive());
+  bool expo_active = wm.IsExpoActive();
+  hide_machine_.SetQuirk(LauncherHideMachine::EXPO_ACTIVE, expo_active);
+
+  if (expo_active && icon_under_mouse_)
+    icon_under_mouse_->HideTooltip();
+}
+
+void Launcher::OnSpreadChanged()
+{
+  WindowManager& wm = WindowManager::Default();
+  bool active = wm.IsScaleActive();
+  hide_machine_.SetQuirk(LauncherHideMachine::SCALE_ACTIVE, active);
+
+  bg_effect_helper_.enabled = active;
+
+  if (active && icon_under_mouse_)
+    icon_under_mouse_->HideTooltip();
+
+  if (active && (!hovered_ || wm.IsScaleActiveForGroup()))
+  {
+    // The icons can take some ms to update their active state, this can protect us.
+    sources_.AddIdle([this] { DesaturateIcons(); return false; }, SCALE_DESATURATE_IDLE);
+  }
+  else
+  {
+    sources_.Remove(SCALE_DESATURATE_IDLE);
+    SaturateIcons();
+  }
 }
 
 LauncherHideMode Launcher::GetHideMode() const
@@ -2231,6 +2265,13 @@
   if (!hidden_)
     UpdateChangeInMousePosition(dx, dy);
 
+  if (WindowManager::Default().IsScaleActiveForGroup())
+  {
+    auto icon = MouseIconIntersection(x, y);
+    if (icon && !icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE))
+      SaturateIcons();
+  }
+
   // Every time the mouse moves, we check if it is inside an icon...
   EventLogic();
 

=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2013-09-30 15:08:09 +0000
+++ launcher/Launcher.h	2013-10-21 23:51:09 +0000
@@ -200,6 +200,7 @@
 #endif
 
   void OnPluginStateChanged();
+  void OnSpreadChanged();
 
   void OnSelectionChanged(AbstractLauncherIcon::Ptr const& selection);
 

=== modified file 'tests/autopilot/unity/tests/test_spread.py'
--- tests/autopilot/unity/tests/test_spread.py	2013-10-08 14:08:52 +0000
+++ tests/autopilot/unity/tests/test_spread.py	2013-10-21 23:51:09 +0000
@@ -8,9 +8,11 @@
 
 from __future__ import absolute_import
 
+from autopilot.display import Display
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals, NotEquals
 from time import sleep
+from unity.emulators.icons import BFBLauncherIcon
 
 from unity.tests import UnityTestCase
 
@@ -18,6 +20,10 @@
 class SpreadTests(UnityTestCase):
     """Spread tests"""
 
+    def setUp(self):
+        super(SpreadTests, self).setUp()
+        self.launcher = self.unity.launcher.get_launcher_for_monitor(self.display.get_primary_screen())
+
     def start_test_application_windows(self, app_name, num_windows=2):
         """Start a given number of windows of the requested application"""
         self.process_manager.close_all_app(app_name)
@@ -44,10 +50,9 @@
         """Initiate the Spread for windows of the given app"""
         icon = self.unity.launcher.model.get_icon(desktop_id=desktop_id)
         self.assertThat(icon, NotEquals(None))
-        launcher = self.unity.launcher.get_launcher_for_monitor(self.display.get_primary_screen())
 
         self.addCleanup(self.unity.window_manager.terminate_spread)
-        launcher.click_launcher_icon(icon)
+        self.launcher.click_launcher_icon(icon, move_mouse_after=False)
         self.assertThat(self.unity.window_manager.scale_active_for_group, Eventually(Equals(True)))
 
     def assertWindowIsNotScaled(self, window):
@@ -60,6 +65,17 @@
         refresh_fn = lambda: xid in [w.x_id for w in self.process_manager.get_open_windows()]
         self.assertThat(refresh_fn, Eventually(Equals(False)))
 
+    def assertLauncherIconsSaturated(self):
+        for icon in self.unity.launcher.model.get_launcher_icons():
+            self.assertThat(icon.desaturated, Eventually(Equals(False)))
+
+    def assertLauncherIconsDesaturated(self, also_active=True):
+        for icon in self.unity.launcher.model.get_launcher_icons():
+            if isinstance(icon, BFBLauncherIcon) or (not also_active and icon.active):
+                self.assertThat(icon.desaturated, Eventually(Equals(False)))
+            else:
+                self.assertThat(icon.desaturated, Eventually(Equals(True)))
+
     def test_scale_application_windows(self):
         """All the windows of an application must be scaled when application
         spread is initiated
@@ -120,3 +136,57 @@
 
         self.assertWindowIsNotScaled(target_win)
         self.assertWindowIsClosed(target_xid)
+
+    def test_spread_desaturate_launcher_icons(self):
+        """Test that the screen spread desaturates the launcher icons"""
+        self.start_test_application_windows("Calculator", 1)
+        self.initiate_spread_for_screen()
+        self.launcher.move_mouse_to_right_of_launcher()
+        self.assertLauncherIconsDesaturated()
+
+    def test_spread_saturate_launcher_icons_on_mouse_over(self):
+        """Test that the screen spread re-saturates the launcher icons on mouse over"""
+        win = self.start_test_application_windows("Calculator", 2)[0]
+        self.initiate_spread_for_application(win.application.desktop_file)
+        self.launcher.move_mouse_over_launcher()
+        self.assertLauncherIconsSaturated()
+
+    def test_app_spread_desaturate_inactive_launcher_icons(self):
+        """Test that the app spread desaturates the inactive launcher icons"""
+        win = self.start_test_application_windows("Calculator", 2)[0]
+        self.initiate_spread_for_application(win.application.desktop_file)
+        self.assertLauncherIconsDesaturated(also_active=False)
+
+    def test_app_spread_saturate_launcher_icons_on_mouse_move(self):
+        """Test that the app spread re-saturates the launcher icons on mouse move"""
+        win = self.start_test_application_windows("Calculator", 2)[0]
+        self.initiate_spread_for_application(win.application.desktop_file)
+        self.launcher.move_mouse_to_icon(self.unity.launcher.model.get_bfb_icon())
+        self.assertLauncherIconsSaturated()
+
+    def test_app_spread_saturate_launcher_icons_on_mouse_over(self):
+        """Test that the app spread re-saturates the launcher icons on mouse over"""
+        win = self.start_test_application_windows("Calculator", 2)[0]
+        self.initiate_spread_for_application(win.application.desktop_file)
+        self.launcher.move_mouse_over_launcher()
+        self.assertLauncherIconsSaturated()
+
+    def test_app_spread_desaturate_launcher_icons_switching_application(self):
+        """Test that the app spread desaturates the launcher icons on mouse over"""
+        cal_win = self.start_test_application_windows("Calculator", 2)[0]
+        char_win = self.start_test_application_windows("Character Map", 2)[0]
+        self.initiate_spread_for_application(char_win.application.desktop_file)
+        self.initiate_spread_for_application(cal_win.application.desktop_file)
+        self.assertLauncherIconsDesaturated(also_active=False)
+
+    def test_spread_hides_icon_tooltip(self):
+        """Tests that the screen spread hides the active tooltip."""
+        [win] = self.start_test_application_windows("Calculator", 1)
+        icon = self.unity.launcher.model.get_icon(desktop_id=win.application.desktop_file)
+        self.mouse.move(icon.center_x, icon.center_y)
+
+        self.assertThat(lambda: icon.get_tooltip(), Eventually(NotEquals(None)))
+        self.assertThat(icon.get_tooltip().active, Eventually(Equals(True)))
+
+        self.initiate_spread_for_screen()
+        self.assertThat(icon.get_tooltip().active, Eventually(Equals(False)))
\ No newline at end of file

=== modified file 'tests/mock-base-window.h'
--- tests/mock-base-window.h	2013-02-07 16:55:11 +0000
+++ tests/mock-base-window.h	2013-10-21 23:51:09 +0000
@@ -16,6 +16,7 @@
 #ifndef TESTS_MOCK_BASEWINDOW_H
 #define TESTS_MOCK_BASEWINDOW_H
 
+#include <gmock/gmock.h>
 #include "ResizingBaseWindow.h"
 
 namespace unity
@@ -23,25 +24,26 @@
 namespace testmocks
 {
 
+using namespace testing;
+
 class MockBaseWindow : public ResizingBaseWindow
 {
 public:
   typedef nux::ObjectPtr<MockBaseWindow> Ptr;
+  typedef NiceMock<MockBaseWindow> Nice;
 
   MockBaseWindow(ResizingBaseWindow::GeometryAdjuster const& input_adjustment, const char *name = "Mock")
   	: ResizingBaseWindow(name, input_adjustment)
-  {}
+  {
+    ON_CALL(*this, SetOpacity(_)).WillByDefault(Invoke([this] (float o) { ResizingBaseWindow::SetOpacity(o); }));
+  }
 
   MockBaseWindow(const char *name = "Mock")
-  	: ResizingBaseWindow(name, [](nux::Geometry const& geo) { return geo; })
+  	: MockBaseWindow([](nux::Geometry const& geo) { return geo; }, name)
   {}
 
   MOCK_METHOD2(ShowWindow, void(bool, bool));
   MOCK_METHOD1(SetOpacity, void(float));
-
-  // Really invoke the SetOpacity member function, a callthrough for use with
-  // ::testing::Invoke().
-  void RealSetOpacity(float opacity) { ResizingBaseWindow::SetOpacity(opacity); }
 };
 
 } // namespace testmocks

=== modified file 'tests/test_dash_controller.cpp'
--- tests/test_dash_controller.cpp	2013-02-07 16:56:07 +0000
+++ tests/test_dash_controller.cpp	2013-10-21 23:51:09 +0000
@@ -21,6 +21,7 @@
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UnitySettings.h"
+#include "unity-shared/WindowManager.h"
 #include "test_utils.h"
 
 #include <NuxCore/AnimationController.h>
@@ -32,42 +33,32 @@
 namespace
 {
 
-class TestDashController : public Test
+struct TestDashController : Test
 {
-public:
   TestDashController()
     : animation_controller(tick_source)
-    , base_window_(new NiceMock<testmocks::MockBaseWindow>())
-  { }
-
-  virtual void SetUp()
-  {
-    ON_CALL(*base_window_, SetOpacity(_))
-      .WillByDefault(Invoke(base_window_.GetPointer(),
-                     &testmocks::MockBaseWindow::RealSetOpacity));
-
-    // Set expectations for creating the controller
-    EXPECT_CALL(*base_window_, SetOpacity(0.0f))
-      .WillOnce(Invoke(base_window_.GetPointer(),
-                       &testmocks::MockBaseWindow::RealSetOpacity));
-
-    controller_.reset(new dash::Controller([&](){ return base_window_.GetPointer();}));
-    Mock::VerifyAndClearExpectations(base_window_.GetPointer());
-  }
+    , base_window_(new testmocks::MockBaseWindow::Nice())
+    , controller_(std::make_shared<dash::Controller>([this] { return base_window_.GetPointer(); }))
+  {}
 
 protected:
   nux::animation::TickSource tick_source;
   nux::animation::AnimationController animation_controller;
 
-  dash::Controller::Ptr controller_;
-  testmocks::MockBaseWindow::Ptr base_window_;
-
   // required to create hidden secret global variables
   Settings unity_settings_;
   dash::Style dash_style_;
   panel::Style panel_style_;
+
+  testmocks::MockBaseWindow::Ptr base_window_;
+  dash::Controller::Ptr controller_;
 };
 
+TEST_F(TestDashController, Construction)
+{
+  EXPECT_CALL(*base_window_, SetOpacity(0.0f));
+  controller_ = std::make_shared<dash::Controller>([this] { return base_window_.GetPointer(); });
+}
 
 TEST_F(TestDashController, TestShowAndHideDash)
 {
@@ -100,5 +91,13 @@
   EXPECT_EQ(base_window_->GetOpacity(), 0.0);
 }
 
+TEST_F(TestDashController, DisconnectWMSignalsOnDestruction)
+{
+  auto& signal = WindowManager::Default().initiate_spread;
+  size_t before = signal.size();
+  { auto controller = std::make_shared<dash::Controller>([this] { return base_window_.GetPointer(); }); }
+  ASSERT_EQ(before, signal.size());
+  signal.emit();
 }
 
+}

=== modified file 'tests/test_hud_controller.cpp'
--- tests/test_hud_controller.cpp	2013-02-19 15:07:36 +0000
+++ tests/test_hud_controller.cpp	2013-10-21 23:51:09 +0000
@@ -28,6 +28,7 @@
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UnitySettings.h"
+#include "unity-shared/WindowManager.h"
 #include "test_utils.h"
 using namespace unity;
 
@@ -62,35 +63,32 @@
 };
 
 
-class TestHudController : public Test
+struct TestHudController : Test
 {
-public:
   TestHudController()
-  : view_(new NiceMock<MockHudView>)
-  , base_window_(new NiceMock<testmocks::MockBaseWindow>())
-  {
-    ON_CALL(*base_window_, SetOpacity(_))
-      .WillByDefault(Invoke(base_window_.GetPointer(),
-                     &testmocks::MockBaseWindow::RealSetOpacity));
-
-    // Set expectations for creating the controller
-    EXPECT_CALL(*base_window_, SetOpacity(0.0f));
-
-    controller_.reset(new hud::Controller([&](){ return view_.GetPointer(); },
-                                          [&](){ return base_window_.GetPointer();}));
-  }
+    : view_(new NiceMock<MockHudView>)
+    , base_window_(new testmocks::MockBaseWindow::Nice())
+    , controller_(std::make_shared<hud::Controller>([this] { return view_.GetPointer(); },
+                                                    [this] { return base_window_.GetPointer(); }))
+  {}
 
 protected:
-  hud::Controller::Ptr controller_;
-  MockHudView::Ptr view_;
-  testmocks::MockBaseWindow::Ptr base_window_;
-
   // required to create hidden secret global variables
   Settings unity_settings_;
   dash::Style dash_style_;
   panel::Style panel_style_;
+
+  MockHudView::Ptr view_;
+  testmocks::MockBaseWindow::Ptr base_window_;
+  hud::Controller::Ptr controller_;
 };
 
+TEST_F(TestHudController, Construction)
+{
+  EXPECT_CALL(*base_window_, SetOpacity(0.0f));
+  controller_ = std::make_shared<hud::Controller>([this] { return view_.GetPointer(); },
+                                                  [this] { return base_window_.GetPointer(); });
+}
 
 TEST_F(TestHudController, TestShowAndHideHud)
 {
@@ -141,4 +139,16 @@
   EXPECT_EQ(base_window_->GetOpacity(), 0.0);
 }
 
+TEST_F(TestHudController, DisconnectWMSignalsOnDestruction)
+{
+  auto& signal = WindowManager::Default().initiate_spread;
+  size_t before = signal.size();
+  {
+    auto controller = std::make_shared<hud::Controller>([this] { return view_.GetPointer(); },
+                                                        [this] { return base_window_.GetPointer(); });
+  }
+  ASSERT_EQ(before, signal.size());
+  signal.emit();
+}
+
 }

=== modified file 'tests/test_launcher.cpp'
--- tests/test_launcher.cpp	2013-10-04 00:19:56 +0000
+++ tests/test_launcher.cpp	2013-10-21 23:51:09 +0000
@@ -31,6 +31,7 @@
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UnitySettings.h"
 #include "unity-shared/IconRenderer.h"
+#include "StandaloneWindowManager.h"
 #include "test_utils.h"
 
 namespace unity
@@ -46,6 +47,7 @@
 {
 public:
   typedef nux::ObjectPtr<MockMockLauncherIcon> Ptr;
+  typedef testing::NiceMock<MockMockLauncherIcon> Nice;
   MockMockLauncherIcon(IconType type = IconType::APPLICATION)
     : MockLauncherIcon(type)
   {}
@@ -53,6 +55,7 @@
   MOCK_METHOD1(ShouldHighlightOnDrag, bool(DndData const&));
   MOCK_METHOD1(Stick, void(bool));
   MOCK_METHOD2(PerformScroll, void(ScrollDirection, Time));
+  MOCK_METHOD0(HideTooltip, void());
 };
 
 }
@@ -115,6 +118,7 @@
     using Launcher::SetHidden;
     using Launcher::HandleUrgentIcon;
     using Launcher::SetUrgentTimer;
+    using Launcher::SetIconUnderMouse;
     using Launcher::urgent_timer_running_;
     using Launcher::urgent_finished_time_;
     using Launcher::urgent_wiggle_time_;
@@ -140,7 +144,8 @@
   };
 
   TestLauncher()
-    : parent_window_(new MockableBaseWindow("TestLauncherWindow"))
+    : WM(dynamic_cast<StandaloneWindowManager*>(&WindowManager::Default()))
+    , parent_window_(new MockableBaseWindow("TestLauncherWindow"))
     , model_(new LauncherModel)
     , options_(new Options)
     , launcher_(new MockLauncher(parent_window_.GetPointer()))
@@ -149,6 +154,15 @@
     launcher_->SetModel(model_);
   }
 
+  ~TestLauncher()
+  {
+    WM->SetScaleActiveForGroup(false);
+    WM->SetScaleActive(false);
+
+    if (WM->IsExpoActive())
+      WM->TerminateExpo();
+  }
+
   std::vector<MockMockLauncherIcon::Ptr> AddMockIcons(unsigned number)
   {
     std::vector<MockMockLauncherIcon::Ptr> icons;
@@ -159,7 +173,7 @@
 
     for (unsigned i = 0; i < number; ++i)
     {
-      MockMockLauncherIcon::Ptr icon(new MockMockLauncherIcon);
+      MockMockLauncherIcon::Ptr icon(new MockMockLauncherIcon::Nice);
       icon->SetCenter(nux::Point3(launcher_geo.x + icon_size/2.0f, launcher_geo.y + icon_size/2.0f * (i+1) + 1, 0), monitor);
 
       icons.push_back(icon);
@@ -173,6 +187,7 @@
   }
 
   MockUScreen uscreen;
+  StandaloneWindowManager* WM;
   nux::ObjectPtr<MockableBaseWindow> parent_window_;
   Settings settings;
   panel::Style panel_style;
@@ -688,9 +703,180 @@
   launcher_->HandleUrgentIcon(icon, current);
 
   EXPECT_THAT(launcher_->urgent_finished_time_.tv_sec, Gt(0));
-  EXPECT_THAT(launcher_->urgent_finished_time_.tv_nsec, Gt(0));  
-}  
-
-}
-}
-
+  EXPECT_THAT(launcher_->urgent_finished_time_.tv_nsec, Gt(0));
+}
+
+TEST_F(TestLauncher, DesaturateAllIconsOnSpread)
+{
+  auto const& icons = AddMockIcons(5);
+  icons[g_random_int()%icons.size()]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  WM->SetScaleActiveForGroup(false);
+  WM->SetScaleActive(true);
+  WM->initiate_spread.emit();
+
+  Utils::WaitUntilMSec([&icons] {
+    for (auto const& icon : icons)
+    {
+      if (!icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT))
+        return false;
+    }
+    return true;
+  });
+
+  for (auto const& icon : icons)
+    ASSERT_TRUE(icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+}
+
+TEST_F(TestLauncher, SaturateAllIconsOnSpreadTerminated)
+{
+  auto const& icons = AddMockIcons(5);
+  icons[g_random_int()%icons.size()]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  for (auto const& icon : icons)
+    icon->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, true);
+
+  WM->SetScaleActiveForGroup(false);
+  WM->SetScaleActive(false);
+  WM->terminate_spread.emit();
+
+  for (auto const& icon : icons)
+    ASSERT_FALSE(icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+}
+
+TEST_F(TestLauncher, SaturatesAllIconsOnSpreadWithMouseOver)
+{
+  auto const& icons = AddMockIcons(5);
+  icons[g_random_int()%icons.size()]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  for (auto const& icon : icons)
+    icon->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, true);
+
+  launcher_->SetHover(true);
+  WM->SetScaleActiveForGroup(false);
+  WM->SetScaleActive(true);
+  WM->initiate_spread.emit();
+
+  Utils::WaitPendingEvents();
+
+  for (auto const& icon : icons)
+    ASSERT_FALSE(icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+}
+
+TEST_F(TestLauncher, DesaturateInactiveIconsOnAppSpread)
+{
+  auto const& icons = AddMockIcons(5);
+  icons[g_random_int()%icons.size()]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  WM->SetScaleActiveForGroup(true);
+  WM->SetScaleActive(true);
+  WM->initiate_spread.emit();
+
+  Utils::WaitUntilMSec([&icons] {
+    for (auto const& icon : icons)
+    {
+      if (icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE) == icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT))
+        return false;
+    }
+    return true;
+  });
+
+  for (auto const& icon : icons)
+    ASSERT_NE(icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE), icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+}
+
+TEST_F(TestLauncher, SaturatesAllIconsOnAppSpreadMouseMove)
+{
+  auto const& icons = AddMockIcons(5);
+  unsigned active_idx = g_random_int()%icons.size();
+  icons[active_idx]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  launcher_->SetHover(true);
+  WM->SetScaleActiveForGroup(true);
+  WM->SetScaleActive(true);
+  WM->initiate_spread.emit();
+
+  Utils::WaitUntilMSec([&icons] {
+    for (auto const& icon : icons)
+    {
+      if (icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE) == icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT))
+        return false;
+    }
+    return true;
+  });
+
+  for (auto const& icon : icons)
+    ASSERT_NE(icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE), icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+
+  auto const& active_center = icons[active_idx]->GetCenter(launcher_->monitor());
+  launcher_->mouse_move.emit(active_center.x, active_center.y, 0, 0, 0, 0);
+
+  for (auto const& icon : icons)
+    ASSERT_NE(icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE), icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+
+  auto const& other_center = icons[(active_idx+1)%icons.size()]->GetCenter(launcher_->monitor());
+  launcher_->mouse_move.emit(other_center.x, other_center.y, 0, 0, 0, 0);
+
+  for (auto const& icon : icons)
+    ASSERT_FALSE(icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+
+  launcher_->SetHover(false);
+  for (auto const& icon : icons)
+    ASSERT_NE(icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE), icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+
+  launcher_->SetHover(true);
+  for (auto const& icon : icons)
+    ASSERT_FALSE(icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+}
+
+TEST_F(TestLauncher, DesaturateActiveIconOnAppSpreadIconUpdate)
+{
+  auto const& icons = AddMockIcons(5);
+  unsigned active_idx = g_random_int()%icons.size();
+  icons[active_idx]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  launcher_->SetHover(true);
+  WM->SetScaleActiveForGroup(true);
+  WM->SetScaleActive(true);
+  WM->initiate_spread.emit();
+
+  Utils::WaitPendingEvents();
+  for (auto const& icon : icons)
+    ASSERT_NE(icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE), icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+
+  unsigned new_active_idx = (active_idx+1)%icons.size();
+  icons[active_idx]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, false);
+  icons[new_active_idx]->SetQuirk(AbstractLauncherIcon::Quirk::ACTIVE, true);
+
+  WM->terminate_spread.emit();
+  WM->initiate_spread.emit();
+
+  Utils::WaitPendingEvents();
+  for (auto const& icon : icons)
+    ASSERT_NE(icon->GetQuirk(AbstractLauncherIcon::Quirk::ACTIVE), icon->GetQuirk(AbstractLauncherIcon::Quirk::DESAT));
+}
+
+TEST_F(TestLauncher, HideTooltipOnSpread)
+{
+  auto icon = AddMockIcons(1).front();
+  EXPECT_CALL(*icon, HideTooltip());
+
+  launcher_->SetIconUnderMouse(icon);
+  WM->SetScaleActive(true);
+  WM->initiate_spread.emit();
+}
+
+TEST_F(TestLauncher, HideTooltipOnExpo)
+{
+  auto icon = AddMockIcons(1).front();
+  EXPECT_CALL(*icon, HideTooltip());
+
+  if (!WM->IsExpoActive())
+    WM->InitiateExpo();
+
+  launcher_->SetIconUnderMouse(icon);
+  WM->initiate_expo.emit();
+}
+
+} // namespace launcher
+} // namespace unity

=== modified file 'tests/test_switcher_controller_class.cpp'
--- tests/test_switcher_controller_class.cpp	2013-06-26 17:10:45 +0000
+++ tests/test_switcher_controller_class.cpp	2013-10-21 23:51:09 +0000
@@ -78,13 +78,8 @@
   : WM(dynamic_cast<StandaloneWindowManager*>(&WindowManager::Default()))
   , animation_controller_(tick_source_)
   , mock_window_(new NiceMock<testmocks::MockBaseWindow>())
+  , controller_(std::make_shared<Controller>([this] { return mock_window_; }))
 {
-  ON_CALL(*mock_window_, SetOpacity(_))
-    .WillByDefault(Invoke(mock_window_.GetPointer(),
-                   &testmocks::MockBaseWindow::RealSetOpacity));
-
-  auto create_window = [this] { return mock_window_; };
-  controller_.reset(new Controller(create_window));
   controller_->timeout_length = 0;
 
   icons_.push_back(launcher::AbstractLauncherIcon::Ptr(new launcher::DesktopLauncherIcon()));