Merge lp:~3v1n0/unity/spread-filter into lp:unity

[Marco Trevisan (Treviño)]

UnityScreen: add a SpreadFilter when in Scale mode, when updated it filters the scale results

The SpreadFilter is a BaseWindow with a SearchBar shown on the top-left corner of the
active workspace that is hidden by default monitoring key-presses; when some content is
written, the bar is shown, while is hidden when empty.

Thanks to this we can finally filter the windows by name in the unity spread!

As defined in the Spread design doc [1]:

Filtering Windows by Title Captions
The user can start typing to filter the windows shown to include only those which contain the search text in their title bar.

So, added a new SpreadFilter class that basically just shows a SearchBar that is hidden unless the user won't type anything useful to filter the spreaded windows.

Design: http://go.3v1n0.net/1eJfQCF
Actual implementation: http://people.ubuntu.com/~3v1n0/Spread-Filter.webm

Tests added, it has a soft-dependency on lp:~3v1n0/compiz/scale-improvements to properly work.

[1] http://go.3v1n0.net/1bFTXd2

[Brandon Schaefer (brandontschaefer)]

Looks very nice :).

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3685
http://jenkins.qa.ubuntu.com/job/unity-ci/644/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/180
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/176
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/178

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

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

LGTM

review: Approve

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2014-02-18 00:59:55 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-02-18 00:59:55 +0000
@@ -137,10 +137,8 @@
 const unsigned int SCROLL_UP_BUTTON = 7;
 const int MAX_BUFFER_AGE = 11;
 const int FRAMES_TO_REDRAW_ON_RESUME = 10;
-
 const std::string RELAYOUT_TIMEOUT = "relayout-timeout";
 } // namespace local
-
 } // anon namespace
 
 UnityScreen::UnityScreen(CompScreen* screen)
@@ -149,6 +147,7 @@
   , screen(screen)
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
+  , sScreen(ScaleScreen::get(screen))
   , menus_(std::make_shared<menu::Manager>(std::make_shared<indicator::DBusIndicators>(), std::make_shared<key::GnomeGrabber>()))
   , deco_manager_(std::make_shared<decoration::Manager>())
   , debugger_(this)
@@ -511,13 +510,28 @@
 
 void UnityScreen::OnInitiateSpread()
 {
-  for (auto const& swin : ScaleScreen::get(screen)->getWindows())
+  spread_filter_ = std::make_shared<spread::Filter>();
+  spread_filter_->text.changed.connect([this] (std::string const& filter) {
+    if (filter.empty())
+    {
+      sScreen->relayoutSlots(CompMatch::emptyMatch);
+    }
+    else
+    {
+      auto match = sScreen->getCustomMatch();
+      sScreen->relayoutSlots(match & ("ititle="+filter));
+    }
+  });
+
+  for (auto const& swin : sScreen->getWindows())
     UnityWindow::get(swin->window)->OnInitiateSpread();
 }
 
 void UnityScreen::OnTerminateSpread()
 {
-  for (auto const& swin : ScaleScreen::get(screen)->getWindows())
+  spread_filter_.reset();
+
+  for (auto const& swin : sScreen->getWindows())
     UnityWindow::get(swin->window)->OnTerminateSpread();
 }
 
@@ -1680,8 +1694,7 @@
     case MotionNotify:
       if (wm.IsScaleActive())
       {
-        ScaleScreen* ss = ScaleScreen::get(screen);
-        if (CompWindow *w = screen->findWindow(ss->getSelectedWindow()))
+        if (CompWindow *w = screen->findWindow(sScreen->getSelectedWindow()))
           skip_other_plugins = UnityWindow::get(w)->handleEvent(event);
       }
       else if (switcher_controller_->IsDetailViewShown())
