src/ash/wm/maximize_mode/maximize_mode_window_manager.cc

   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/maximize_mode/maximize_mode_window_manager.h"
   6
   7 #include "ash/root_window_controller.h"
   8 #include "ash/shell.h"
   9 #include "ash/shell_window_ids.h"
  10 #include "ash/wm/maximize_mode/maximize_mode_window_state.h"
  11 #include "ash/wm/maximize_mode/workspace_backdrop_delegate.h"
  12 #include "ash/wm/mru_window_tracker.h"
  13 #include "ash/wm/overview/window_selector_controller.h"
  14 #include "ash/wm/window_state.h"
  15 #include "ash/wm/window_util.h"
  16 #include "ash/wm/wm_event.h"
  17 #include "ash/wm/workspace_controller.h"
  18 #include "ui/aura/window.h"
  19 #include "ui/gfx/screen.h"
  20
  21 namespace ash {
  22
  23 namespace {
  24
  25 // The height of the area in which a touch operation leads to exiting the
  26 // full screen mode.
  27 const int kLeaveFullScreenAreaHeightInPixel = 2;
  28
  29 // Exits overview mode if it is currently active.
  30 void CancelOverview() {
  31   WindowSelectorController* controller =
  32       Shell::GetInstance()->window_selector_controller();
  33   if (controller && controller->IsSelecting())
  34     controller->OnSelectionEnded();
  35 }
  36
  37 }  // namespace
  38
  39 MaximizeModeWindowManager::~MaximizeModeWindowManager() {
  40   // Overview mode needs to be ended before exiting maximize mode to prevent
  41   // transforming windows which are currently in
  42   // overview: http://crbug.com/366605
  43   CancelOverview();
  44
  45   Shell::GetInstance()->RemovePreTargetHandler(this);
  46   Shell::GetInstance()->RemoveShellObserver(this);
  47   Shell::GetScreen()->RemoveObserver(this);
  48   EnableBackdropBehindTopWindowOnEachDisplay(false);
  49   RemoveWindowCreationObservers();
  50   RestoreAllWindows();
  51 }
  52
  53 int MaximizeModeWindowManager::GetNumberOfManagedWindows() {
  54   return window_state_map_.size();
  55 }
  56
  57 void MaximizeModeWindowManager::AddWindow(aura::Window* window) {
  58   // Only add the window if it is a direct dependent of a container window
  59   // and not yet tracked.
  60   if (!ShouldHandleWindow(window) ||
  61       window_state_map_.find(window) != window_state_map_.end() ||
  62       !IsContainerWindow(window->parent())) {
  63     return;
  64   }
  65
  66   MaximizeAndTrackWindow(window);
  67 }
  68
  69 void MaximizeModeWindowManager::WindowStateDestroyed(aura::Window* window) {
  70   // At this time ForgetWindow() should already have been called. If not,
  71   // someone else must have replaced the "window manager's state object".
  72   DCHECK(!window->HasObserver(this));
  73
  74   WindowToState::iterator it = window_state_map_.find(window);
  75   DCHECK(it != window_state_map_.end());
  76   window_state_map_.erase(it);
  77 }
  78
  79 void MaximizeModeWindowManager::OnOverviewModeStarting() {
  80   if (backdrops_hidden_)
  81     return;
  82
  83   EnableBackdropBehindTopWindowOnEachDisplay(false);
  84   backdrops_hidden_ = true;
  85 }
  86
  87 void MaximizeModeWindowManager::OnOverviewModeEnding() {
  88   if (!backdrops_hidden_)
  89     return;
  90
  91   backdrops_hidden_ = false;
  92   EnableBackdropBehindTopWindowOnEachDisplay(true);
  93 }
  94
  95 void MaximizeModeWindowManager::OnWindowDestroying(aura::Window* window) {
  96   // If a known window gets destroyed we need to remove all knowledge about it.
  97   if (!IsContainerWindow(window))
  98     ForgetWindow(window);
  99 }
 100
 101 void MaximizeModeWindowManager::OnWindowAdded(aura::Window* window) {
 102   // A window can get removed and then re-added by a drag and drop operation.
 103   if (IsContainerWindow(window->parent()) &&
 104       window_state_map_.find(window) == window_state_map_.end()) {
 105     MaximizeAndTrackWindow(window);
 106     // When the state got added, the "WM_EVENT_ADDED_TO_WORKSPACE" event got
 107     // already sent and we have to notify our state again.
 108     if (window_state_map_.find(window) != window_state_map_.end()) {
 109       wm::WMEvent event(wm::WM_EVENT_ADDED_TO_WORKSPACE);
 110       wm::GetWindowState(window)->OnWMEvent(&event);
 111     }
 112   }
 113 }
 114
 115 void MaximizeModeWindowManager::OnWindowBoundsChanged(
 116     aura::Window* window,
 117     const gfx::Rect& old_bounds,
 118     const gfx::Rect& new_bounds) {
 119   if (!IsContainerWindow(window))
 120     return;
 121   // Reposition all non maximizeable windows.
 122   for (WindowToState::iterator it = window_state_map_.begin();
 123        it != window_state_map_.end();
 124        ++it) {
 125     it->second->UpdateWindowPosition(wm::GetWindowState(it->first), false);
 126   }
 127 }
 128
 129 void MaximizeModeWindowManager::OnDisplayAdded(const gfx::Display& display) {
 130   DisplayConfigurationChanged();
 131 }
 132
 133 void MaximizeModeWindowManager::OnDisplayRemoved(const gfx::Display& display) {
 134   DisplayConfigurationChanged();
 135 }
 136
 137 void MaximizeModeWindowManager::OnDisplayMetricsChanged(const gfx::Display&,
 138                                                         uint32_t) {
 139   // Nothing to do here.
 140 }
 141
 142 void MaximizeModeWindowManager::OnTouchEvent(ui::TouchEvent* event) {
 143   if (event->type() != ui::ET_TOUCH_PRESSED)
 144     return;
 145
 146   // Find the active window (from the primary screen) to un-fullscreen.
 147   aura::Window* window = wm::GetActiveWindow();
 148   if (!window)
 149     return;
 150
 151   wm::WindowState* window_state = wm::GetWindowState(window);
 152   if (!window_state->IsFullscreen() || window_state->in_immersive_fullscreen())
 153     return;
 154
 155   // Test that the touch happened in the top or bottom lines.
 156   int y = event->y();
 157   if (y >= kLeaveFullScreenAreaHeightInPixel &&
 158       y < (window->bounds().height() - kLeaveFullScreenAreaHeightInPixel)) {
 159     return;
 160   }
 161
 162   // Leave full screen mode.
 163   event->StopPropagation();
 164   wm::WMEvent toggle_fullscreen(wm::WM_EVENT_TOGGLE_FULLSCREEN);
 165   window_state->OnWMEvent(&toggle_fullscreen);
 166 }
 167
 168 MaximizeModeWindowManager::MaximizeModeWindowManager()
 169       : backdrops_hidden_(false) {
 170   // The overview mode needs to be ended before the maximize mode is started. To
 171   // guarantee the proper order, it will be turned off from here.
 172   CancelOverview();
 173
 174   MaximizeAllWindows();
 175   AddWindowCreationObservers();
 176   EnableBackdropBehindTopWindowOnEachDisplay(true);
 177   Shell::GetScreen()->AddObserver(this);
 178   Shell::GetInstance()->AddShellObserver(this);
 179   Shell::GetInstance()->AddPreTargetHandler(this);
 180 }
 181
 182 void MaximizeModeWindowManager::MaximizeAllWindows() {
 183   MruWindowTracker::WindowList windows =
 184       MruWindowTracker::BuildWindowList(false);
 185   // Add all existing Mru windows.
 186   for (MruWindowTracker::WindowList::iterator window = windows.begin();
 187       window != windows.end(); ++window) {
 188     MaximizeAndTrackWindow(*window);
 189   }
 190 }
 191
 192 void MaximizeModeWindowManager::RestoreAllWindows() {
 193   while (window_state_map_.size())
 194     ForgetWindow(window_state_map_.begin()->first);
 195 }
 196
 197 void MaximizeModeWindowManager::MaximizeAndTrackWindow(
 198     aura::Window* window) {
 199   if (!ShouldHandleWindow(window))
 200     return;
 201
 202   DCHECK(window_state_map_.find(window) == window_state_map_.end());
 203   window->AddObserver(this);
 204
 205   // We create and remember a maximize mode state which will attach itself to
 206   // the provided state object.
 207   window_state_map_[window] = new MaximizeModeWindowState(window, this);
 208 }
 209
 210 void MaximizeModeWindowManager::ForgetWindow(aura::Window* window) {
 211   WindowToState::iterator it = window_state_map_.find(window);
 212
 213   // The following DCHECK could fail if our window state object was destroyed
 214   // earlier by someone else. However - at this point there is no other client
 215   // which replaces the state object and therefore this should not happen.
 216   DCHECK(it != window_state_map_.end());
 217   window->RemoveObserver(this);
 218
 219   // By telling the state object to revert, it will switch back the old
 220   // State object and destroy itself, calling WindowStateDerstroyed().
 221   it->second->LeaveMaximizeMode(wm::GetWindowState(it->first));
 222   DCHECK(window_state_map_.find(window) == window_state_map_.end());
 223 }
 224
 225 bool MaximizeModeWindowManager::ShouldHandleWindow(aura::Window* window) {
 226   DCHECK(window);
 227   return window->type() == ui::wm::WINDOW_TYPE_NORMAL;
 228 }
 229
 230 void MaximizeModeWindowManager::AddWindowCreationObservers() {
 231   DCHECK(observed_container_windows_.empty());
 232   // Observe window activations/creations in the default containers on all root
 233   // windows.
 234   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 235   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
 236        iter != root_windows.end(); ++iter) {
 237     aura::Window* container =
 238         Shell::GetContainer(*iter, kShellWindowId_DefaultContainer);
 239     DCHECK(observed_container_windows_.find(container) ==
 240               observed_container_windows_.end());
 241     container->AddObserver(this);
 242     observed_container_windows_.insert(container);
 243   }
 244 }
 245
 246 void MaximizeModeWindowManager::RemoveWindowCreationObservers() {
 247   for (std::set<aura::Window*>::iterator iter =
 248            observed_container_windows_.begin();
 249        iter != observed_container_windows_.end(); ++iter) {
 250     (*iter)->RemoveObserver(this);
 251   }
 252   observed_container_windows_.clear();
 253 }
 254
 255 void MaximizeModeWindowManager::DisplayConfigurationChanged() {
 256   EnableBackdropBehindTopWindowOnEachDisplay(false);
 257   RemoveWindowCreationObservers();
 258   AddWindowCreationObservers();
 259   EnableBackdropBehindTopWindowOnEachDisplay(true);
 260 }
 261
 262 bool MaximizeModeWindowManager::IsContainerWindow(aura::Window* window) {
 263   return observed_container_windows_.find(window) !=
 264              observed_container_windows_.end();
 265 }
 266
 267 void MaximizeModeWindowManager::EnableBackdropBehindTopWindowOnEachDisplay(
 268     bool enable) {
 269   if (backdrops_hidden_)
 270     return;
 271   // Inform the WorkspaceLayoutManager that we want to show a backdrop behind
 272   // the topmost window of its container.
 273   Shell::RootWindowControllerList controllers =
 274       Shell::GetAllRootWindowControllers();
 275   for (Shell::RootWindowControllerList::iterator iter = controllers.begin();
 276        iter != controllers.end(); ++iter) {
 277     RootWindowController* controller = *iter;
 278     aura::Window* container = Shell::GetContainer(
 279         controller->GetRootWindow(), kShellWindowId_DefaultContainer);
 280     controller->workspace_controller()->SetMaximizeBackdropDelegate(
 281         scoped_ptr<WorkspaceLayoutManagerDelegate>(
 282             enable ? new WorkspaceBackdropDelegate(container) : NULL));
 283   }
 284 }
 285
 286 }  // namespace ash