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