@@ -1706,9 +1719,14 @@
       }
       if (wm.IsScaleActive())
       {
-        ScaleScreen* ss = ScaleScreen::get(screen);
-        if (CompWindow *w = screen->findWindow(ss->getSelectedWindow()))
-          skip_other_plugins = UnityWindow::get(w)->handleEvent(event);
+        if (spread_filter_ && spread_filter_->Visible())
+          skip_other_plugins = spread_filter_->GetAbsoluteGeometry().IsPointInside(event->xbutton.x_root, event->xbutton.y_root);
+
+        if (!skip_other_plugins)
+        {
+          if (CompWindow *w = screen->findWindow(sScreen->getSelectedWindow()))
+            skip_other_plugins = UnityWindow::get(w)->handleEvent(event);
+        }
       }
       else if (switcher_controller_->IsDetailViewShown())
       {
@@ -1782,9 +1800,14 @@
       }
       else if (wm.IsScaleActive())
       {
-        ScaleScreen* ss = ScaleScreen::get(screen);
-        if (CompWindow *w = screen->findWindow(ss->getSelectedWindow()))
-          skip_other_plugins = UnityWindow::get(w)->handleEvent(event);
+        if (spread_filter_ && spread_filter_->Visible())
+          skip_other_plugins = spread_filter_->GetAbsoluteGeometry().IsPointInside(event->xbutton.x_root, event->xbutton.y_root);
+
+        if (!skip_other_plugins)
+        {
+          if (CompWindow *w = screen->findWindow(sScreen->getSelectedWindow()))
+            skip_other_plugins = skip_other_plugins || UnityWindow::get(w)->handleEvent(event);
+        }
       }
       break;
     case KeyPress:
@@ -1853,6 +1876,16 @@
           EnableCancelAction(CancelActionTarget::LAUNCHER_SWITCHER, false);
         }
       }
+
+      if (spread_filter_ && spread_filter_->Visible())
+      {
+        if (key_sym == XK_Escape)
+        {
+          skip_other_plugins = true;
+          spread_filter_->text = "";
+        }
+      }
+
       break;
     }
     case MapRequest:
@@ -1866,22 +1899,21 @@
       }
       break;
     default:
-        if (screen->shapeEvent () + ShapeNotify == event->type)
+        if (screen->shapeEvent() + ShapeNotify == event->type)
         {
           Window xid = event->xany.window;
           CompWindow *w = screen->findWindow(xid);
 
           if (w)
           {
-            UnityWindow *uw = UnityWindow::get (w);
-
+            UnityWindow *uw = UnityWindow::get(w);
             uw->handleEvent(event);
           }
         }
       break;
   }
 
-  compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>::handleEvent (event);
+  compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>::handleEvent(event);
 
   // avoid further propagation (key conflict for instance)
   if (!skip_other_plugins)
@@ -1890,19 +1922,18 @@
   if (deco_manager_->HandleEventAfter(event))
     return;
 
-  switch (event->type)
-  {
-    case MapRequest:
-      ShowdesktopHandler::AllowLeaveShowdesktopMode(event->xmaprequest.window);
-      break;
-  }
+  if (event->type == MapRequest)
+    ShowdesktopHandler::AllowLeaveShowdesktopMode(event->xmaprequest.window);
 
-  if ((event->type == MotionNotify || event->type == ButtonPress || event->type == ButtonRelease) &&
-      switcher_controller_->IsMouseDisabled() && switcher_controller_->Visible())
+  if (switcher_controller_->IsMouseDisabled() && switcher_controller_->Visible() &&
+      (event->type == MotionNotify || event->type == ButtonPress || event->type == ButtonRelease))
   {
     skip_other_plugins = true;
   }
 
