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. OnDisplaysInitialized()61 virtual void OnDisplaysInitialized() {} 62 63 // Invoked when the display configuration change is requested, 64 // but before the change is applied to aura/ash. OnDisplayConfigurationChanging()65 virtual void OnDisplayConfigurationChanging() {} 66 67 // Invoked when the all display configuration changes 68 // have been applied. OnDisplayConfigurationChanged()69 virtual void OnDisplayConfigurationChanged() {}; 70 71 protected: ~Observer()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 cursor_window_controller()85 CursorWindowController* cursor_window_controller() { 86 return cursor_window_controller_.get(); 87 } 88 mirror_window_controller()89 MirrorWindowController* mirror_window_controller() { 90 return mirror_window_controller_.get(); 91 } 92 virtual_keyboard_window_controller()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_ 235