1// Copyright (c) 2012 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#ifndef ASH_ROOT_WINDOW_CONTROLLER_H_ 6#define ASH_ROOT_WINDOW_CONTROLLER_H_ 7 8#include <map> 9 10#include "ash/ash_export.h" 11#include "ash/shelf/shelf_types.h" 12#include "ash/shell_observer.h" 13#include "ash/system/user/login_status.h" 14#include "base/basictypes.h" 15#include "base/memory/scoped_ptr.h" 16#include "ui/aura/window.h" 17#include "ui/aura/window_tree_host.h" 18#include "ui/base/ui_base_types.h" 19 20class SkBitmap; 21 22namespace aura { 23class EventFilter; 24class Window; 25} 26 27namespace gfx { 28class Point; 29} 30 31namespace keyboard { 32class KeyboardController; 33} 34 35namespace ui { 36class EventHandler; 37} 38 39namespace views { 40class Widget; 41} 42 43namespace wm { 44class InputMethodEventFilter; 45class RootWindowEventFilter; 46class ScopedCaptureClient; 47} 48 49namespace ash { 50class AshWindowTreeHost; 51class AlwaysOnTopController; 52class AnimatingDesktopController; 53class DesktopBackgroundWidgetController; 54class DockedWindowLayoutManager; 55class PanelLayoutManager; 56class RootWindowLayoutManager; 57class ScreenDimmer; 58class ShelfLayoutManager; 59class ShelfWidget; 60class StackingController; 61class StatusAreaWidget; 62class SystemBackgroundController; 63class SystemModalContainerLayoutManager; 64class SystemTray; 65class TouchHudDebug; 66class TouchHudProjection; 67class WorkspaceController; 68 69#if defined(OS_CHROMEOS) 70class BootSplashScreen; 71class AshTouchExplorationManager; 72#endif 73 74// This class maintains the per root window state for ash. This class 75// owns the root window and other dependent objects that should be 76// deleted upon the deletion of the root window. This object is 77// indirectly owned and deleted by |DisplayController|. 78// The RootWindowController for particular root window is stored in 79// its property (RootWindowSettings) and can be obtained using 80// |GetRootWindowController(aura::WindowEventDispatcher*)| function. 81class ASH_EXPORT RootWindowController : public ShellObserver { 82 public: 83 // Creates and Initialize the RootWindowController for primary display. 84 static void CreateForPrimaryDisplay(AshWindowTreeHost* host); 85 86 // Creates and Initialize the RootWindowController for secondary displays. 87 static void CreateForSecondaryDisplay(AshWindowTreeHost* host); 88 89 // Creates and Initialize the RootWindowController for virtual 90 // keyboard displays. 91 static void CreateForVirtualKeyboardDisplay(AshWindowTreeHost* host); 92 93 // Returns a RootWindowController that has a shelf for given 94 // |window|. This returns the RootWindowController for the |window|'s 95 // root window when multiple shelf mode is enabled, or the primary 96 // RootWindowController otherwise. 97 static RootWindowController* ForShelf(const aura::Window* window); 98 99 // Returns a RootWindowController of the window's root window. 100 static RootWindowController* ForWindow(const aura::Window* window); 101 102 // Returns the RootWindowController of the target root window. 103 static RootWindowController* ForTargetRootWindow(); 104 105 // Returns container which contains a given |window|. 106 static aura::Window* GetContainerForWindow(aura::Window* window); 107 108 virtual ~RootWindowController(); 109 110 AshWindowTreeHost* ash_host() { return ash_host_.get(); } 111 const AshWindowTreeHost* ash_host() const { return ash_host_.get(); } 112 113 aura::WindowTreeHost* GetHost(); 114 const aura::WindowTreeHost* GetHost() const; 115 aura::Window* GetRootWindow(); 116 const aura::Window* GetRootWindow() const; 117 118 RootWindowLayoutManager* root_window_layout() { return root_window_layout_; } 119 120 WorkspaceController* workspace_controller() { 121 return workspace_controller_.get(); 122 } 123 124 AlwaysOnTopController* always_on_top_controller() { 125 return always_on_top_controller_.get(); 126 } 127 128 ScreenDimmer* screen_dimmer() { return screen_dimmer_.get(); } 129 130 // Access the shelf associated with this root window controller, 131 // NULL if no such shelf exists. 132 ShelfWidget* shelf() { return shelf_.get(); } 133 134 // Get touch HUDs associated with this root window controller. 135 TouchHudDebug* touch_hud_debug() const { 136 return touch_hud_debug_; 137 } 138 TouchHudProjection* touch_hud_projection() const { 139 return touch_hud_projection_; 140 } 141 142 // Set touch HUDs for this root window controller. The root window controller 143 // will not own the HUDs; their lifetimes are managed by themselves. Whenever 144 // the widget showing a HUD is being destroyed (e.g. because of detaching a 145 // display), the HUD deletes itself. 146 void set_touch_hud_debug(TouchHudDebug* hud) { 147 touch_hud_debug_ = hud; 148 } 149 void set_touch_hud_projection(TouchHudProjection* hud) { 150 touch_hud_projection_ = hud; 151 } 152 153 DesktopBackgroundWidgetController* wallpaper_controller() { 154 return wallpaper_controller_.get(); 155 } 156 void SetWallpaperController(DesktopBackgroundWidgetController* controller); 157 AnimatingDesktopController* animating_wallpaper_controller() { 158 return animating_wallpaper_controller_.get(); 159 } 160 void SetAnimatingWallpaperController(AnimatingDesktopController* controller); 161 162 // Access the shelf layout manager associated with this root 163 // window controller, NULL if no such shelf exists. 164 ShelfLayoutManager* GetShelfLayoutManager(); 165 166 // Returns the system tray on this root window. Note that 167 // calling this on the root window that doesn't have a shelf will 168 // lead to a crash. 169 SystemTray* GetSystemTray(); 170 171 // Shows context menu at the |location_in_screen|. This uses 172 // |ShellDelegate::CreateContextMenu| to define the content of the menu. 173 void ShowContextMenu(const gfx::Point& location_in_screen, 174 ui::MenuSourceType source_type); 175 176 // Returns the layout-manager for the appropriate modal-container. If the 177 // window is inside the lockscreen modal container, then the layout manager 178 // for that is returned. Otherwise the layout manager for the default modal 179 // container is returned. 180 // If no window is specified (i.e. |window| is NULL), then the lockscreen 181 // modal container is used if the screen is currently locked. Otherwise, the 182 // default modal container is used. 183 SystemModalContainerLayoutManager* GetSystemModalLayoutManager( 184 aura::Window* window); 185 186 aura::Window* GetContainer(int container_id); 187 const aura::Window* GetContainer(int container_id) const; 188 189 // Show shelf view if it was created hidden (before session has started). 190 void ShowShelf(); 191 192 // Called when the shelf associated with this root window is created. 193 void OnShelfCreated(); 194 195 // Called when the login status changes after login (such as lock/unlock). 196 // TODO(oshima): Investigate if we can merge this and |OnLoginStateChanged|. 197 void UpdateAfterLoginStatusChange(user::LoginStatus status); 198 199 // Called when the brightness/grayscale animation from white to the login 200 // desktop background image has started. Starts |boot_splash_screen_|'s 201 // hiding animation (if the screen is non-NULL). 202 void HandleInitialDesktopBackgroundAnimationStarted(); 203 204 // Called when the wallpaper ainmation is finished. Updates |background_| 205 // to be black and drops |boot_splash_screen_| and moves the wallpaper 206 // controller into the root window controller. |widget| holds the wallpaper 207 // image, or NULL if the background is a solid color. 208 void OnWallpaperAnimationFinished(views::Widget* widget); 209 210 // Deletes associated objects and clears the state, but doesn't delete 211 // the root window yet. This is used to delete a secondary displays' 212 // root window safely when the display disconnect signal is received, 213 // which may come while we're in the nested message loop. 214 void Shutdown(); 215 216 // Deletes all child windows and performs necessary cleanup. 217 void CloseChildWindows(); 218 219 // Moves child windows to |dest|. 220 void MoveWindowsTo(aura::Window* dest); 221 222 // Force the shelf to query for it's current visibility state. 223 void UpdateShelfVisibility(); 224 225 // Initialize touch HUDs if necessary. 226 void InitTouchHuds(); 227 228 // Returns the topmost window or one of its transient parents, if any of them 229 // are in fullscreen mode. 230 const aura::Window* GetWindowForFullscreenMode() const; 231 232 // Activate virtual keyboard on current root window controller. 233 void ActivateKeyboard(keyboard::KeyboardController* keyboard_controller); 234 235 // Deactivate virtual keyboard on current root window controller. 236 void DeactivateKeyboard(keyboard::KeyboardController* keyboard_controller); 237 238 // Tests if a window is associated with the virtual keyboard. 239 bool IsVirtualKeyboardWindow(aura::Window* window); 240 241 private: 242 explicit RootWindowController(AshWindowTreeHost* host); 243 enum RootWindowType { 244 PRIMARY, 245 SECONDARY 246 }; 247 248 // Initializes the RootWindowController. |is_primary| is true if 249 // the controller is for primary display. |first_run_after_boot| is 250 // set to true only for primary root window after boot. 251 void Init(RootWindowType root_window_type, bool first_run_after_boot); 252 253 void InitLayoutManagers(); 254 255 // Initializes |system_background_| and possibly also |boot_splash_screen_|. 256 // |is_first_run_after_boot| determines the background's initial color. 257 void CreateSystemBackground(bool is_first_run_after_boot); 258 259 // Creates each of the special window containers that holds windows of various 260 // types in the shell UI. 261 void CreateContainersInRootWindow(aura::Window* root_window); 262 263 // Enables projection touch HUD. 264 void EnableTouchHudProjection(); 265 266 // Disables projection touch HUD. 267 void DisableTouchHudProjection(); 268 269 // Overridden from ShellObserver. 270 virtual void OnLoginStateChanged(user::LoginStatus status) OVERRIDE; 271 virtual void OnTouchHudProjectionToggled(bool enabled) OVERRIDE; 272 273 scoped_ptr<AshWindowTreeHost> ash_host_; 274 RootWindowLayoutManager* root_window_layout_; 275 276 scoped_ptr<StackingController> stacking_controller_; 277 278 // The shelf for managing the shelf and the status widget. 279 scoped_ptr<ShelfWidget> shelf_; 280 281 // An invisible/empty window used as a event target for 282 // |MouseCursorEventFilter| before a user logs in. 283 // (crbug.com/266987) 284 // Its container is |LockScreenBackgroundContainer| and 285 // this must be deleted before the container is deleted. 286 scoped_ptr<aura::Window> mouse_event_target_; 287 288 // Manages layout of docked windows. Owned by DockedContainer. 289 DockedWindowLayoutManager* docked_layout_manager_; 290 291 // Manages layout of panels. Owned by PanelContainer. 292 PanelLayoutManager* panel_layout_manager_; 293 294 scoped_ptr<SystemBackgroundController> system_background_; 295 296#if defined(OS_CHROMEOS) 297 scoped_ptr<BootSplashScreen> boot_splash_screen_; 298 // Responsible for initializing TouchExplorationController when spoken 299 // feedback is on. 300 scoped_ptr<AshTouchExplorationManager> touch_exploration_manager_; 301#endif 302 303 scoped_ptr<ScreenDimmer> screen_dimmer_; 304 scoped_ptr<WorkspaceController> workspace_controller_; 305 scoped_ptr<AlwaysOnTopController> always_on_top_controller_; 306 307 // Heads-up displays for touch events. These HUDs are not owned by the root 308 // window controller and manage their own lifetimes. 309 TouchHudDebug* touch_hud_debug_; 310 TouchHudProjection* touch_hud_projection_; 311 312 // Handles double clicks on the panel window header. 313 scoped_ptr<ui::EventHandler> panel_container_handler_; 314 315 scoped_ptr<DesktopBackgroundWidgetController> wallpaper_controller_; 316 scoped_ptr<AnimatingDesktopController> animating_wallpaper_controller_; 317 scoped_ptr< ::wm::ScopedCaptureClient> capture_client_; 318 319 DISALLOW_COPY_AND_ASSIGN(RootWindowController); 320}; 321 322 323// Gets the RootWindowController for |root_window|. 324ASH_EXPORT RootWindowController* GetRootWindowController( 325 const aura::Window* root_window); 326 327} // namespace ash 328 329#endif // ASH_ROOT_WINDOW_CONTROLLER_H_ 330