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