+  if (spread_filter_ && spread_filter_->Visible())
+    skip_other_plugins = false;
+
   if (!skip_other_plugins &&
       screen->otherGrabExist("deco", "move", "switcher", "resize", nullptr))
   {
@@ -2786,7 +2817,7 @@
   }
 
   if (WindowManager::Default().IsScaleActive() &&
-      ScaleScreen::get(screen)->getSelectedWindow() == window->id())
+      uScreen->sScreen->getSelectedWindow() == window->id())
   {
     nux::Geometry const& scaled_geo = GetScaledGeometry();
     paintInnerGlow(scaled_geo, matrix, attrib, mask);
@@ -3737,7 +3768,7 @@
 void UnityWindow::AddProperties(debug::IntrospectionData& introspection)
 {
   Window xid = window->id();
-  auto const& swins = ScaleScreen::get(screen)->getWindows();
+  auto const& swins = uScreen->sScreen->getWindows();
   bool scaled = std::find(swins.begin(), swins.end(), ScaleWindow::get(window)) != swins.end();
   WindowManager& wm = WindowManager::Default();
 
@@ -3942,8 +3973,7 @@
   if (!scale_win->hasSlot()) // animation not finished
     return;
 
-  ScaleScreen* ss = ScaleScreen::get(screen);
-  auto state = ss->getState();
+  auto state = uScreen->sScreen->getState();
 
   if (state != ScaleScreen::Wait && state != ScaleScreen::Out)
     return;
@@ -3953,7 +3983,7 @@
   auto deco_attrib = attrib;
   deco_attrib.opacity = COMPIZ_COMPOSITE_OPAQUE;
 
-  bool highlighted = (ss->getSelectedWindow() == window->id());
+  bool highlighted = (uScreen->sScreen->getSelectedWindow() == window->id());
   paintFakeDecoration(scale_geo, deco_attrib, transform, mask, highlighted, pos.scale);
 }
 
@@ -4130,7 +4160,7 @@
 
 Introspectable::IntrospectableList ScreenIntrospection::GetIntrospectableChildren()
 {
-  IntrospectableList children;
+  IntrospectableList children({uScreen->spread_filter_.get()});
 
   for (auto const& win : screen_->windows())
     children.push_back(UnityWindow::get(win));

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2014-02-12 07:13:01 +0000
+++ plugins/unityshell/src/unityshell.h	2014-02-18 00:59:55 +0000
@@ -65,6 +65,7 @@
 #include "ScreenIntrospection.h"
 #include "SwitcherController.h"
 #include "SessionController.h"
+#include "SpreadFilter.h"
 #include "UBusWrapper.h"
 #include "UnityshellPrivate.h"
 #include "UnityShowdesktopHandler.h"
@@ -118,6 +119,7 @@
   CompScreen* screen;
   CompositeScreen* cScreen;
   GLScreen* gScreen;
+  ScaleScreen* sScreen;
 
   /* prepares nux for drawing */
   void nuxPrologue();
@@ -327,6 +329,7 @@
   session::Controller::Ptr  session_controller_;
   debug::DebugDBusInterface debugger_;
   std::unique_ptr<BGHash>   bghash_;
+  spread::Filter::Ptr       spread_filter_;
 
   /* Subscription for gestures that manipulate Unity launcher */
   std::unique_ptr<nux::GesturesSubscription> gestures_sub_launcher_;
@@ -407,6 +410,7 @@
   bool is_desktop_active_;
 
   friend class UnityWindow;
+  friend class debug::ScreenIntrospection;
   friend class decoration::Manager;
 };
 

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2014-02-04 16:38:45 +0000
+++ plugins/unityshell/unityshell.xml.in	2014-02-18 00:59:55 +0000
@@ -43,6 +43,7 @@
             </requirement>
             <conflict>
                 <plugin>decor</plugin>
+                <plugin>scalefilter</plugin>
             </conflict>
         </deps>
 

=== modified file 'shutdown/SessionController.h'
--- shutdown/SessionController.h	2014-01-06 19:50:53 +0000
+++ shutdown/SessionController.h	2014-02-18 00:59:55 +0000
@@ -25,7 +25,6 @@
 #include <Nux/Nux.h>
 #include <Nux/BaseWindow.h>
 #include <Nux/HLayout.h>
-#include <NuxCore/Color.h>
 #include <NuxCore/Animation.h>
 #include <UnityCore/SessionManager.h>
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-02-07 21:50:15 +0000
+++ tests/CMakeLists.txt	2014-02-18 00:59:55 +0000
@@ -278,6 +278,7 @@
                  test_single_monitor_launcher_icon.cpp
                  test_showdesktop_handler.cpp
                  test_software_center_launcher_icon.cpp
+                 test_spread_filter.cpp
                  test_static_cairo_text.cpp
                  test_switcher_controller.cpp
                  test_switcher_controller_class.cpp

=== modified file 'tests/autopilot/unity/emulators/screen.py'
--- tests/autopilot/unity/emulators/screen.py	2013-10-08 14:08:52 +0000
+++ tests/autopilot/unity/emulators/screen.py	2014-02-18 00:59:55 +0000
@@ -28,6 +28,15 @@
         """Return the available scaled windows, or None."""
         return self.get_children_by_type(Window, scaled=True)
 
+    @property
+    def spread_filter(self):
+        """Return the spread filter, or None."""
+        filter = self.get_children_by_type(SpreadFilter)
+        if len(filter):
+            return filter[0]
+
+        return None
+
     def window(self, xid):
         """Return the window with given xid."""
         windows = self.get_children_by_type(Window, xid=xid)
@@ -51,3 +60,17 @@
         self.scaled_close_width.wait_for(GreaterThan(0))
         self.scaled_close_height.wait_for(GreaterThan(0))
         return (self.scaled_close_x, self.scaled_close_y, self.scaled_close_width, self.scaled_close_height)
+
+
+class SpreadFilter(UnityIntrospectionObject):
+    """The spread filter."""
+
+    @property
+    def search_bar(self):
+        """Return the search bar."""
+        [search_bar] = self.get_children_by_type(SearchBar)
+        return search_bar
+
+
+class SearchBar(UnityIntrospectionObject):
+    """The search bar for the spread filter."""
\ No newline at end of file

=== modified file 'tests/autopilot/unity/tests/test_spread.py'
--- tests/autopilot/unity/tests/test_spread.py	2014-02-14 16:40:28 +0000
+++ tests/autopilot/unity/tests/test_spread.py	2014-02-18 00:59:55 +0000
@@ -12,7 +12,6 @@
 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
 
@@ -56,10 +55,14 @@
         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):
