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/command_line.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 {
 
+// The proportion of screen width that the text filter takes.
+const float kTextFilterScreenProportion = 0.5;
+
+// The height of the text filter.
+const int kTextFilterHeight = 50;
+
+// Solid shadow length from the text filter.
+const int kVerticalShadowOffset = 1;
+
+// Amount of blur applied to the text filter shadow.
+const int kShadowBlur = 10;
+
+// Text filter shadow color.
+const SkColor kTextFilterShadow = 0xB0000000;
+
 // A comparator for locating a grid with a given root window.
 struct RootWindowGridComparator
     : public std::unary_function<WindowGrid*, bool> {
   explicit RootWindowGridComparator(const aura::Window* root_window)
       : root_window_(root_window) {
   }
 
   bool operator()(WindowGrid* grid) const {
     return (grid->root_window() == root_window_);
   }
@@ skipping 33 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() / 2 * (1 - kTextFilterScreenProportion),
+      -kTextFilterHeight,

[flackr, 2014/06/27 20:00:06]

Should this be created at 0 and transformed to -kTextFilterHeight so that it's
ready to slide in?

[Nina, 2014/06/27 22:42:02]

Done.

+      root_window->bounds().width() * kTextFilterScreenProportion,
+      kTextFilterHeight);
+  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->set_shadows(gfx::ShadowValues(1, gfx::ShadowValue(
+      gfx::Point(0, kVerticalShadowOffset), kShadowBlur, kTextFilterShadow)));
+  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) {
   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()));

[flackr, 2014/06/27 20:00:07]

Do we have to worry about the text input element losing focus? Maybe we should
exit overview mode if that happens? If you don't think it can happen without
another window being activated (which would cause us to exit overview mode) then
that's fine.

[Nina, 2014/06/27 22:42:02]

I really don't think it can happen, as we are observing most of the containers,
and when a window is activated we just cancel the overview.

+
   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);
+      Move(WindowSelector::UP, true);
       break;
     case ui::VKEY_DOWN:
       num_key_presses_++;
-      Move(WindowSelector::DOWN);
+      Move(WindowSelector::DOWN, true);
       break;
     case ui::VKEY_RIGHT:
       num_key_presses_++;
-      Move(WindowSelector::RIGHT);
+      Move(WindowSelector::RIGHT, true);
       break;
     case ui::VKEY_LEFT:
       num_key_presses_++;
-      Move(WindowSelector::LEFT);
+      Move(WindowSelector::LEFT, true);
       break;
     case ui::VKEY_RETURN:
       // Ignore if no item is selected.
       if (!grid_list_[selected_grid_index_]->is_selecting())
-        return;
+        return true;

[flackr, 2014/06/27 20:00:06]

Isn't this technically not handled? Should we return false here?

[Nina, 2014/06/27 22:42:01]

Well, apparently both options have the same effect, and since we don't want
enter to do anything besides selecting, I think returning true is the best
course of action.

       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 (CommandLine::ForCurrentProcess()->HasSwitch(
+               switches::kAshDisableTextFilteringInOverviewMode)) {

[flackr, 2014/06/27 20:00:06]

nit: Indend 4 from '(', I guess a total of 10 spaces?

[Nina, 2014/06/27 22:42:02]

Damn Eclipse!

+    return;
+  }

[flackr, 2014/06/27 20:00:06]

nit: blank line to separate this early return from rest of method.

[Nina, 2014/06/27 22:42:02]

Done.

+  if (!showing_selection_widget_ || new_contents.empty()) {

[flackr, 2014/06/27 20:00:06]

nit: To make sure this always does the right thing (when other people change
it), I'd suggest adding a bool should_should_selection_widget =
!new_contents.empty();
Then if can be:
if (showing_selection_widget_ != should_should_selection_widget)
And you can update showing_... to be should_show_... at the end of the block.

[Nina, 2014/06/27 22:42:01]

I'll take you meant should_show_*. Done.

+    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);
+
+    gfx::Transform transform;
+    if (showing_selection_widget_)

[flackr, 2014/06/27 20:00:06]

This is confusing because you're doing the opposite of
showing_selection_widget_, i think my suggestion above will fix the confusion
though.

[Nina, 2014/06/27 22:42:02]

Done.

+      transform.Translate(0, -kTextFilterHeight);
+    else
+      transform.Translate(0, kTextFilterHeight);

[flackr, 2014/06/27 20:00:06]

This should just be transformed to (0, 0), we should initialize it to be
transformed offscreen.

[Nina, 2014/06/27 22:42:01]

Done.

+
+    text_filter_widget_->GetNativeWindow()->SetTransform(transform);
+    showing_selection_widget_ = !showing_selection_widget_;
+  }
+  for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
+       iter != grid_list_.end(); iter++) {
+    (*iter)->FilterItems(new_contents);
+  }
+
+  // If the selection widget is not active, execute a Move() command so that it
+  // shows up on the first undimmed item.
+  if (grid_list_[selected_grid_index_]->is_selecting())
+    return;
+  Move(WindowSelector::RIGHT, false);
+}
+
 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 42 matching lines @@
   }
   // If the window is in the observed_windows_ list it needs to continue to be
   // observed.
   if (observed_windows_.find(restore_focus_window_) ==
           observed_windows_.end()) {
     restore_focus_window_->RemoveObserver(this);
   }
   restore_focus_window_ = NULL;
 }
 
-void WindowSelector::Move(Direction direction) {
-  bool overflowed = grid_list_[selected_grid_index_]->Move(direction);
-  if (overflowed) {
-    // The grid reported that the movement command corresponds to the next
-    // root window, identify it and call Move() on it to initialize the
-    // selection widget.
+void WindowSelector::Move(Direction direction, bool animate) {
+  // Keep calling Move() on the grids until one of them reports no overflow or
+  // we made a full cycle on all the grids.
+  for (size_t i = 0;
+      i <= grid_list_.size() &&
+      grid_list_[selected_grid_index_]->Move(direction, animate); i++) {
     // 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