Added text filtering to Overview Mode

ash/wm/overview/window_grid.cc

 // Copyright 2014 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_grid.h"
 
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/overview/scoped_transform_overview_window.h"
 #include "ash/wm/overview/window_selector.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/overview/window_selector_panels.h"
 #include "ash/wm/overview/window_selector_window.h"
 #include "ash/wm/window_state.h"
+#include "base/i18n/string_search.h"
 #include "base/memory/scoped_vector.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/vector2d.h"
 #include "ui/views/background.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
@@ skipping 164 matching lines @@
       static_cast<int>(total_bounds.width() / num_columns_),
       static_cast<int>(total_bounds.height() * kCardAspectRatio / num_rows)));
   window_size.set_height(window_size.width() / kCardAspectRatio);
 
   // Calculate the X and Y offsets necessary to center the grid.
   int x_offset = total_bounds.x() + ((window_list_.size() >= num_columns_ ? 0 :
       (num_columns_ - window_list_.size()) * window_size.width()) +
       (total_bounds.width() - num_columns_ * window_size.width())) / 2;
   int y_offset = total_bounds.y() + (total_bounds.height() -
       num_rows * window_size.height()) / 2;
+
   for (size_t i = 0; i < window_list_.size(); ++i) {
     gfx::Transform transform;
     int column = i % num_columns_;
     int row = i / num_columns_;
     gfx::Rect target_bounds(window_size.width() * column + x_offset,
                             window_size.height() * row + y_offset,
                             window_size.width(),
                             window_size.height());
     window_list_[i]->SetBounds(root_window_, target_bounds, animate);
   }
 
   // If we have less than |kMinCardsMajor| windows, adjust the column_ value to
   // reflect how many "real" columns we have.
   if (num_columns_ > window_list_.size())
     num_columns_ = window_list_.size();
 
   // If the selection widget is active, reposition it without any animation.
   if (selection_widget_)
     MoveSelectionWidgetToTarget(animate);
 }
 
-bool WindowGrid::Move(WindowSelector::Direction direction) {
+bool WindowGrid::Move(WindowSelector::Direction direction, bool animate) {
   bool recreate_selection_widget = false;
   bool out_of_bounds = false;
   if (!selection_widget_) {
     switch (direction) {
      case WindowSelector::LEFT:
        selected_index_ = window_list_.size() - 1;
        break;
      case WindowSelector::UP:
        selected_index_ =
            (window_list_.size() / num_columns_) * num_columns_ - 1;
        break;
      case WindowSelector::RIGHT:
      case WindowSelector::DOWN:
        selected_index_ = 0;
        break;
      }
-  } else {
+  }
+  while (SelectedWindow()->dimmed() || selection_widget_) {
     switch (direction) {
       case WindowSelector::RIGHT:
         if (selected_index_ >= window_list_.size() - 1)
           out_of_bounds = true;
         selected_index_++;
         if (selected_index_ % num_columns_ == 0)
           recreate_selection_widget = true;
         break;
       case WindowSelector::LEFT:
         if (selected_index_ == 0)
@@ skipping 16 matching lines @@
           out_of_bounds = true;
         if (selected_index_ < num_columns_) {
           selected_index_ += num_columns_ *
               ((window_list_.size() - selected_index_) / num_columns_) - 1;
           recreate_selection_widget = true;
         } else {
           selected_index_ -= num_columns_;
         }
         break;
     }
+    // Exit the loop if we broke free from the grid or found an active item.
+    if (out_of_bounds || !SelectedWindow()->dimmed())
+      break;
   }
 
-  MoveSelectionWidget(direction, recreate_selection_widget, out_of_bounds);
+  MoveSelectionWidget(direction, recreate_selection_widget,
+                      out_of_bounds, animate);
   return out_of_bounds;
 }
 
 WindowSelectorItem* WindowGrid::SelectedWindow() const {
   CHECK(selected_index_ < window_list_.size());
   return window_list_[selected_index_];
 }
 
 bool WindowGrid::Contains(const aura::Window* window) const {
   return std::find_if(window_list_.begin(), window_list_.end(),
                       WindowSelectorItemTargetComparator(window)) !=
                           window_list_.end();
 }
 
+void WindowGrid::FilterItems(const base::string16& pattern) {
+  base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents finder(pattern);
+  for (ScopedVector<WindowSelectorItem>::iterator iter = window_list_.begin();
+       iter != window_list_.end(); iter++) {
+    if (finder.Search((*iter)->SelectionWindow()->title(), NULL, NULL)) {
+      (*iter)->SetDimmed(false);
+    } else {
+      (*iter)->SetDimmed(true);
+      if (selection_widget_ && SelectedWindow() == *iter)
+        selection_widget_.reset();
+    }
+  }
+}
+
 void WindowGrid::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
   observed_windows_.erase(window);
   ScopedVector<WindowSelectorItem>::iterator iter =
       std::find_if(window_list_.begin(), window_list_.end(),
                    WindowSelectorItemComparator(window));
 
   DCHECK(iter != window_list_.end());
 
   (*iter)->RemoveWindow(window);
@@ skipping 74 matching lines @@
   gfx::Vector2d fade_out_direction =
           GetSlideVectorForFadeIn(direction, target_bounds);
   gfx::Display dst_display = gfx::Screen::GetScreenFor(root_window_)->
       GetDisplayMatching(target_bounds);
   selection_widget_->GetNativeWindow()->SetBoundsInScreen(
       target_bounds - fade_out_direction, dst_display);
 }
 
 void WindowGrid::MoveSelectionWidget(WindowSelector::Direction direction,
                                      bool recreate_selection_widget,
-                                     bool out_of_bounds) {
+                                     bool out_of_bounds,
+                                     bool animate) {
   // If the selection widget is already active, fade it out in the selection
   // direction.
   if (selection_widget_ && (recreate_selection_widget || out_of_bounds)) {
     // Animate the old selection widget and then destroy it.
     views::Widget* old_selection = selection_widget_.get();
     gfx::Vector2d fade_out_direction =
         GetSlideVectorForFadeIn(
             direction, old_selection->GetNativeWindow()->bounds());
 
     ui::ScopedLayerAnimationSettings animation_settings(
@@ skipping 16 matching lines @@
   if (out_of_bounds)
     return;
 
   if (!selection_widget_)
     InitSelectionWidget(direction);
   // Send an a11y alert so that if ChromeVox is enabled, the item label is
   // read.
   SelectedWindow()->SendFocusAlert();
   // The selection widget is moved to the newly selected item in the same
   // grid.
-  MoveSelectionWidgetToTarget(true);
+  MoveSelectionWidgetToTarget(animate);
 }
 
 void WindowGrid::MoveSelectionWidgetToTarget(bool animate) {
   if (animate) {
     ui::ScopedLayerAnimationSettings animation_settings(
         selection_widget_->GetNativeWindow()->layer()->GetAnimator());
     animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
         kOverviewSelectorTransitionMilliseconds));
     animation_settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
     animation_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     selection_widget_->SetBounds(SelectedWindow()->target_bounds());
     selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
     return;
   }
   selection_widget_->SetBounds(SelectedWindow()->target_bounds());
   selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
 }
 
 }  // namespace ash