-        """Assert that a window is not scaled"""
-        refresh_fn = lambda: window.id in [w.id for w in self.unity.screen.scaled_windows]
-        self.assertThat(refresh_fn, Eventually(Equals(False)))
+    def get_spread_filter(self):
+        self.assertThat(lambda: self.unity.screen.spread_filter, Eventually(NotEquals(None)))
+        return self.unity.screen.spread_filter
+
+    def assertWindowIsScaledEquals(self, xid, scaled):
+        """Assert weather a window is scaled"""
+        refresh_fn = lambda: xid in [w.xid for w in self.unity.screen.scaled_windows]
+        self.assertThat(refresh_fn, Eventually(Equals(scaled)))
 
     def assertWindowIsClosed(self, xid):
         """Assert that a window is not in the list of the open windows"""
@@ -72,7 +75,7 @@
 
     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):
+            if not also_active and icon.active:
                 self.assertFalse(icon.monitors_desaturated[self.monitor])
             else:
                 self.assertTrue(icon.monitors_desaturated[self.monitor])
@@ -119,7 +122,7 @@
         sleep(.5)
         self.mouse.click(button=2)
 
-        self.assertWindowIsNotScaled(target_win)
+        self.assertWindowIsScaledEquals(target_xid, False)
         self.assertWindowIsClosed(target_xid)
 
     def test_scaled_window_closes_on_close_button_click(self):
@@ -135,7 +138,7 @@
         sleep(.5)
         self.mouse.click()
 
-        self.assertWindowIsNotScaled(target_win)
+        self.assertWindowIsScaledEquals(target_xid, False)
         self.assertWindowIsClosed(target_xid)
 
     def test_spread_desaturate_launcher_icons(self):
@@ -191,3 +194,41 @@
 
         self.initiate_spread_for_screen()
         self.assertThat(icon.get_tooltip().active, Eventually(Equals(False)))
+
+    def test_spread_puts_panel_in_overlay_mode(self):
+        """Test that the panel is in overlay mode when in spread"""
+        self.start_test_application_windows("Calculator", 1)
+        self.initiate_spread_for_screen()
+        self.assertThat(self.unity.panels.get_active_panel().in_overlay_mode, Eventually(Equals(True)))
+        self.unity.window_manager.terminate_spread()
+        self.assertThat(self.unity.panels.get_active_panel().in_overlay_mode, Eventually(Equals(False)))
+
+    def test_panel_close_window_button_terminates_spread(self):
+        """Test that the panel close window button terminates the spread"""
+        self.start_test_application_windows("Calculator", 1)
+        self.initiate_spread_for_screen()
+        self.unity.panels.get_active_panel().window_buttons.close.mouse_click();
+        self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(False)))
+
+    def test_spread_filter(self):
+        """Test spread filter"""
+        cal_wins = self.start_test_application_windows("Calculator", 2)
+        char_wins = self.start_test_application_windows("Character Map", 2)
+        self.initiate_spread_for_screen()
+        spread_filter = self.get_spread_filter()
+        self.assertThat(spread_filter.visible, Eventually(Equals(False)))
+
+        self.addCleanup(self.keyboard.press_and_release, "Escape")
+        self.keyboard.type(cal_wins[0].title)
+        self.assertThat(spread_filter.visible, Eventually(Equals(True)))
+        self.assertThat(spread_filter.search_bar.search_string, Eventually(Equals(cal_wins[0].title)))
+
+        for w in cal_wins + char_wins:
+            self.assertWindowIsScaledEquals(w.x_id, (w in cal_wins))
+
+        self.keyboard.press_and_release("Escape")
+        self.assertThat(spread_filter.visible, Eventually(Equals(False)))
+        self.assertThat(spread_filter.search_bar.search_string, Eventually(Equals("")))
+
+        for w in cal_wins + char_wins:
+            self.assertWindowIsScaledEquals(w.x_id, True)

