Home | History | Annotate | Download | only in overview 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ash/wm/overview/window_grid.h"
      6 
      7 #include "ash/ash_switches.h"
      8 #include "ash/screen_util.h"
      9 #include "ash/shell.h"
     10 #include "ash/shell_window_ids.h"
     11 #include "ash/wm/overview/scoped_transform_overview_window.h"
     12 #include "ash/wm/overview/window_selector.h"
     13 #include "ash/wm/overview/window_selector_item.h"
     14 #include "ash/wm/overview/window_selector_panels.h"
     15 #include "ash/wm/overview/window_selector_window.h"
     16 #include "ash/wm/window_state.h"
     17 #include "base/command_line.h"
     18 #include "base/i18n/string_search.h"
     19 #include "base/memory/scoped_vector.h"
     20 #include "third_party/skia/include/core/SkColor.h"
     21 #include "ui/aura/window.h"
     22 #include "ui/compositor/layer_animation_observer.h"
     23 #include "ui/compositor/scoped_layer_animation_settings.h"
     24 #include "ui/gfx/animation/tween.h"
     25 #include "ui/gfx/vector2d.h"
     26 #include "ui/views/background.h"
     27 #include "ui/views/view.h"
     28 #include "ui/views/widget/widget.h"
     29 #include "ui/wm/core/window_animations.h"
     30 
     31 namespace ash {
     32 namespace {
     33 
     34 // An observer which holds onto the passed widget until the animation is
     35 // complete.
     36 class CleanupWidgetAfterAnimationObserver
     37     : public ui::ImplicitAnimationObserver {
     38  public:
     39   explicit CleanupWidgetAfterAnimationObserver(
     40       scoped_ptr<views::Widget> widget);
     41   virtual ~CleanupWidgetAfterAnimationObserver();
     42 
     43   // ui::ImplicitAnimationObserver:
     44   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
     45 
     46  private:
     47   scoped_ptr<views::Widget> widget_;
     48 
     49   DISALLOW_COPY_AND_ASSIGN(CleanupWidgetAfterAnimationObserver);
     50 };
     51 
     52 CleanupWidgetAfterAnimationObserver::CleanupWidgetAfterAnimationObserver(
     53     scoped_ptr<views::Widget> widget)
     54     : widget_(widget.Pass()) {
     55 }
     56 
     57 CleanupWidgetAfterAnimationObserver::~CleanupWidgetAfterAnimationObserver() {
     58 }
     59 
     60 void CleanupWidgetAfterAnimationObserver::OnImplicitAnimationsCompleted() {
     61   delete this;
     62 }
     63 
     64 // A comparator for locating a given target window.
     65 struct WindowSelectorItemComparator
     66     : public std::unary_function<WindowSelectorItem*, bool> {
     67   explicit WindowSelectorItemComparator(const aura::Window* target_window)
     68       : target(target_window) {
     69   }
     70 
     71   bool operator()(WindowSelectorItem* window) const {
     72     return window->HasSelectableWindow(target);
     73   }
     74 
     75   const aura::Window* target;
     76 };
     77 
     78 // A comparator for locating a WindowSelectorItem given a targeted window.
     79 struct WindowSelectorItemTargetComparator
     80     : public std::unary_function<WindowSelectorItem*, bool> {
     81   explicit WindowSelectorItemTargetComparator(const aura::Window* target_window)
     82       : target(target_window) {
     83   }
     84 
     85   bool operator()(WindowSelectorItem* window) const {
     86     return window->Contains(target);
     87   }
     88 
     89   const aura::Window* target;
     90 };
     91 
     92 // Conceptually the window overview is a table or grid of cells having this
     93 // fixed aspect ratio. The number of columns is determined by maximizing the
     94 // area of them based on the number of window_list.
     95 const float kCardAspectRatio = 4.0f / 3.0f;
     96 
     97 // The minimum number of cards along the major axis (i.e. horizontally on a
     98 // landscape orientation).
     99 const int kMinCardsMajor = 3;
    100 
    101 const int kOverviewSelectorTransitionMilliseconds = 100;
    102 
    103 // The color and opacity of the overview selector.
    104 const SkColor kWindowOverviewSelectionColor = SK_ColorBLACK;
    105 const unsigned char kWindowOverviewSelectorOpacity = 128;
    106 
    107 // The minimum amount of spacing between the bottom of the text filtering
    108 // text field and the top of the selection widget on the first row of items.
    109 const int kTextFilterBottomMargin = 5;
    110 
    111 // Returns the vector for the fade in animation.
    112 gfx::Vector2d GetSlideVectorForFadeIn(WindowSelector::Direction direction,
    113                                       const gfx::Rect& bounds) {
    114   gfx::Vector2d vector;
    115   switch (direction) {
    116     case WindowSelector::DOWN:
    117       vector.set_y(bounds.width());
    118       break;
    119     case WindowSelector::RIGHT:
    120       vector.set_x(bounds.height());
    121       break;
    122     case WindowSelector::UP:
    123       vector.set_y(-bounds.width());
    124       break;
    125     case WindowSelector::LEFT:
    126       vector.set_x(-bounds.height());
    127       break;
    128   }
    129   return vector;
    130 }
    131 
    132 }  // namespace
    133 
    134 WindowGrid::WindowGrid(aura::Window* root_window,
    135                        const std::vector<aura::Window*>& windows,
    136                        WindowSelector* window_selector)
    137     : root_window_(root_window),
    138       window_selector_(window_selector) {
    139   WindowSelectorPanels* panels_item = NULL;
    140   for (aura::Window::Windows::const_iterator iter = windows.begin();
    141        iter != windows.end(); ++iter) {
    142     if ((*iter)->GetRootWindow() != root_window)
    143       continue;
    144     (*iter)->AddObserver(this);
    145     observed_windows_.insert(*iter);
    146 
    147     if ((*iter)->type() == ui::wm::WINDOW_TYPE_PANEL &&
    148         wm::GetWindowState(*iter)->panel_attached()) {
    149       // Attached panel windows are grouped into a single overview item per
    150       // grid.
    151       if (!panels_item) {
    152         panels_item = new WindowSelectorPanels(root_window_);
    153         window_list_.push_back(panels_item);
    154       }
    155       panels_item->AddWindow(*iter);
    156     } else {
    157       window_list_.push_back(new WindowSelectorWindow(*iter));
    158     }
    159   }
    160   if (window_list_.empty())
    161     return;
    162 }
    163 
    164 WindowGrid::~WindowGrid() {
    165   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
    166        iter != observed_windows_.end(); iter++) {
    167     (*iter)->RemoveObserver(this);
    168   }
    169 }
    170 
    171 void WindowGrid::PrepareForOverview() {
    172   for (ScopedVector<WindowSelectorItem>::iterator iter = window_list_.begin();
    173        iter != window_list_.end(); ++iter) {
    174     (*iter)->PrepareForOverview();
    175   }
    176 }
    177 
    178 void WindowGrid::PositionWindows(bool animate) {
    179   CHECK(!window_list_.empty());
    180 
    181   gfx::Size window_size;
    182   gfx::Rect total_bounds = ScreenUtil::ConvertRectToScreen(
    183       root_window_,
    184       ScreenUtil::GetDisplayWorkAreaBoundsInParent(
    185           Shell::GetContainer(root_window_, kShellWindowId_DefaultContainer)));
    186 
    187   // If the text filtering feature is enabled, reserve space at the top for the
    188   // text filtering textbox to appear.
    189   if (!CommandLine::ForCurrentProcess()->HasSwitch(
    190           switches::kAshDisableTextFilteringInOverviewMode)) {
    191     total_bounds.Inset(
    192         0,
    193         WindowSelector::kTextFilterBottomEdge + kTextFilterBottomMargin,
    194         0,
    195         0);
    196   }
    197 
    198   // Find the minimum number of windows per row that will fit all of the
    199   // windows on screen.
    200   num_columns_ = std::max(
    201       total_bounds.width() > total_bounds.height() ? kMinCardsMajor : 1,
    202       static_cast<int>(ceil(sqrt(total_bounds.width() * window_list_.size() /
    203                                  (kCardAspectRatio * total_bounds.height())))));
    204   int num_rows = ((window_list_.size() + num_columns_ - 1) / num_columns_);
    205   window_size.set_width(std::min(
    206       static_cast<int>(total_bounds.width() / num_columns_),
    207       static_cast<int>(total_bounds.height() * kCardAspectRatio / num_rows)));
    208   window_size.set_height(window_size.width() / kCardAspectRatio);
    209 
    210   // Calculate the X and Y offsets necessary to center the grid.
    211   int x_offset = total_bounds.x() + ((window_list_.size() >= num_columns_ ? 0 :
    212       (num_columns_ - window_list_.size()) * window_size.width()) +
    213       (total_bounds.width() - num_columns_ * window_size.width())) / 2;
    214   int y_offset = total_bounds.y() + (total_bounds.height() -
    215       num_rows * window_size.height()) / 2;
    216 
    217   for (size_t i = 0; i < window_list_.size(); ++i) {
    218     gfx::Transform transform;
    219     int column = i % num_columns_;
    220     int row = i / num_columns_;
    221     gfx::Rect target_bounds(window_size.width() * column + x_offset,
    222                             window_size.height() * row + y_offset,
    223                             window_size.width(),
    224                             window_size.height());
    225     window_list_[i]->SetBounds(root_window_, target_bounds, animate);
    226   }
    227 
    228   // If we have less than |kMinCardsMajor| windows, adjust the column_ value to
    229   // reflect how many "real" columns we have.
    230   if (num_columns_ > window_list_.size())
    231     num_columns_ = window_list_.size();
    232 
    233   // If the selection widget is active, reposition it without any animation.
    234   if (selection_widget_)
    235     MoveSelectionWidgetToTarget(animate);
    236 }
    237 
    238 bool WindowGrid::Move(WindowSelector::Direction direction, bool animate) {
    239   bool recreate_selection_widget = false;
    240   bool out_of_bounds = false;
    241   if (!selection_widget_) {
    242     switch (direction) {
    243      case WindowSelector::LEFT:
    244        selected_index_ = window_list_.size() - 1;
    245        break;
    246      case WindowSelector::UP:
    247        selected_index_ =
    248            (window_list_.size() / num_columns_) * num_columns_ - 1;
    249        break;
    250      case WindowSelector::RIGHT:
    251      case WindowSelector::DOWN:
    252        selected_index_ = 0;
    253        break;
    254      }
    255   }
    256   while (SelectedWindow()->dimmed() || selection_widget_) {
    257     switch (direction) {
    258       case WindowSelector::RIGHT:
    259         if (selected_index_ >= window_list_.size() - 1)
    260           out_of_bounds = true;
    261         selected_index_++;
    262         if (selected_index_ % num_columns_ == 0)
    263           recreate_selection_widget = true;
    264         break;
    265       case WindowSelector::LEFT:
    266         if (selected_index_ == 0)
    267           out_of_bounds = true;
    268         selected_index_--;
    269         if ((selected_index_ + 1) % num_columns_ == 0)
    270           recreate_selection_widget = true;
    271         break;
    272       case WindowSelector::DOWN:
    273         selected_index_ += num_columns_;
    274         if (selected_index_ >= window_list_.size()) {
    275           selected_index_ = (selected_index_ + 1) % num_columns_;
    276           if (selected_index_ == 0)
    277             out_of_bounds = true;
    278           recreate_selection_widget = true;
    279         }
    280         break;
    281       case WindowSelector::UP:
    282         if (selected_index_ == 0)
    283           out_of_bounds = true;
    284         if (selected_index_ < num_columns_) {
    285           selected_index_ += num_columns_ *
    286               ((window_list_.size() - selected_index_) / num_columns_) - 1;
    287           recreate_selection_widget = true;
    288         } else {
    289           selected_index_ -= num_columns_;
    290         }
    291         break;
    292     }
    293     // Exit the loop if we broke free from the grid or found an active item.
    294     if (out_of_bounds || !SelectedWindow()->dimmed())
    295       break;
    296   }
    297 
    298   MoveSelectionWidget(direction, recreate_selection_widget,
    299                       out_of_bounds, animate);
    300   return out_of_bounds;
    301 }
    302 
    303 WindowSelectorItem* WindowGrid::SelectedWindow() const {
    304   CHECK(selected_index_ < window_list_.size());
    305   return window_list_[selected_index_];
    306 }
    307 
    308 bool WindowGrid::Contains(const aura::Window* window) const {
    309   return std::find_if(window_list_.begin(), window_list_.end(),
    310                       WindowSelectorItemTargetComparator(window)) !=
    311                           window_list_.end();
    312 }
    313 
    314 void WindowGrid::FilterItems(const base::string16& pattern) {
    315   base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents finder(pattern);
    316   for (ScopedVector<WindowSelectorItem>::iterator iter = window_list_.begin();
    317        iter != window_list_.end(); iter++) {
    318     if (finder.Search((*iter)->SelectionWindow()->title(), NULL, NULL)) {
    319       (*iter)->SetDimmed(false);
    320     } else {
    321       (*iter)->SetDimmed(true);
    322       if (selection_widget_ && SelectedWindow() == *iter)
    323         selection_widget_.reset();
    324     }
    325   }
    326 }
    327 
    328 void WindowGrid::OnWindowDestroying(aura::Window* window) {
    329   window->RemoveObserver(this);
    330   observed_windows_.erase(window);
    331   ScopedVector<WindowSelectorItem>::iterator iter =
    332       std::find_if(window_list_.begin(), window_list_.end(),
    333                    WindowSelectorItemComparator(window));
    334 
    335   DCHECK(iter != window_list_.end());
    336 
    337   (*iter)->RemoveWindow(window);
    338 
    339   // If there are still windows in this selector entry then the overview is
    340   // still active and the active selection remains the same.
    341   if (!(*iter)->empty())
    342     return;
    343 
    344   size_t removed_index = iter - window_list_.begin();
    345   window_list_.erase(iter);
    346 
    347   if (empty()) {
    348     // If the grid is now empty, notify the window selector so that it erases us
    349     // from its grid list.
    350     window_selector_->OnGridEmpty(this);
    351     return;
    352   }
    353 
    354   // If selecting, update the selection index.
    355   if (selection_widget_) {
    356     bool send_focus_alert = selected_index_ == removed_index;
    357     if (selected_index_ >= removed_index && selected_index_ != 0)
    358       selected_index_--;
    359     if (send_focus_alert)
    360       SelectedWindow()->SendFocusAlert();
    361   }
    362 
    363   PositionWindows(true);
    364 }
    365 
    366 void WindowGrid::OnWindowBoundsChanged(aura::Window* window,
    367                                        const gfx::Rect& old_bounds,
    368                                        const gfx::Rect& new_bounds) {
    369   ScopedVector<WindowSelectorItem>::const_iterator iter =
    370       std::find_if(window_list_.begin(), window_list_.end(),
    371                    WindowSelectorItemTargetComparator(window));
    372   DCHECK(iter != window_list_.end());
    373 
    374   // Immediately finish any active bounds animation.
    375   window->layer()->GetAnimator()->StopAnimatingProperty(
    376       ui::LayerAnimationElement::BOUNDS);
    377 
    378   // Recompute the transform for the window.
    379   (*iter)->RecomputeWindowTransforms();
    380 }
    381 
    382 void WindowGrid::InitSelectionWidget(WindowSelector::Direction direction) {
    383   selection_widget_.reset(new views::Widget);
    384   views::Widget::InitParams params;
    385   params.type = views::Widget::InitParams::TYPE_POPUP;
    386   params.keep_on_top = false;
    387   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
    388   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
    389   params.parent = Shell::GetContainer(root_window_,
    390                                       kShellWindowId_DefaultContainer);
    391   params.accept_events = false;
    392   selection_widget_->set_focus_on_creation(false);
    393   selection_widget_->Init(params);
    394   // Disable the "bounce in" animation when showing the window.
    395   ::wm::SetWindowVisibilityAnimationTransition(
    396       selection_widget_->GetNativeWindow(), ::wm::ANIMATE_NONE);
    397   // The selection widget should not activate the shelf when passing under it.
    398   ash::wm::GetWindowState(selection_widget_->GetNativeWindow())->
    399       set_ignored_by_shelf(true);
    400 
    401   views::View* content_view = new views::View;
    402   content_view->set_background(
    403       views::Background::CreateSolidBackground(kWindowOverviewSelectionColor));
    404   selection_widget_->SetContentsView(content_view);
    405   selection_widget_->GetNativeWindow()->parent()->StackChildAtBottom(
    406       selection_widget_->GetNativeWindow());
    407   selection_widget_->Show();
    408   // New selection widget starts with 0 opacity and then fades in.
    409   selection_widget_->GetNativeWindow()->layer()->SetOpacity(0);
    410 
    411   const gfx::Rect target_bounds = SelectedWindow()->target_bounds();
    412   gfx::Vector2d fade_out_direction =
    413           GetSlideVectorForFadeIn(direction, target_bounds);
    414   gfx::Display dst_display = gfx::Screen::GetScreenFor(root_window_)->
    415       GetDisplayMatching(target_bounds);
    416   selection_widget_->GetNativeWindow()->SetBoundsInScreen(
    417       target_bounds - fade_out_direction, dst_display);
    418 }
    419 
    420 void WindowGrid::MoveSelectionWidget(WindowSelector::Direction direction,
    421                                      bool recreate_selection_widget,
    422                                      bool out_of_bounds,
    423                                      bool animate) {
    424   // If the selection widget is already active, fade it out in the selection
    425   // direction.
    426   if (selection_widget_ && (recreate_selection_widget || out_of_bounds)) {
    427     // Animate the old selection widget and then destroy it.
    428     views::Widget* old_selection = selection_widget_.get();
    429     gfx::Vector2d fade_out_direction =
    430         GetSlideVectorForFadeIn(
    431             direction, old_selection->GetNativeWindow()->bounds());
    432 
    433     ui::ScopedLayerAnimationSettings animation_settings(
    434         old_selection->GetNativeWindow()->layer()->GetAnimator());
    435     animation_settings.SetTransitionDuration(
    436         base::TimeDelta::FromMilliseconds(
    437             kOverviewSelectorTransitionMilliseconds));
    438     animation_settings.SetPreemptionStrategy(
    439         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
    440     animation_settings.SetTweenType(gfx::Tween::FAST_OUT_LINEAR_IN);
    441     // CleanupWidgetAfterAnimationObserver will delete itself (and the
    442     // widget) when the movement animation is complete.
    443     animation_settings.AddObserver(
    444         new CleanupWidgetAfterAnimationObserver(selection_widget_.Pass()));
    445     old_selection->SetOpacity(0);
    446     old_selection->GetNativeWindow()->SetBounds(
    447         old_selection->GetNativeWindow()->bounds() + fade_out_direction);
    448     old_selection->Hide();
    449   }
    450   if (out_of_bounds)
    451     return;
    452 
    453   if (!selection_widget_)
    454     InitSelectionWidget(direction);
    455   // Send an a11y alert so that if ChromeVox is enabled, the item label is
    456   // read.
    457   SelectedWindow()->SendFocusAlert();
    458   // The selection widget is moved to the newly selected item in the same
    459   // grid.
    460   MoveSelectionWidgetToTarget(animate);
    461 }
    462 
    463 void WindowGrid::MoveSelectionWidgetToTarget(bool animate) {
    464   if (animate) {
    465     ui::ScopedLayerAnimationSettings animation_settings(
    466         selection_widget_->GetNativeWindow()->layer()->GetAnimator());
    467     animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
    468         kOverviewSelectorTransitionMilliseconds));
    469     animation_settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
    470     animation_settings.SetPreemptionStrategy(
    471         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
    472     selection_widget_->SetBounds(SelectedWindow()->target_bounds());
    473     selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
    474     return;
    475   }
    476   selection_widget_->SetBounds(SelectedWindow()->target_bounds());
    477   selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
    478 }
    479 
    480 }  // namespace ash
    481