Added text filtering to Overview Mode

ash/wm/overview/window_selector.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/wm/overview/window_selector.h"
 
 #include <algorithm>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/switchable_windows.h"
 #include "ash/wm/overview/scoped_transform_overview_window.h"
 #include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector_delegate.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/gfx/screen.h"
+#include "ui/views/border.h"
+#include "ui/views/controls/textfield/textfield.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
 
 namespace {
 
 // A comparator for locating a grid with a given root window.
 struct RootWindowGridComparator
     : public std::unary_function<WindowGrid*, bool> {
@@ skipping 40 matching lines @@
 void UpdateShelfVisibility() {
   Shell::RootWindowControllerList root_window_controllers =
       Shell::GetInstance()->GetAllRootWindowControllers();
   for (Shell::RootWindowControllerList::iterator iter =
           root_window_controllers.begin();
        iter != root_window_controllers.end(); ++iter) {
     (*iter)->UpdateShelfVisibility();
   }
 }
 
+// Initializes the text filter on the top of the main root window and requests
+// focus on its textfield.
+views::Widget* CreateTextFilter(views::TextfieldController* controller,
+                                aura::Window* root_window) {
+  views::Widget* widget = new views::Widget;
+  views::Widget::InitParams params;
+  params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+  params.parent =
+      Shell::GetContainer(root_window, ash::kShellWindowId_OverlayContainer);
+  params.accept_events = true;
+  params.bounds = gfx::Rect(root_window->bounds().width() / 4, 0,
+                            root_window->bounds().width() / 2, 0);

[flackr, 2014/06/26 17:33:07]

nit: use constants, in this case something like kTextFilterScreenProportion =
0.5 which implies a centered rectangle that is 50% of the screen width.

[Nina, 2014/06/27 15:20:39]

Done.

+  widget->Init(params);
+  views::Textfield* textfield = new views::Textfield;
+  textfield->set_controller(controller);
+  textfield->SetBackgroundColor(SK_ColorTRANSPARENT);
+  textfield->SetBorder(views::Border::NullBorder());
+  textfield->SetTextColor(SK_ColorWHITE);
+  textfield->DisplayShadow(true);
+  widget->SetContentsView(textfield);
+  widget->Show();
+  textfield->RequestFocus();
+
+  return widget;
+}
+
 }  // namespace
 
 WindowSelector::WindowSelector(const WindowList& windows,
                                WindowSelectorDelegate* delegate)
     : delegate_(delegate),
       restore_focus_window_(aura::client::GetFocusClient(
           Shell::GetPrimaryRootWindow())->GetFocusedWindow()),
       ignore_activations_(false),
       selected_grid_index_(0),
       overview_start_time_(base::Time::Now()),
       num_key_presses_(0),
-      num_items_(0) {
+      num_items_(0),
+      showing_selection_widget_(false) {

[flackr, 2014/06/26 17:33:07]

Do we need this variable or can we just check if the text contents are empty?

[Nina, 2014/06/27 15:20:39]

We could remove the variable at the cost of having to animate the widget moving
in every single time the user wrote something, as we have no idea what the
contents were _before_ he did. I'd rather leave it there.

   DCHECK(delegate_);
   Shell* shell = Shell::GetInstance();
   shell->OnOverviewModeStarting();
 
   if (restore_focus_window_)
     restore_focus_window_->AddObserver(this);
 
   const aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); iter++) {
     // Observed switchable containers for newly created windows on all root
     // windows.
     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
       aura::Window* container = Shell::GetContainer(*iter,
           kSwitchableWindowContainerIds[i]);
       container->AddObserver(this);
       observed_windows_.insert(container);
     }
     scoped_ptr<WindowGrid> grid(new WindowGrid(*iter, windows, this));
     if (grid->empty())
       continue;
     num_items_ += grid->size();
     grid_list_.push_back(grid.release());
   }
 
   DCHECK(!grid_list_.empty());
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 
+  text_filter_widget_.reset(
+      CreateTextFilter(this, Shell::GetPrimaryRootWindow()));
+
   shell->activation_client()->AddObserver(this);
 
-  // Remove focus from active window before entering overview.
-  aura::client::GetFocusClient(
-      Shell::GetPrimaryRootWindow())->FocusWindow(NULL);
-
-  shell->PrependPreTargetHandler(this);
   shell->GetScreen()->AddObserver(this);
   shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
   HideAndTrackNonOverviewWindows();
   // Send an a11y alert.
   shell->accessibility_delegate()->TriggerAccessibilityAlert(
       A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 
   UpdateShelfVisibility();
 }
 
@@ skipping 14 matching lines @@
     ui::ScopedLayerAnimationSettings settings(
         (*iter)->layer()->GetAnimator());
     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
         ScopedTransformOverviewWindow::kTransitionMilliseconds));
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     (*iter)->layer()->SetOpacity(1);
     (*iter)->Show();
   }
 
-  shell->RemovePreTargetHandler(this);
   shell->GetScreen()->RemoveObserver(this);
 
   size_t remaining_items = 0;
   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
       iter != grid_list_.end(); iter++) {
     remaining_items += (*iter)->size();
   }
 
   DCHECK(num_items_ >= remaining_items);
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.OverviewClosedItems",
@@ skipping 18 matching lines @@
   ScopedVector<WindowGrid>::iterator iter =
       std::find(grid_list_.begin(), grid_list_.end(), grid);
   DCHECK(iter != grid_list_.end());
   grid_list_.erase(iter);
   // TODO(nsatragno): Use the previous index for more than two displays.
   selected_grid_index_ = 0;
   if (grid_list_.empty())
     CancelSelection();
 }
 