=== added file 'tests/test_spread_filter.cpp'
--- tests/test_spread_filter.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_spread_filter.cpp	2014-02-18 00:59:55 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2014 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 <[e-mail]>
+ *
+ */
+
+#include <gmock/gmock.h>
+#include <Nux/NuxTimerTickSource.h>
+#include <NuxCore/AnimationController.h>
+
+#include "SpreadFilter.h"
+#include "UnitySettings.h"
+#include "DashStyle.h"
+#include "test_utils.h"
+
+namespace unity
+{
+namespace spread
+{
+namespace
+{
+using namespace testing;
+
+const unsigned ANIMATION_DURATION = 100 * 1000; // in microseconds
+
+struct SigReceiver : sigc::trackable
+{
+  typedef NiceMock<SigReceiver> Nice;
+
+  SigReceiver(Filter const& const_filter)
+  {
+    auto& filter = const_cast<Filter&>(const_filter);
+    filter.text.changed.connect(sigc::mem_fun(this, &SigReceiver::TextChanged));
+  }
+
+  MOCK_CONST_METHOD1(TextChanged, void(std::string const&));
+};
+
+struct TestSpreadFilter : Test
+{
+  TestSpreadFilter()
+    : animation_controller(tick_source)
+    , big_tick_(0)
+    , sig_receiver(filter)
+  {}
+
+  void Tick()
+  {
+    big_tick_ += ANIMATION_DURATION;
+    tick_source.tick(big_tick_);
+  }
+
+  Settings settings_;
+  dash::Style style_;
+  nux::NuxTimerTickSource tick_source;
+  nux::animation::AnimationController animation_controller;
+  uint64_t big_tick_;
+  Filter filter;
+  SigReceiver::Nice sig_receiver;
+};
+
+TEST_F(TestSpreadFilter, Construction)
+{
+  EXPECT_FALSE(filter.Visible());
+  EXPECT_TRUE(filter.text().empty());
+}
+
+TEST_F(TestSpreadFilter, VisibleWithText)
+{
+  std::string filter_string = "Unity is cool!";
+  EXPECT_CALL(sig_receiver, TextChanged(_)).Times(0);
+
+  filter.text = filter_string;
+  Tick();
+
+  EXPECT_TRUE(filter.Visible());
+  EXPECT_FALSE(filter.text().empty());
+
+  EXPECT_CALL(sig_receiver, TextChanged(filter_string));
+  Utils::WaitForTimeoutMSec();
+
+  EXPECT_EQ(filter_string, filter.text());
+}
+
+TEST_F(TestSpreadFilter, InVisibleWithoutText)
+{
+  filter.text = "Really, Unity is cool!";
+  Utils::WaitForTimeoutMSec();
+  Tick();
+
+  ASSERT_TRUE(filter.Visible());
+
+  EXPECT_CALL(sig_receiver, TextChanged(""));
+  filter.text = "";
+  EXPECT_TRUE(filter.text().empty());
+  Tick();
+  EXPECT_FALSE(filter.Visible());
+}
+
+} // anonymous namespace
+} // spread namespace
+} // unity namespace

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2014-02-12 07:09:43 +0000
+++ unity-shared/CMakeLists.txt	2014-02-18 00:59:55 +0000
@@ -55,6 +55,7 @@
      ResizingBaseWindow.cpp
      SearchBar.cpp
      SearchBarSpinner.cpp
+     SpreadFilter.cpp
      StaticCairoText.cpp
      TextureCache.cpp
      TextInput.cpp

=== modified file 'unity-shared/PluginAdapter.cpp'
--- unity-shared/PluginAdapter.cpp	2014-02-18 00:59:55 +0000
+++ unity-shared/PluginAdapter.cpp	2014-02-18 00:59:55 +0000
@@ -24,6 +24,7 @@
 #include "PluginAdapter.h"
 #include "CompizUtils.h"
 
+#include <scale/scale.h>
 #include <NuxCore/Logger.h>
 
 namespace unity
@@ -288,7 +289,7 @@
 
   if (primary_action_)
   {
-    primary_action_->terminate()(primary_action_, 0, argument);
+    primary_action_->terminate()(primary_action_, CompAction::StateCancel, argument);
     return;
   }
 
