ash/display/display_controller.h

   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_DISPLAY_DISPLAY_CONTROLLER_H_
   6 #define ASH_DISPLAY_DISPLAY_CONTROLLER_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "ash/ash_export.h"
  12 #include "ash/display/display_manager.h"
  13 #include "base/basictypes.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/gtest_prod_util.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/observer_list.h"
  19 #include "base/time/time.h"
  20 #include "ui/aura/window.h"
  21 #include "ui/aura/window_tree_host_observer.h"
  22 #include "ui/gfx/display_observer.h"
  23 #include "ui/gfx/point.h"
  24
  25 namespace aura {
  26 class Display;
  27 class WindowTreeHost;
  28 }
  29
  30 namespace base {
  31 class Value;
  32 template <typename T> class JSONValueConverter;
  33 }
  34
  35 namespace gfx {
  36 class Display;
  37 class Insets;
  38 }
  39
  40 namespace ash {
  41 class AshWindowTreeHost;
  42 struct AshWindowTreeHostInitParams;
  43 class CursorWindowController;
  44 class DisplayInfo;
  45 class DisplayManager;
  46 class FocusActivationStore;
  47 class MirrorWindowController;
  48 class RootWindowController;
  49 class VirtualKeyboardWindowController;
  50
  51 // DisplayController owns and maintains RootWindows for each attached
  52 // display, keeping them in sync with display configuration changes.
  53 class ASH_EXPORT DisplayController : public gfx::DisplayObserver,
  54                                      public aura::WindowTreeHostObserver,
  55                                      public DisplayManager::Delegate {
  56  public:
  57   class ASH_EXPORT Observer {
  58    public:
  59     // Invoked only once after all displays are initialized
  60     // after startup.
  61     virtual void OnDisplaysInitialized() {}
  62
  63     // Invoked when the display configuration change is requested,
  64     // but before the change is applied to aura/ash.
  65     virtual void OnDisplayConfigurationChanging() {}
  66
  67     // Invoked when the all display configuration changes
  68     // have been applied.
  69     virtual void OnDisplayConfigurationChanged() {};
  70
  71    protected:
  72     virtual ~Observer() {}
  73   };
  74
  75   DisplayController();
  76   virtual ~DisplayController();
  77
  78   void Start();
  79   void Shutdown();
  80
  81   // Returns primary display's ID.
  82   // TODO(oshima): Move this out from DisplayController;
  83   static int64 GetPrimaryDisplayId();
  84
  85   CursorWindowController* cursor_window_controller() {
  86     return cursor_window_controller_.get();
  87   }
  88
  89   MirrorWindowController* mirror_window_controller() {
  90     return mirror_window_controller_.get();
  91   }
  92
  93   VirtualKeyboardWindowController* virtual_keyboard_window_controller() {
  94     return virtual_keyboard_window_controller_.get();
  95   }
  96
  97   // Create a WindowTreeHost for the primary display. This replaces
  98   // |initial_bounds| in |init_params|.
  99   void CreatePrimaryHost(const AshWindowTreeHostInitParams& init_params);
 100
 101   // Initializes all displays.
 102   void InitDisplays();
 103
 104   // Add/Remove observers.
 105   void AddObserver(Observer* observer);
 106   void RemoveObserver(Observer* observer);
 107
 108   // Returns the root window for primary display.
 109   aura::Window* GetPrimaryRootWindow();
 110
 111   // Returns the root window for |display_id|.
 112   aura::Window* GetRootWindowForDisplayId(int64 id);
 113
 114   // Toggle mirror mode.
 115   void ToggleMirrorMode();
 116
 117   // Swap primary and secondary display.
 118   void SwapPrimaryDisplay();
 119
 120   // Sets the ID of the primary display.  If the display is not connected, it
 121   // will switch the primary display when connected.
 122   void SetPrimaryDisplayId(int64 id);
 123
 124   // Sets primary display. This re-assigns the current root
 125   // window to given |display|.
 126   void SetPrimaryDisplay(const gfx::Display& display);
 127
 128   // Closes all child windows in the all root windows.
 129   void CloseChildWindows();
 130
 131   // Returns all root windows. In non extended desktop mode, this
 132   // returns the primary root window only.
 133   aura::Window::Windows GetAllRootWindows();
 134
 135   // Returns all oot window controllers. In non extended desktop
 136   // mode, this return a RootWindowController for the primary root window only.
 137   std::vector<RootWindowController*> GetAllRootWindowControllers();
 138
 139   // Gets/Sets/Clears the overscan insets for the specified |display_id|. See
 140   // display_manager.h for the details.
 141   gfx::Insets GetOverscanInsets(int64 display_id) const;
 142   void SetOverscanInsets(int64 display_id, const gfx::Insets& insets_in_dip);
 143
 144   // Checks if the mouse pointer is on one of displays, and moves to
 145   // the center of the nearest display if it's outside of all displays.
 146   void EnsurePointerInDisplays();
 147
 148   // Sets the work area's |insets| to the display assigned to |window|.
 149   bool UpdateWorkAreaOfDisplayNearestWindow(const aura::Window* window,
 150                                             const gfx::Insets& insets);
 151   // gfx::DisplayObserver overrides:
 152   virtual void OnDisplayAdded(const gfx::Display& display) OVERRIDE;
 153   virtual void OnDisplayRemoved(const gfx::Display& display) OVERRIDE;
 154   virtual void OnDisplayMetricsChanged(const gfx::Display& display,
 155                                        uint32_t metrics) OVERRIDE;
 156
 157   // aura::WindowTreeHostObserver overrides:
 158   virtual void OnHostResized(const aura::WindowTreeHost* host) OVERRIDE;
 159
 160   // aura::DisplayManager::Delegate overrides:
 161   virtual void CreateOrUpdateNonDesktopDisplay(const DisplayInfo& info)
 162       OVERRIDE;
 163   virtual void CloseNonDesktopDisplay() OVERRIDE;
 164   virtual void PreDisplayConfigurationChange(bool clear_focus) OVERRIDE;
 165   virtual void PostDisplayConfigurationChange() OVERRIDE;
 166
 167  private:
 168   FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, BoundsUpdated);
 169   FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, SecondaryDisplayLayout);
 170   friend class DisplayManager;
 171   friend class MirrorWindowController;
 172
 173   // Creates a WindowTreeHost for |display| and stores it in the
 174   // |window_tree_hosts_| map.
 175   AshWindowTreeHost* AddWindowTreeHostForDisplay(
 176       const gfx::Display& display,
 177       const AshWindowTreeHostInitParams& params);
 178
 179   void OnFadeOutForSwapDisplayFinished();
 180
 181   void SetMirrorModeAfterAnimation(bool mirror);
 182
 183   void UpdateHostWindowNames();
 184
 185   class DisplayChangeLimiter {
 186    public:
 187     DisplayChangeLimiter();
 188
 189     // Sets how long the throttling should last.
 190     void SetThrottleTimeout(int64 throttle_ms);
 191
 192     bool IsThrottled() const;
 193
 194    private:
 195     // The time when the throttling ends.
 196     base::Time throttle_timeout_;
 197
 198     DISALLOW_COPY_AND_ASSIGN(DisplayChangeLimiter);
 199   };
 200
 201   // The limiter to throttle how fast a user can
 202   // change the display configuration.
 203   scoped_ptr<DisplayChangeLimiter> limiter_;
 204
 205   typedef std::map<int64, AshWindowTreeHost*> WindowTreeHostMap;
 206   // The mapping from display ID to its window tree host.
 207   WindowTreeHostMap window_tree_hosts_;
 208
 209   ObserverList<Observer> observers_;
 210
 211   // Store the primary window tree host temporarily while replacing
 212   // display.
 213   AshWindowTreeHost* primary_tree_host_for_replace_;
 214
 215   scoped_ptr<FocusActivationStore> focus_activation_store_;
 216
 217   scoped_ptr<CursorWindowController> cursor_window_controller_;
 218   scoped_ptr<MirrorWindowController> mirror_window_controller_;
 219   scoped_ptr<VirtualKeyboardWindowController>
 220       virtual_keyboard_window_controller_;
 221
 222   // Stores the curent cursor location (in native coordinates) used to
 223   // restore the cursor location when display configuration
 224   // changed.
 225   gfx::Point cursor_location_in_native_coords_for_restore_;
 226
 227   base::WeakPtrFactory<DisplayController> weak_ptr_factory_;
 228
 229   DISALLOW_COPY_AND_ASSIGN(DisplayController);
 230 };
 231
 232 }  // namespace ash
 233
 234 #endif  // ASH_DISPLAY_DISPLAY_CONTROLLER_H_