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