@@ -337,13 +338,8 @@
 {
   std::ostringstream sout;
 
-  sout << "any & (";
-
   for (auto const& window : windows)
-  {
-    sout << "| xid=" << window << " ";
-  }
-  sout << ")";
+    sout << "xid=" << window << " | ";
 
   return sout.str();
 }

=== modified file 'unity-shared/SearchBar.cpp'
--- unity-shared/SearchBar.cpp	2013-11-19 18:48:35 +0000
+++ unity-shared/SearchBar.cpp	2014-02-18 00:59:55 +0000
@@ -33,8 +33,8 @@
 
 namespace
 {
-const float kExpandDefaultIconOpacity = 1.0f;
-const int LIVE_SEARCH_TIMEOUT = 40;
+const float DEFAULT_ICON_OPACITY = 1.0f;
+const int DEFAULT_LIVE_SEARCH_TIMEOUT = 40;
 const int SPINNER_TIMEOUT = 100;
 
 const int SPACE_BETWEEN_SPINNER_AND_TEXT = 5;
@@ -105,34 +105,19 @@
 NUX_IMPLEMENT_OBJECT_TYPE(SearchBar);
 
 SearchBar::SearchBar(NUX_FILE_LINE_DECL)
-  : View(NUX_FILE_LINE_PARAM)
-  , search_hint("")
-  , showing_filters(false)
-  , can_refine_search(false)
-  , show_filter_hint_(true)
-  , expander_view_(nullptr)
-  , show_filters_(nullptr)
-  , last_width_(-1)
-  , last_height_(-1)
-{
-  Init();
-}
-
-SearchBar::SearchBar(bool show_filter_hint_, NUX_FILE_LINE_DECL)
-  : View(NUX_FILE_LINE_PARAM)
-  , search_hint("")
-  , showing_filters(false)
-  , can_refine_search(false)
-  , show_filter_hint_(show_filter_hint_)
-  , expander_view_(nullptr)
-  , show_filters_(nullptr)
-  , last_width_(-1)
-  , last_height_(-1)
-{
-  Init();
-}
-
-void SearchBar::Init()
+  : SearchBar(false)
+{}
+
+SearchBar::SearchBar(bool show_filter_hint, NUX_FILE_LINE_DECL)
+  : View(NUX_FILE_LINE_PARAM)
+  , showing_filters(false)
+  , can_refine_search(false)
+  , live_search_wait(DEFAULT_LIVE_SEARCH_TIMEOUT)
+  , show_filter_hint_(show_filter_hint)
+  , expander_view_(nullptr)
+  , show_filters_(nullptr)
+  , last_width_(-1)
+  , last_height_(-1)
 {
   dash::Style& style = dash::Style::Instance();
   nux::BaseTexture* icon = style.GetSearchMagnifyIcon();
@@ -199,7 +184,7 @@
     expand_icon_ = new IconTexture(arrow,
                                    arrow->GetWidth(),
                                    arrow->GetHeight());
-    expand_icon_->SetOpacity(kExpandDefaultIconOpacity);
+    expand_icon_->SetOpacity(DEFAULT_ICON_OPACITY);
     expand_icon_->SetMinimumSize(arrow->GetWidth(), arrow->GetHeight());
     expand_icon_->SetVisible(false);
 
@@ -294,10 +279,13 @@
     font_desc << pango_font_description_get_family(desc) << " " << HINT_LABEL_FONT_STYLE << " " << HINT_LABEL_FONT_SIZE;
     hint_->SetFont(font_desc.str().c_str());
 
-    font_desc.str("");
-    font_desc.clear();
-    font_desc << pango_font_description_get_family(desc) << " " << SHOW_FILTERS_LABEL_FONT_STYLE << " " << SHOW_FILTERS_LABEL_FONT_SIZE;
-    show_filters_->SetFont(font_desc.str().c_str());
+    if (show_filter_hint_)
+    {
+      font_desc.str("");
+      font_desc.clear();
+      font_desc << pango_font_description_get_family(desc) << " " << SHOW_FILTERS_LABEL_FONT_STYLE << " " << SHOW_FILTERS_LABEL_FONT_SIZE;
+      show_filters_->SetFont(font_desc.str().c_str());
+    }
 
     pango_font_description_free(desc);
   }
@@ -317,7 +305,7 @@
   // We don't want to set a new search string on every new character, so we add a sma
   // timeout to see if the user is typing a sentence. If more characters are added, we
   // keep restarting the timeout unti the user has actuay paused.
-  live_search_timeout_.reset(new glib::Timeout(LIVE_SEARCH_TIMEOUT));
+  live_search_timeout_.reset(new glib::Timeout(live_search_wait()));
   live_search_timeout_->Run(sigc::mem_fun(this, &SearchBar::OnLiveSearchTimeout));
 
   // Don't animate the spinner immediately, the searches are fast and
@@ -428,6 +416,9 @@
     nux::GetPainter().PushPaintLayerStack();      
   }
 
