Home | History | Annotate | Download | only in ash
      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 
     18 class SkBitmap;
     19 
     20 namespace aura {
     21 class EventFilter;
     22 class RootWindow;
     23 class Window;
     24 }
     25 
     26 namespace gfx {
     27 class Point;
     28 }
     29 
     30 namespace views {
     31 class Widget;
     32 
     33 namespace corewm {
     34 class InputMethodEventFilter;
     35 class RootWindowEventFilter;
     36 }
     37 }
     38 
     39 namespace keyboard {
     40 class KeyboardController;
     41 }
     42 
     43 namespace ash {
     44 class StackingController;
     45 class ShelfWidget;
     46 class SystemTray;
     47 class ToplevelWindowEventHandler;
     48 
     49 namespace internal {
     50 
     51 class AlwaysOnTopController;
     52 class AnimatingDesktopController;
     53 class BootSplashScreen;
     54 class DesktopBackgroundWidgetController;
     55 class DockedWindowLayoutManager;
     56 class PanelLayoutManager;
     57 class RootWindowLayoutManager;
     58 class ScreenDimmer;
     59 class ShelfLayoutManager;
     60 class StatusAreaWidget;
     61 class SystemBackgroundController;
     62 class SystemModalContainerLayoutManager;
     63 class TouchHudDebug;
     64 class TouchHudProjection;
     65 class 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.
     72 class 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   // An invisible/empty window used as a event target for
    245   // |MouseCursorEventFilter| before a user logs in.
    246   // (crbug.com/266987)
    247   // Its container is |LockScreenBackgroundContainer| and
    248   // this must be deleted before the container is deleted.
    249   scoped_ptr<aura::Window> mouse_event_target_;
    250 
    251   // Manages layout of docked windows. Owned by DockedContainer.
    252   DockedWindowLayoutManager* docked_layout_manager_;
    253 
    254   // Manages layout of panels. Owned by PanelContainer.
    255   PanelLayoutManager* panel_layout_manager_;
    256 
    257   scoped_ptr<SystemBackgroundController> system_background_;
    258   scoped_ptr<BootSplashScreen> boot_splash_screen_;
    259 
    260   scoped_ptr<ScreenDimmer> screen_dimmer_;
    261   scoped_ptr<WorkspaceController> workspace_controller_;
    262   scoped_ptr<AlwaysOnTopController> always_on_top_controller_;
    263 
    264   // Heads-up displays for touch events. These HUDs are not owned by the root
    265   // window controller and manage their own lifetimes.
    266   TouchHudDebug* touch_hud_debug_;
    267   TouchHudProjection* touch_hud_projection_;
    268 
    269   // We need to own event handlers for various containers.
    270   scoped_ptr<ToplevelWindowEventHandler> default_container_handler_;
    271   scoped_ptr<ToplevelWindowEventHandler> always_on_top_container_handler_;
    272   scoped_ptr<ToplevelWindowEventHandler> modal_container_handler_;
    273   scoped_ptr<ToplevelWindowEventHandler> lock_modal_container_handler_;
    274   scoped_ptr<ToplevelWindowEventHandler> panel_container_handler_;
    275   scoped_ptr<ToplevelWindowEventHandler> docked_container_handler_;
    276 
    277   scoped_ptr<DesktopBackgroundWidgetController> wallpaper_controller_;
    278   scoped_ptr<AnimatingDesktopController> animating_wallpaper_controller_;
    279 
    280   DISALLOW_COPY_AND_ASSIGN(RootWindowController);
    281 };
    282 
    283 }  // namespace internal
    284 }  // ash
    285 
    286 #endif  //  ASH_ROOT_WINDOW_CONTROLLER_H_
    287