-void WindowSelector::OnKeyEvent(ui::KeyEvent* event) {
-  if (event->type() != ui::ET_KEY_PRESSED)
-    return;
+bool WindowSelector::HandleKeyEvent(views::Textfield* sender,
+                                    const ui::KeyEvent& key_event) {
+  if (key_event.type() != ui::ET_KEY_PRESSED)
+    return false;
 
-  switch (event->key_code()) {
+  switch (key_event.key_code()) {
     case ui::VKEY_ESCAPE:
       CancelSelection();
       break;
     case ui::VKEY_UP:
       num_key_presses_++;
       Move(WindowSelector::UP);
       break;
     case ui::VKEY_DOWN:
       num_key_presses_++;
       Move(WindowSelector::DOWN);
       break;
     case ui::VKEY_RIGHT:
       num_key_presses_++;
       Move(WindowSelector::RIGHT);
       break;
     case ui::VKEY_LEFT:
       num_key_presses_++;
       Move(WindowSelector::LEFT);
       break;
     case ui::VKEY_RETURN:
       // Ignore if no item is selected.
       if (!grid_list_[selected_grid_index_]->is_selecting())
-        return;
+        return true;
       UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ArrowKeyPresses",
                                num_key_presses_);
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Ash.WindowSelector.KeyPressesOverItemsRatio",
           (num_key_presses_ * 100) / num_items_, 1, 300, 30);
       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
           UMA_WINDOW_OVERVIEW_ENTER_KEY);
       wm::GetWindowState(grid_list_[selected_grid_index_]->
                          SelectedWindow()->SelectionWindow())->Activate();
       break;
     default:
-      // Not a key we are interested in.
-      return;
+      // Not a key we are interested in, allow the textfield to handle it.
+      return false;
   }
-  event->StopPropagation();
+  return true;
 }
 
 void WindowSelector::OnDisplayAdded(const gfx::Display& display) {
 }
 
 void WindowSelector::OnDisplayRemoved(const gfx::Display& display) {
   // TODO(nsatragno): Keep window selection active on remaining displays.
   CancelSelection();
 }
 
@@ skipping 20 matching lines @@
 
 void WindowSelector::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
   observed_windows_.erase(window);
   if (window == restore_focus_window_)
     restore_focus_window_ = NULL;
 }
 
 void WindowSelector::OnWindowActivated(aura::Window* gained_active,
                                        aura::Window* lost_active) {
-  if (ignore_activations_ || !gained_active)
+  if (ignore_activations_ ||
+      !gained_active ||
+      gained_active == text_filter_widget_->GetNativeWindow()) {
     return;
+  }
 
   ScopedVector<WindowGrid>::iterator grid =
       std::find_if(grid_list_.begin(), grid_list_.end(),
                    RootWindowGridComparator(gained_active->GetRootWindow()));
   if (grid == grid_list_.end())
     return;
   const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
 
   ScopedVector<WindowSelectorItem>::const_iterator iter = std::find_if(
       windows.begin(), windows.end(),
       WindowSelectorItemTargetComparator(gained_active));
 
   if (iter != windows.end())
     (*iter)->RestoreWindowOnExit(gained_active);
 
   // Don't restore focus on exit if a window was just activated.
   ResetFocusRestoreWindow(false);
   CancelSelection();
 }
 
 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
                                                  aura::Window* actual_active) {
   OnWindowActivated(request_active, actual_active);
 }
 
+void WindowSelector::ContentsChanged(views::Textfield* sender,
+                                     const base::string16& new_contents) {
+  if (!showing_selection_widget_ || new_contents.empty()) {

[flackr, 2014/06/26 17:33:07]

We did say this should be behind a flag right? Can you add a flag which if not
set you won't be able to search? You can and still should create the hidden
textbox to handle input as this makes the design much cleaner, thanks again for
doing it this way!

[Nina, 2014/06/27 15:20:39]

Added --disable* flag

+    ui::ScopedLayerAnimationSettings animation_settings(
+        text_filter_widget_->GetNativeWindow()->layer()->GetAnimator());
+    animation_settings.SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+    animation_settings.SetTweenType(showing_selection_widget_ ?
+        gfx::Tween::FAST_OUT_LINEAR_IN : gfx::Tween::LINEAR_OUT_SLOW_IN);
+    size_t root_window_width = Shell::GetPrimaryRootWindow()->bounds().width();
+    text_filter_widget_->SetBounds(
+        gfx::Rect(root_window_width / 4, 0,root_window_width / 2,
+                  showing_selection_widget_ ? 0 : 50));

[flackr, 2014/06/26 17:33:07]

To do this animation on the compositor this should use a translate transform to
slide in from above the screen. I believe bounds animations (especially when the
height changes) require re-rastering every frame.

Also, use a constant for the 50.

[Nina, 2014/06/27 15:20:39]

Done!

+    showing_selection_widget_ = !showing_selection_widget_;
+  }
+  for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
+       iter != grid_list_.end(); iter++) {
+    (*iter)->FilterItems(new_contents);
+  }
+}
+
 void WindowSelector::PositionWindows(bool animate) {
   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
       iter != grid_list_.end(); iter++) {
     (*iter)->PositionWindows(animate);
   }
 }
 
 void WindowSelector::HideAndTrackNonOverviewWindows() {
   // Add the windows to hidden_windows first so that if any are destroyed
   // while hiding them they are tracked.
@@ skipping 56 matching lines @@
     // root window, identify it and call Move() on it to initialize the
     // selection widget.
     // TODO(nsatragno): If there are more than two monitors, move between grids
     // in the requested direction.
     selected_grid_index_ = (selected_grid_index_ + 1) % grid_list_.size();
     grid_list_[selected_grid_index_]->Move(direction);
   }
 }
 
 }  // namespace ash