+  if (!IsFullRedraw())
+    graphics::ClearGeometry(pango_entry_->GetGeometry());
+
   layout_->ProcessDraw(graphics_engine, force_draw);
 
   if (IsFullRedraw())
@@ -455,7 +446,7 @@
 
 void SearchBar::ForceLiveSearch()
 {
-  live_search_timeout_.reset(new glib::Timeout(LIVE_SEARCH_TIMEOUT));
+  live_search_timeout_.reset(new glib::Timeout(live_search_wait()));
   live_search_timeout_->Run(sigc::mem_fun(this, &SearchBar::OnLiveSearchTimeout));
 
   start_spinner_timeout_.reset(new glib::Timeout(SPINNER_TIMEOUT));
@@ -466,8 +457,7 @@
 {
   start_spinner_timeout_.reset();
 
-  bool is_empty = pango_entry_->im_active() ?
-    false : pango_entry_->GetText() == "";
+  bool is_empty = pango_entry_->im_active() ? false : pango_entry_->GetText().empty();
   spinner_->SetState(is_empty ? STATE_READY : STATE_CLEAR);
 }
 
@@ -609,14 +599,19 @@
   .add(GetAbsoluteGeometry())
   .add("has_focus", pango_entry_->HasKeyFocus())
   .add("search_string", pango_entry_->GetText())
-  .add("expander-has-focus", expander_view_->HasKeyFocus())
   .add("showing-filters", showing_filters)
-  .add("filter-label-x", show_filters_->GetAbsoluteX())
-  .add("filter-label-y", show_filters_->GetAbsoluteY())
-  .add("filter-label-width", show_filters_->GetAbsoluteWidth())
-  .add("filter-label-height", show_filters_->GetAbsoluteHeight())
-  .add("filter-label-geo", show_filters_->GetAbsoluteGeometry())
   .add("im_active", pango_entry_->im_active());
+
+  if (show_filter_hint_)
+  {
+    introspection
+    .add("expander-has-focus", expander_view_->HasKeyFocus())
+    .add("filter-label-x", show_filters_->GetAbsoluteX())
+    .add("filter-label-y", show_filters_->GetAbsoluteY())
+    .add("filter-label-width", show_filters_->GetAbsoluteWidth())
+    .add("filter-label-height", show_filters_->GetAbsoluteHeight())
+    .add("filter-label-geo", show_filters_->GetAbsoluteGeometry());
+  }
 }
 
 } // namespace unity

=== modified file 'unity-shared/SearchBar.h'
--- unity-shared/SearchBar.h	2013-09-19 16:44:03 +0000
+++ unity-shared/SearchBar.h	2014-02-18 00:59:55 +0000
@@ -63,14 +63,13 @@
   nux::Property<bool> can_refine_search;
   nux::ROProperty<bool> im_active;
   nux::ROProperty<bool> im_preedit;
+  nux::Property<unsigned> live_search_wait;
 
   sigc::signal<void> activated;
   sigc::signal<void, std::string const&> search_changed;
   sigc::signal<void, std::string const&> live_search_reached;
 
 private:
-  void Init();
-
   void OnFontChanged(GtkSettings* settings, GParamSpec* pspec=NULL);
   void OnSearchHintChanged();
 

