src/ash/wm/overview/window_selector.cc

   1 // Copyright 2013 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_selector.h"
   6
   7 #include <algorithm>
   8
   9 #include "ash/accessibility_delegate.h"
  10 #include "ash/ash_switches.h"
  11 #include "ash/metrics/user_metrics_recorder.h"
  12 #include "ash/root_window_controller.h"
  13 #include "ash/shell.h"
  14 #include "ash/shell_window_ids.h"
  15 #include "ash/switchable_windows.h"
  16 #include "ash/wm/overview/scoped_transform_overview_window.h"
  17 #include "ash/wm/overview/window_grid.h"
  18 #include "ash/wm/overview/window_selector_delegate.h"
  19 #include "ash/wm/overview/window_selector_item.h"
  20 #include "ash/wm/window_state.h"
  21 #include "base/auto_reset.h"
  22 #include "base/metrics/histogram.h"
  23 #include "ui/aura/client/focus_client.h"
  24 #include "ui/aura/window.h"
  25 #include "ui/aura/window_event_dispatcher.h"
  26 #include "ui/aura/window_observer.h"
  27 #include "ui/compositor/scoped_layer_animation_settings.h"
  28 #include "ui/events/event.h"
  29 #include "ui/gfx/screen.h"
  30 #include "ui/wm/core/window_util.h"
  31 #include "ui/wm/public/activation_client.h"
  32
  33 namespace ash {
  34
  35 namespace {
  36
  37 // A comparator for locating a grid with a given root window.
  38 struct RootWindowGridComparator
  39     : public std::unary_function<WindowGrid*, bool> {
  40   explicit RootWindowGridComparator(const aura::Window* root_window)
  41       : root_window_(root_window) {
  42   }
  43
  44   bool operator()(WindowGrid* grid) const {
  45     return (grid->root_window() == root_window_);
  46   }
  47
  48   const aura::Window* root_window_;
  49 };
  50
  51 // A comparator for locating a selectable window given a targeted window.
  52 struct WindowSelectorItemTargetComparator
  53     : public std::unary_function<WindowSelectorItem*, bool> {
  54   explicit WindowSelectorItemTargetComparator(const aura::Window* target_window)
  55       : target(target_window) {
  56   }
  57
  58   bool operator()(WindowSelectorItem* window) const {
  59     return window->Contains(target);
  60   }
  61
  62   const aura::Window* target;
  63 };
  64
  65 // A comparator for locating a selector item for a given root.
  66 struct WindowSelectorItemForRoot
  67     : public std::unary_function<WindowSelectorItem*, bool> {
  68   explicit WindowSelectorItemForRoot(const aura::Window* root)
  69       : root_window(root) {
  70   }
  71
  72   bool operator()(WindowSelectorItem* item) const {
  73     return item->GetRootWindow() == root_window;
  74   }
  75
  76   const aura::Window* root_window;
  77 };
  78
  79 // Triggers a shelf visibility update on all root window controllers.
  80 void UpdateShelfVisibility() {
  81   Shell::RootWindowControllerList root_window_controllers =
  82       Shell::GetInstance()->GetAllRootWindowControllers();
  83   for (Shell::RootWindowControllerList::iterator iter =
  84           root_window_controllers.begin();
  85        iter != root_window_controllers.end(); ++iter) {
  86     (*iter)->UpdateShelfVisibility();
  87   }
  88 }
  89
  90 }  // namespace
  91
  92 WindowSelector::WindowSelector(const WindowList& windows,
  93                                WindowSelectorDelegate* delegate)
  94     : delegate_(delegate),
  95       restore_focus_window_(aura::client::GetFocusClient(
  96           Shell::GetPrimaryRootWindow())->GetFocusedWindow()),
  97       ignore_activations_(false),
  98       selected_grid_index_(0),
  99       overview_start_time_(base::Time::Now()),
 100       num_key_presses_(0),
 101       num_items_(0) {
 102   DCHECK(delegate_);
 103   Shell* shell = Shell::GetInstance();
 104   shell->OnOverviewModeStarting();
 105
 106   if (restore_focus_window_)
 107     restore_focus_window_->AddObserver(this);
 108
 109   const aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 110   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
 111        iter != root_windows.end(); iter++) {
 112     // Observed switchable containers for newly created windows on all root
 113     // windows.
 114     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 115       aura::Window* container = Shell::GetContainer(*iter,
 116           kSwitchableWindowContainerIds[i]);
 117       container->AddObserver(this);
 118       observed_windows_.insert(container);
 119     }
 120     scoped_ptr<WindowGrid> grid(new WindowGrid(*iter, windows, this));
 121     if (grid->empty())
 122       continue;
 123     num_items_ += grid->size();
 124     grid_list_.push_back(grid.release());
 125   }
 126
 127   // Do not call PrepareForOverview until all items are added to window_list_ as
 128   // we don't want to cause any window updates until all windows in overview
 129   // are observed. See http://crbug.com/384495.
 130   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 131        iter != grid_list_.end(); ++iter) {
 132     (*iter)->PrepareForOverview();
 133     (*iter)->PositionWindows(true);
 134   }
 135
 136   DCHECK(!grid_list_.empty());
 137   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 138
 139   shell->activation_client()->AddObserver(this);
 140
 141   // Remove focus from active window before entering overview.
 142   aura::client::GetFocusClient(
 143       Shell::GetPrimaryRootWindow())->FocusWindow(NULL);
 144
 145   shell->PrependPreTargetHandler(this);
 146   shell->GetScreen()->AddObserver(this);
 147   shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
 148   HideAndTrackNonOverviewWindows();
 149   // Send an a11y alert.
 150   shell->accessibility_delegate()->TriggerAccessibilityAlert(
 151       A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 152
 153   UpdateShelfVisibility();
 154 }
 155
 156 WindowSelector::~WindowSelector() {
 157   ash::Shell* shell = ash::Shell::GetInstance();
 158
 159   ResetFocusRestoreWindow(true);
 160   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
 161        iter != observed_windows_.end(); ++iter) {
 162     (*iter)->RemoveObserver(this);
 163   }
 164   shell->activation_client()->RemoveObserver(this);
 165   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 166
 167   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
 168   for (aura::WindowTracker::Windows::const_iterator iter =
 169        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
 170     ui::ScopedLayerAnimationSettings settings(
 171         (*iter)->layer()->GetAnimator());
 172     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 173         ScopedTransformOverviewWindow::kTransitionMilliseconds));
 174     settings.SetPreemptionStrategy(
 175         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 176     (*iter)->layer()->SetOpacity(1);
 177     (*iter)->Show();
 178   }
 179
 180   shell->RemovePreTargetHandler(this);
 181   shell->GetScreen()->RemoveObserver(this);
 182
 183   size_t remaining_items = 0;
 184   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 185       iter != grid_list_.end(); iter++) {
 186     remaining_items += (*iter)->size();
 187   }
 188
 189   DCHECK(num_items_ >= remaining_items);
 190   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.OverviewClosedItems",
 191                            num_items_ - remaining_items);
 192   UMA_HISTOGRAM_MEDIUM_TIMES("Ash.WindowSelector.TimeInOverview",
 193                              base::Time::Now() - overview_start_time_);
 194
 195   // TODO(nsatragno): Change this to OnOverviewModeEnded and move it to when
 196   // everything is done.
 197   shell->OnOverviewModeEnding();
 198
 199   // Clearing the window list resets the ignored_by_shelf flag on the windows.
 200   grid_list_.clear();
 201   UpdateShelfVisibility();
 202 }
 203
 204 void WindowSelector::CancelSelection() {
 205   delegate_->OnSelectionEnded();
 206 }
 207
 208 void WindowSelector::OnGridEmpty(WindowGrid* grid) {
 209   ScopedVector<WindowGrid>::iterator iter =
 210       std::find(grid_list_.begin(), grid_list_.end(), grid);
 211   DCHECK(iter != grid_list_.end());
 212   grid_list_.erase(iter);
 213   // TODO(nsatragno): Use the previous index for more than two displays.
 214   selected_grid_index_ = 0;
 215   if (grid_list_.empty())
 216     CancelSelection();
 217 }
 218
 219 void WindowSelector::OnKeyEvent(ui::KeyEvent* event) {
 220   if (event->type() != ui::ET_KEY_PRESSED)
 221     return;
 222
 223   switch (event->key_code()) {
 224     case ui::VKEY_ESCAPE:
 225       CancelSelection();
 226       break;
 227     case ui::VKEY_UP:
 228       num_key_presses_++;
 229       Move(WindowSelector::UP);
 230       break;
 231     case ui::VKEY_DOWN:
 232       num_key_presses_++;
 233       Move(WindowSelector::DOWN);
 234       break;
 235     case ui::VKEY_RIGHT:
 236       num_key_presses_++;
 237       Move(WindowSelector::RIGHT);
 238       break;
 239     case ui::VKEY_LEFT:
 240       num_key_presses_++;
 241       Move(WindowSelector::LEFT);
 242       break;
 243     case ui::VKEY_RETURN:
 244       // Ignore if no item is selected.
 245       if (!grid_list_[selected_grid_index_]->is_selecting())
 246         return;
 247       UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ArrowKeyPresses",
 248                                num_key_presses_);
 249       UMA_HISTOGRAM_CUSTOM_COUNTS(
 250           "Ash.WindowSelector.KeyPressesOverItemsRatio",
 251           (num_key_presses_ * 100) / num_items_, 1, 300, 30);
 252       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
 253           UMA_WINDOW_OVERVIEW_ENTER_KEY);
 254       wm::GetWindowState(grid_list_[selected_grid_index_]->
 255                          SelectedWindow()->SelectionWindow())->Activate();
 256       break;
 257     default:
 258       // Not a key we are interested in.
 259       return;
 260   }
 261   event->StopPropagation();
 262 }
 263
 264 void WindowSelector::OnDisplayAdded(const gfx::Display& display) {
 265 }
 266
 267 void WindowSelector::OnDisplayRemoved(const gfx::Display& display) {
 268   // TODO(nsatragno): Keep window selection active on remaining displays.
 269   CancelSelection();
 270 }
 271
 272 void WindowSelector::OnDisplayMetricsChanged(const gfx::Display& display,
 273                                              uint32_t metrics) {
 274   PositionWindows(/* animate */ false);
 275 }
 276
 277 void WindowSelector::OnWindowAdded(aura::Window* new_window) {
 278   if (new_window->type() != ui::wm::WINDOW_TYPE_NORMAL &&
 279       new_window->type() != ui::wm::WINDOW_TYPE_PANEL) {
 280     return;
 281   }
 282
 283   for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 284     if (new_window->parent()->id() == kSwitchableWindowContainerIds[i] &&
 285         !::wm::GetTransientParent(new_window)) {
 286       // The new window is in one of the switchable containers, abort overview.
 287       CancelSelection();
 288       return;
 289     }
 290   }
 291 }
 292
 293 void WindowSelector::OnWindowDestroying(aura::Window* window) {
 294   window->RemoveObserver(this);
 295   observed_windows_.erase(window);
 296   if (window == restore_focus_window_)
 297     restore_focus_window_ = NULL;
 298 }
 299
 300 void WindowSelector::OnWindowActivated(aura::Window* gained_active,
 301                                        aura::Window* lost_active) {
 302   if (ignore_activations_ || !gained_active)
 303     return;
 304
 305   ScopedVector<WindowGrid>::iterator grid =
 306       std::find_if(grid_list_.begin(), grid_list_.end(),
 307                    RootWindowGridComparator(gained_active->GetRootWindow()));
 308   if (grid == grid_list_.end())
 309     return;
 310   const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
 311
 312   ScopedVector<WindowSelectorItem>::const_iterator iter = std::find_if(
 313       windows.begin(), windows.end(),
 314       WindowSelectorItemTargetComparator(gained_active));
 315
 316   if (iter != windows.end())
 317     (*iter)->RestoreWindowOnExit(gained_active);
 318
 319   // Don't restore focus on exit if a window was just activated.
 320   ResetFocusRestoreWindow(false);
 321   CancelSelection();
 322 }
 323
 324 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
 325                                                  aura::Window* actual_active) {
 326   OnWindowActivated(request_active, actual_active);
 327 }
 328
 329 void WindowSelector::PositionWindows(bool animate) {
 330   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 331       iter != grid_list_.end(); iter++) {
 332     (*iter)->PositionWindows(animate);
 333   }
 334 }
 335
 336 void WindowSelector::HideAndTrackNonOverviewWindows() {
 337   // Add the windows to hidden_windows first so that if any are destroyed
 338   // while hiding them they are tracked.
 339   for (ScopedVector<WindowGrid>::iterator grid_iter = grid_list_.begin();
 340       grid_iter != grid_list_.end(); ++grid_iter) {
 341     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 342       const aura::Window* container =
 343           Shell::GetContainer((*grid_iter)->root_window(),
 344                               kSwitchableWindowContainerIds[i]);
 345       for (aura::Window::Windows::const_iterator iter =
 346            container->children().begin(); iter != container->children().end();
 347            ++iter) {
 348         if (!(*iter)->IsVisible() || (*grid_iter)->Contains(*iter))
 349           continue;
 350         hidden_windows_.Add(*iter);
 351       }
 352     }
 353   }
 354
 355   // Copy the window list as it can change during iteration.
 356   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
 357   for (aura::WindowTracker::Windows::const_iterator iter =
 358        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
 359     if (!hidden_windows_.Contains(*iter))
 360       continue;
 361     ui::ScopedLayerAnimationSettings settings(
 362         (*iter)->layer()->GetAnimator());
 363     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 364         ScopedTransformOverviewWindow::kTransitionMilliseconds));
 365     settings.SetPreemptionStrategy(
 366         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 367     (*iter)->Hide();
 368     // Hiding the window can result in it being destroyed.
 369     if (!hidden_windows_.Contains(*iter))
 370       continue;
 371     (*iter)->layer()->SetOpacity(0);
 372   }
 373 }
 374
 375 void WindowSelector::ResetFocusRestoreWindow(bool focus) {
 376   if (!restore_focus_window_)
 377     return;
 378   if (focus) {
 379     base::AutoReset<bool> restoring_focus(&ignore_activations_, true);
 380     restore_focus_window_->Focus();
 381   }
 382   // If the window is in the observed_windows_ list it needs to continue to be
 383   // observed.
 384   if (observed_windows_.find(restore_focus_window_) ==
 385           observed_windows_.end()) {
 386     restore_focus_window_->RemoveObserver(this);
 387   }
 388   restore_focus_window_ = NULL;
 389 }
 390
 391 void WindowSelector::Move(Direction direction) {
 392   bool overflowed = grid_list_[selected_grid_index_]->Move(direction);
 393   if (overflowed) {
 394     // The grid reported that the movement command corresponds to the next
 395     // root window, identify it and call Move() on it to initialize the
 396     // selection widget.
 397     // TODO(nsatragno): If there are more than two monitors, move between grids
 398     // in the requested direction.
 399     selected_grid_index_ = (selected_grid_index_ + 1) % grid_list_.size();
 400     grid_list_[selected_grid_index_]->Move(direction);
 401   }
 402 }
 403
 404 }  // namespace ash