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   DCHECK(!grid_list_.empty());
 128   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 129
 130   shell->activation_client()->AddObserver(this);
 131
 132   // Remove focus from active window before entering overview.
 133   aura::client::GetFocusClient(
 134       Shell::GetPrimaryRootWindow())->FocusWindow(NULL);
 135
 136   shell->PrependPreTargetHandler(this);
 137   shell->GetScreen()->AddObserver(this);
 138   shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
 139   HideAndTrackNonOverviewWindows();
 140   // Send an a11y alert.
 141   shell->accessibility_delegate()->TriggerAccessibilityAlert(
 142       A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 143
 144   UpdateShelfVisibility();
 145 }
 146
 147 WindowSelector::~WindowSelector() {
 148   ash::Shell* shell = ash::Shell::GetInstance();
 149
 150   ResetFocusRestoreWindow(true);
 151   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
 152        iter != observed_windows_.end(); ++iter) {
 153     (*iter)->RemoveObserver(this);
 154   }
 155   shell->activation_client()->RemoveObserver(this);
 156   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 157
 158   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
 159   for (aura::WindowTracker::Windows::const_iterator iter =
 160        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
 161     ui::ScopedLayerAnimationSettings settings(
 162         (*iter)->layer()->GetAnimator());
 163     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 164         ScopedTransformOverviewWindow::kTransitionMilliseconds));
 165     settings.SetPreemptionStrategy(
 166         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 167     (*iter)->layer()->SetOpacity(1);
 168     (*iter)->Show();
 169   }
 170
 171   shell->RemovePreTargetHandler(this);
 172   shell->GetScreen()->RemoveObserver(this);
 173
 174   size_t remaining_items = 0;
 175   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 176       iter != grid_list_.end(); iter++) {
 177     remaining_items += (*iter)->size();
 178   }
 179
 180   DCHECK(num_items_ >= remaining_items);
 181   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.OverviewClosedItems",
 182                            num_items_ - remaining_items);
 183   UMA_HISTOGRAM_MEDIUM_TIMES("Ash.WindowSelector.TimeInOverview",
 184                              base::Time::Now() - overview_start_time_);
 185
 186   // TODO(nsatragno): Change this to OnOverviewModeEnded and move it to when
 187   // everything is done.
 188   shell->OnOverviewModeEnding();
 189
 190   // Clearing the window list resets the ignored_by_shelf flag on the windows.
 191   grid_list_.clear();
 192   UpdateShelfVisibility();
 193 }
 194
 195 void WindowSelector::CancelSelection() {
 196   delegate_->OnSelectionEnded();
 197 }
 198
 199 void WindowSelector::OnGridEmpty(WindowGrid* grid) {
 200   ScopedVector<WindowGrid>::iterator iter =
 201       std::find(grid_list_.begin(), grid_list_.end(), grid);
 202   DCHECK(iter != grid_list_.end());
 203   grid_list_.erase(iter);
 204   // TODO(nsatragno): Use the previous index for more than two displays.
 205   selected_grid_index_ = 0;
 206   if (grid_list_.empty())
 207     CancelSelection();
 208 }
 209
 210 void WindowSelector::OnKeyEvent(ui::KeyEvent* event) {
 211   if (event->type() != ui::ET_KEY_PRESSED)
 212     return;
 213
 214   switch (event->key_code()) {
 215     case ui::VKEY_ESCAPE:
 216       CancelSelection();
 217       break;
 218     case ui::VKEY_UP:
 219       num_key_presses_++;
 220       Move(WindowSelector::UP);
 221       break;
 222     case ui::VKEY_DOWN:
 223       num_key_presses_++;
 224       Move(WindowSelector::DOWN);
 225       break;
 226     case ui::VKEY_RIGHT:
 227       num_key_presses_++;
 228       Move(WindowSelector::RIGHT);
 229       break;
 230     case ui::VKEY_LEFT:
 231       num_key_presses_++;
 232       Move(WindowSelector::LEFT);
 233       break;
 234     case ui::VKEY_RETURN:
 235       // Ignore if no item is selected.
 236       if (!grid_list_[selected_grid_index_]->is_selecting())
 237         return;
 238       UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ArrowKeyPresses",
 239                                num_key_presses_);
 240       UMA_HISTOGRAM_CUSTOM_COUNTS(
 241           "Ash.WindowSelector.KeyPressesOverItemsRatio",
 242           (num_key_presses_ * 100) / num_items_, 1, 300, 30);
 243       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
 244           UMA_WINDOW_OVERVIEW_ENTER_KEY);
 245       wm::GetWindowState(grid_list_[selected_grid_index_]->
 246                          SelectedWindow()->SelectionWindow())->Activate();
 247       break;
 248     default:
 249       // Not a key we are interested in.
 250       return;
 251   }
 252   event->StopPropagation();
 253 }
 254
 255 void WindowSelector::OnDisplayAdded(const gfx::Display& display) {
 256 }
 257
 258 void WindowSelector::OnDisplayRemoved(const gfx::Display& display) {
 259   // TODO(nsatragno): Keep window selection active on remaining displays.
 260   CancelSelection();
 261 }
 262
 263 void WindowSelector::OnDisplayMetricsChanged(const gfx::Display& display,
 264                                              uint32_t metrics) {
 265   PositionWindows(/* animate */ false);
 266 }
 267
 268 void WindowSelector::OnWindowAdded(aura::Window* new_window) {
 269   if (new_window->type() != ui::wm::WINDOW_TYPE_NORMAL &&
 270       new_window->type() != ui::wm::WINDOW_TYPE_PANEL) {
 271     return;
 272   }
 273
 274   for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 275     if (new_window->parent()->id() == kSwitchableWindowContainerIds[i] &&
 276         !::wm::GetTransientParent(new_window)) {
 277       // The new window is in one of the switchable containers, abort overview.
 278       CancelSelection();
 279       return;
 280     }
 281   }
 282 }
 283
 284 void WindowSelector::OnWindowDestroying(aura::Window* window) {
 285   window->RemoveObserver(this);
 286   observed_windows_.erase(window);
 287   if (window == restore_focus_window_)
 288     restore_focus_window_ = NULL;
 289 }
 290
 291 void WindowSelector::OnWindowActivated(aura::Window* gained_active,
 292                                        aura::Window* lost_active) {
 293   if (ignore_activations_ || !gained_active)
 294     return;
 295
 296   ScopedVector<WindowGrid>::iterator grid =
 297       std::find_if(grid_list_.begin(), grid_list_.end(),
 298                    RootWindowGridComparator(gained_active->GetRootWindow()));
 299   if (grid == grid_list_.end())
 300     return;
 301   const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
 302
 303   ScopedVector<WindowSelectorItem>::const_iterator iter = std::find_if(
 304       windows.begin(), windows.end(),
 305       WindowSelectorItemTargetComparator(gained_active));
 306
 307   if (iter != windows.end())
 308     (*iter)->RestoreWindowOnExit(gained_active);
 309
 310   // Don't restore focus on exit if a window was just activated.
 311   ResetFocusRestoreWindow(false);
 312   CancelSelection();
 313 }
 314
 315 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
 316                                                  aura::Window* actual_active) {
 317   OnWindowActivated(request_active, actual_active);
 318 }
 319
 320 void WindowSelector::PositionWindows(bool animate) {
 321   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 322       iter != grid_list_.end(); iter++) {
 323     (*iter)->PositionWindows(animate);
 324   }
 325 }
 326
 327 void WindowSelector::HideAndTrackNonOverviewWindows() {
 328   // Add the windows to hidden_windows first so that if any are destroyed
 329   // while hiding them they are tracked.
 330   for (ScopedVector<WindowGrid>::iterator grid_iter = grid_list_.begin();
 331       grid_iter != grid_list_.end(); ++grid_iter) {
 332     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 333       const aura::Window* container =
 334           Shell::GetContainer((*grid_iter)->root_window(),
 335                               kSwitchableWindowContainerIds[i]);
 336       for (aura::Window::Windows::const_iterator iter =
 337            container->children().begin(); iter != container->children().end();
 338            ++iter) {
 339         if (!(*iter)->IsVisible() || (*grid_iter)->Contains(*iter))
 340           continue;
 341         hidden_windows_.Add(*iter);
 342       }
 343     }
 344   }
 345
 346   // Copy the window list as it can change during iteration.
 347   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
 348   for (aura::WindowTracker::Windows::const_iterator iter =
 349        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
 350     if (!hidden_windows_.Contains(*iter))
 351       continue;
 352     ui::ScopedLayerAnimationSettings settings(
 353         (*iter)->layer()->GetAnimator());
 354     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 355         ScopedTransformOverviewWindow::kTransitionMilliseconds));
 356     settings.SetPreemptionStrategy(
 357         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 358     (*iter)->Hide();
 359     // Hiding the window can result in it being destroyed.
 360     if (!hidden_windows_.Contains(*iter))
 361       continue;
 362     (*iter)->layer()->SetOpacity(0);
 363   }
 364 }
 365
 366 void WindowSelector::ResetFocusRestoreWindow(bool focus) {
 367   if (!restore_focus_window_)
 368     return;
 369   if (focus) {
 370     base::AutoReset<bool> restoring_focus(&ignore_activations_, true);
 371     restore_focus_window_->Focus();
 372   }
 373   // If the window is in the observed_windows_ list it needs to continue to be
 374   // observed.
 375   if (observed_windows_.find(restore_focus_window_) ==
 376           observed_windows_.end()) {
 377     restore_focus_window_->RemoveObserver(this);
 378   }
 379   restore_focus_window_ = NULL;
 380 }
 381
 382 void WindowSelector::Move(Direction direction) {
 383   bool overflowed = grid_list_[selected_grid_index_]->Move(direction);
 384   if (overflowed) {
 385     // The grid reported that the movement command corresponds to the next
 386     // root window, identify it and call Move() on it to initialize the
 387     // selection widget.
 388     // TODO(nsatragno): If there are more than two monitors, move between grids
 389     // in the requested direction.
 390     selected_grid_index_ = (selected_grid_index_ + 1) % grid_list_.size();
 391     grid_list_[selected_grid_index_]->Move(direction);
 392   }
 393 }
 394
 395 }  // namespace ash