=== added file 'unity-shared/SpreadFilter.cpp'
--- unity-shared/SpreadFilter.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/SpreadFilter.cpp	2014-02-18 00:59:55 +0000
@@ -0,0 +1,121 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2014 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: Marco Trevisan <[e-mail]>
+*/
+
+#include "SpreadFilter.h"
+
+#include <Nux/HLayout.h>
+#include "AnimationUtils.h"
+#include "SearchBar.h"
+#include "WindowManager.h"
+
+namespace unity
+{
+namespace spread
+{
+namespace
+{
+const unsigned FADE_DURATION = 100;
+const unsigned DEFAULT_SEARCH_WAIT = 300;
+const nux::Point OFFSET(10, 15);
+const nux::Size SIZE(620, 42);
+}
+
+Filter::Filter()
+  : fade_animator_(FADE_DURATION)
+{
+  search_bar_ = SearchBar::Ptr(new SearchBar());
+  search_bar_->SetMinMaxSize(SIZE.width, SIZE.height);
+  search_bar_->live_search_wait = DEFAULT_SEARCH_WAIT;
+  text.SetGetterFunction([this] { return search_bar_->search_string(); });
+  text.SetSetterFunction([this] (std::string const& t) { search_bar_->search_string = t; return false; });
+  debug::Introspectable::AddChild(search_bar_.GetPointer());
+
+  auto layout = new nux::HLayout(NUX_TRACKER_LOCATION);
+  layout->SetVerticalExternalMargin(0);
+  layout->SetHorizontalExternalMargin(0);
+  layout->AddView(search_bar_.GetPointer());
+
+  auto const& work_area = WindowManager::Default().GetWorkAreaGeometry(0);
+  view_window_ = new nux::BaseWindow(GetName().c_str());
+  view_window_->SetLayout(layout);
+  view_window_->SetBackgroundColor(nux::color::Transparent);
+  view_window_->SetWindowSizeMatchLayout(true);
+  view_window_->ShowWindow(true);
+  view_window_->PushToFront();
+  view_window_->SetOpacity(0.0f);
+  view_window_->SetEnterFocusInputArea(search_bar_.GetPointer());
+  view_window_->SetInputFocus();
+  view_window_->SetXY(OFFSET.x + work_area.x, OFFSET.y + work_area.y);
+  fade_animator_.updated.connect([this] (double opacity) { view_window_->SetOpacity(opacity); });
+
+  nux::GetWindowCompositor().SetKeyFocusArea(search_bar_->text_entry());
+
+  search_bar_->search_changed.connect([this] (std::string const& search) {
+    if (!Visible())
+      animation::StartOrReverse(fade_animator_, animation::Direction::FORWARD);
+
+    if (search.empty())
+    {
+      text.changed.emit(search);
+      animation::StartOrReverse(fade_animator_, animation::Direction::BACKWARD);
+    }
+  });
+
+  search_bar_->live_search_reached.connect([this] (std::string const& search) {
+    if (!search.empty())
+    {
+      text.changed.emit(search);
+      search_bar_->SetSearchFinished();
+    }
+  });
+}
+
+Filter::~Filter()
+{
+  nux::GetWindowCompositor().SetKeyFocusArea(nullptr);
+  nux::GetWindowThread()->RemoveObjectFromLayoutQueue(view_window_.GetPointer());
+}
+
+bool Filter::Visible() const
+{
+  return (view_window_->GetOpacity() != 0.0f);
+}
+
+nux::Geometry const& Filter::GetAbsoluteGeometry() const
+{
+  return view_window_->GetGeometry();
+}
+
+//
+// Introspection
+//
+std::string Filter::GetName() const
+{
+  return "SpreadFilter";
+}
+
+void Filter::AddProperties(debug::IntrospectionData& introspection)
+{
+  introspection
+    .add(GetAbsoluteGeometry())
+    .add("visible", Visible());
+}
+
+} // namespace spread
+} // namespace unity

=== added file 'unity-shared/SpreadFilter.h'
--- unity-shared/SpreadFilter.h	1970-01-01 00:00:00 +0000
+++ unity-shared/SpreadFilter.h	2014-02-18 00:59:55 +0000
@@ -0,0 +1,64 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2014 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: Marco Trevisan <[e-mail]>
+*/
+
+#ifndef UNITYSHELL_SPREAD_FILTER_H
+#define UNITYSHELL_SPREAD_FILTER_H
+
+#include <memory>
+
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+#include <NuxCore/Animation.h>
+#include "Introspectable.h"
+
+namespace unity
+{
+class SearchBar;
+
+namespace spread
+{
+
+class Filter : public debug::Introspectable, public sigc::trackable
+{
+public:
+  typedef std::shared_ptr<Filter> Ptr;
+
+  Filter();
+  virtual ~Filter();
+
+  nux::RWProperty<std::string> text;
+
+  bool Visible() const;
+  nux::Geometry const& GetAbsoluteGeometry() const;
+
+protected:
+  // Introspectable
+  std::string GetName() const;
+  void AddProperties(debug::IntrospectionData&);
+
+private:
+  nux::ObjectPtr<SearchBar> search_bar_;
+  nux::ObjectPtr<nux::BaseWindow> view_window_;
+  nux::animation::AnimateValue<double> fade_animator_;
+};
+
+} // namespace spread
+} // namespace unity
+
+#endif