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_MANAGER_H_ 6 #define ASH_DISPLAY_DISPLAY_MANAGER_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "ash/ash_export.h" 12 #include "ash/display/display_info.h" 13 #include "ash/display/display_layout.h" 14 #include "base/compiler_specific.h" 15 #include "base/gtest_prod_util.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "ui/gfx/display.h" 18 19 #if defined(OS_CHROMEOS) 20 #include "ui/display/chromeos/display_configurator.h" 21 #endif 22 23 namespace gfx { 24 class Display; 25 class Insets; 26 class Rect; 27 class Screen; 28 } 29 30 namespace ash { 31 class AcceleratorControllerTest; 32 class DisplayController; 33 class DisplayLayoutStore; 34 class ScreenAsh; 35 36 namespace test { 37 class DisplayManagerTestApi; 38 class SystemGestureEventFilterTest; 39 } 40 41 // DisplayManager maintains the current display configurations, 42 // and notifies observers when configuration changes. 43 // 44 // TODO(oshima): Make this non internal. 45 class ASH_EXPORT DisplayManager 46 #if defined(OS_CHROMEOS) 47 : public ui::DisplayConfigurator::SoftwareMirroringController 48 #endif 49 { 50 public: 51 class ASH_EXPORT Delegate { 52 public: ~Delegate()53 virtual ~Delegate() {} 54 55 // Create or updates the non desktop window with |display_info|. 56 virtual void CreateOrUpdateNonDesktopDisplay( 57 const DisplayInfo& display_info) = 0; 58 59 // Closes the mirror window if exists. 60 virtual void CloseNonDesktopDisplay() = 0; 61 62 // Called before and after the display configuration changes. 63 // When |clear_focus| is true, the implementation should 64 // deactivate the active window and set the focus window to NULL. 65 virtual void PreDisplayConfigurationChange(bool clear_focus) = 0; 66 virtual void PostDisplayConfigurationChange() = 0; 67 }; 68 69 // How the second display will be used. 70 // 1) EXTENDED mode extends the desktop to the second dislpay. 71 // 2) MIRRORING mode copies the content of the primary display to 72 // the 2nd display. (Software Mirroring). 73 enum SecondDisplayMode { 74 EXTENDED, 75 MIRRORING 76 }; 77 78 // Returns the list of possible UI scales for the display. 79 static std::vector<float> GetScalesForDisplay(const DisplayInfo& info); 80 81 // Returns next valid UI scale. 82 static float GetNextUIScale(const DisplayInfo& info, bool up); 83 84 // Updates the bounds of the display given by |secondary_display_id| 85 // according to |layout|. 86 static void UpdateDisplayBoundsForLayoutById( 87 const DisplayLayout& layout, 88 const gfx::Display& primary_display, 89 int64 secondary_display_id); 90 91 DisplayManager(); 92 virtual ~DisplayManager(); 93 layout_store()94 DisplayLayoutStore* layout_store() { 95 return layout_store_.get(); 96 } 97 screen()98 gfx::Screen* screen() { 99 return screen_; 100 } 101 set_delegate(Delegate * delegate)102 void set_delegate(Delegate* delegate) { delegate_ = delegate; } 103 104 // When set to true, the MonitorManager calls OnDisplayMetricsChanged 105 // even if the display's bounds didn't change. Used to swap primary 106 // display. set_force_bounds_changed(bool force_bounds_changed)107 void set_force_bounds_changed(bool force_bounds_changed) { 108 force_bounds_changed_ = force_bounds_changed; 109 } 110 111 // Returns the display id of the first display in the outupt list. first_display_id()112 int64 first_display_id() const { return first_display_id_; } 113 114 // Initializes displays using command line flag. Returns false 115 // if no command line flag was provided. 116 bool InitFromCommandLine(); 117 118 // Initialize default display. 119 void InitDefaultDisplay(); 120 121 // Initializes font related params that depends on display 122 // configuration. 123 void InitFontParams(); 124 125 // True if the given |display| is currently connected. 126 bool IsActiveDisplay(const gfx::Display& display) const; 127 128 // True if there is an internal display. 129 bool HasInternalDisplay() const; 130 131 bool IsInternalDisplayId(int64 id) const; 132 133 // Returns the display layout used for current displays. 134 DisplayLayout GetCurrentDisplayLayout(); 135 136 // Returns the current display pair. 137 DisplayIdPair GetCurrentDisplayIdPair() const; 138 139 // Sets the layout for the current display pair. The |layout| specifies 140 // the locaion of the secondary display relative to the primary. 141 void SetLayoutForCurrentDisplays( 142 const DisplayLayout& layout_relative_to_primary); 143 144 // Returns display for given |id|; 145 const gfx::Display& GetDisplayForId(int64 id) const; 146 147 // Finds the display that contains |point| in screeen coordinates. 148 // Returns invalid display if there is no display that can satisfy 149 // the condition. 150 const gfx::Display& FindDisplayContainingPoint( 151 const gfx::Point& point_in_screen) const; 152 153 // Sets the work area's |insets| to the display given by |display_id|. 154 bool UpdateWorkAreaOfDisplay(int64 display_id, const gfx::Insets& insets); 155 156 // Registers the overscan insets for the display of the specified ID. Note 157 // that the insets size should be specified in DIP size. It also triggers the 158 // display's bounds change. 159 void SetOverscanInsets(int64 display_id, const gfx::Insets& insets_in_dip); 160 161 // Sets the display's rotation. 162 void SetDisplayRotation(int64 display_id, gfx::Display::Rotation rotation); 163 164 // Sets the display's ui scale. 165 // TODO(mukai): remove this and merge into SetDisplayMode. 166 void SetDisplayUIScale(int64 display_id, float ui_scale); 167 168 // Sets the display's resolution. 169 // TODO(mukai): remove this and merge into SetDisplayMode. 170 void SetDisplayResolution(int64 display_id, const gfx::Size& resolution); 171 172 // Sets the external display's configuration, including resolution change, 173 // ui-scale change, and device scale factor change. Returns true if it changes 174 // the display resolution so that the caller needs to show a notification in 175 // case the new resolution actually doesn't work. 176 bool SetDisplayMode(int64 display_id, const DisplayMode& display_mode); 177 178 // Register per display properties. |overscan_insets| is NULL if 179 // the display has no custom overscan insets. 180 void RegisterDisplayProperty(int64 display_id, 181 gfx::Display::Rotation rotation, 182 float ui_scale, 183 const gfx::Insets* overscan_insets, 184 const gfx::Size& resolution_in_pixels, 185 float device_scale_factor, 186 ui::ColorCalibrationProfile color_profile); 187 188 // Register stored rotation properties for the internal display. 189 void RegisterDisplayRotationProperties(bool rotation_lock, 190 gfx::Display::Rotation rotation); 191 192 // Returns the stored rotation lock preference if it has been loaded, 193 // otherwise false. registered_internal_display_rotation_lock()194 bool registered_internal_display_rotation_lock() const { 195 return registered_internal_display_rotation_lock_; 196 } 197 198 // Returns the stored rotation preference for the internal display if it has 199 // been loaded, otherwise |gfx::Display::Rotate_0|. registered_internal_display_rotation()200 gfx::Display::Rotation registered_internal_display_rotation() const { 201 return registered_internal_display_rotation_; 202 } 203 204 // Returns the display mode of |display_id| which is currently used. 205 DisplayMode GetActiveModeForDisplayId(int64 display_id) const; 206 207 // Returns the display's selected mode. This returns false and doesn't 208 // set |mode_out| if the display mode is in default. 209 bool GetSelectedModeForDisplayId(int64 display_id, 210 DisplayMode* mode_out) const; 211 212 // Tells if the virtual resolution feature is enabled. 213 bool IsDisplayUIScalingEnabled() const; 214 215 // Returns the current overscan insets for the specified |display_id|. 216 // Returns an empty insets (0, 0, 0, 0) if no insets are specified for 217 // the display. 218 gfx::Insets GetOverscanInsets(int64 display_id) const; 219 220 // Sets the color calibration of the display to |profile|. 221 void SetColorCalibrationProfile(int64 display_id, 222 ui::ColorCalibrationProfile profile); 223 224 // Called when display configuration has changed. The new display 225 // configurations is passed as a vector of Display object, which 226 // contains each display's new infomration. 227 void OnNativeDisplaysChanged( 228 const std::vector<DisplayInfo>& display_info_list); 229 230 // Updates the internal display data and notifies observers about the changes. 231 void UpdateDisplays(const std::vector<DisplayInfo>& display_info_list); 232 233 // Updates current displays using current |display_info_|. 234 void UpdateDisplays(); 235 236 // Returns the display at |index|. The display at 0 is 237 // no longer considered "primary". 238 const gfx::Display& GetDisplayAt(size_t index) const; 239 240 const gfx::Display& GetPrimaryDisplayCandidate() const; 241 242 // Returns the logical number of displays. This returns 1 243 // when displays are mirrored. 244 size_t GetNumDisplays() const; 245 displays()246 const std::vector<gfx::Display>& displays() const { return displays_; } 247 248 // Returns the number of connected displays. This returns 2 249 // when displays are mirrored. num_connected_displays()250 size_t num_connected_displays() const { return num_connected_displays_; } 251 252 // Returns the mirroring status. 253 bool IsMirrored() const; mirrored_display_id()254 int64 mirrored_display_id() const { return mirrored_display_id_; } 255 256 // Returns the display object that is not a part of desktop. non_desktop_display()257 const gfx::Display& non_desktop_display() const { 258 return non_desktop_display_; 259 } 260 261 // Retuns the display info associated with |display_id|. 262 const DisplayInfo& GetDisplayInfo(int64 display_id) const; 263 264 // Returns the human-readable name for the display |id|. 265 std::string GetDisplayNameForId(int64 id); 266 267 // Returns the display id that is capable of UI scaling. On device, 268 // this returns internal display's ID if its device scale factor is 2, 269 // or invalid ID if such internal display doesn't exist. On linux 270 // desktop, this returns the first display ID. 271 int64 GetDisplayIdForUIScaling() const; 272 273 // Change the mirror mode. 274 void SetMirrorMode(bool mirrored); 275 276 // Used to emulate display change when run in a desktop environment instead 277 // of on a device. 278 void AddRemoveDisplay(); 279 void ToggleDisplayScaleFactor(); 280 281 // SoftwareMirroringController override: 282 #if defined(OS_CHROMEOS) 283 virtual void SetSoftwareMirroring(bool enabled) OVERRIDE; 284 virtual bool SoftwareMirroringEnabled() const OVERRIDE; 285 #endif software_mirroring_enabled()286 bool software_mirroring_enabled() const { 287 return second_display_mode_ == MIRRORING; 288 }; 289 290 // Sets/gets second display mode. 291 void SetSecondDisplayMode(SecondDisplayMode mode); second_display_mode()292 SecondDisplayMode second_display_mode() const { 293 return second_display_mode_; 294 } 295 296 // Update the bounds of the display given by |display_id|. 297 bool UpdateDisplayBounds(int64 display_id, 298 const gfx::Rect& new_bounds); 299 300 // Creates mirror window if the software mirror mode is enabled. 301 // This is used only for bootstrap. 302 void CreateMirrorWindowIfAny(); 303 304 // Create a screen instance to be used during shutdown. 305 void CreateScreenForShutdown() const; 306 307 private: 308 FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, ConvertPoint); 309 FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, TestNativeDisplaysChanged); 310 FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, 311 NativeDisplaysChangedAfterPrimaryChange); 312 FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, AutomaticOverscanInsets); 313 friend class ash::AcceleratorControllerTest; 314 friend class test::DisplayManagerTestApi; 315 friend class test::SystemGestureEventFilterTest; 316 friend class DisplayManagerTest; 317 318 typedef std::vector<gfx::Display> DisplayList; 319 set_change_display_upon_host_resize(bool value)320 void set_change_display_upon_host_resize(bool value) { 321 change_display_upon_host_resize_ = value; 322 } 323 324 gfx::Display* FindDisplayForId(int64 id); 325 326 // Add the mirror display's display info if the software based 327 // mirroring is in use. 328 void AddMirrorDisplayInfoIfAny(std::vector<DisplayInfo>* display_info_list); 329 330 // Inserts and update the DisplayInfo according to the overscan 331 // state. Note that The DisplayInfo stored in the |internal_display_info_| 332 // can be different from |new_info| (due to overscan state), so 333 // you must use |GetDisplayInfo| to get the correct DisplayInfo for 334 // a display. 335 void InsertAndUpdateDisplayInfo(const DisplayInfo& new_info); 336 337 // Called when the display info is updated through InsertAndUpdateDisplayInfo. 338 void OnDisplayInfoUpdated(const DisplayInfo& display_info); 339 340 // Creates a display object from the DisplayInfo for |display_id|. 341 gfx::Display CreateDisplayFromDisplayInfoById(int64 display_id); 342 343 // Updates the bounds of the secondary display in |display_list| 344 // using the layout registered for the display pair and set the 345 // index of display updated to |updated_index|. Returns true 346 // if the secondary display's bounds has been changed from current 347 // value, or false otherwise. 348 bool UpdateSecondaryDisplayBoundsForLayout(DisplayList* display_list, 349 size_t* updated_index) const; 350 351 static void UpdateDisplayBoundsForLayout( 352 const DisplayLayout& layout, 353 const gfx::Display& primary_display, 354 gfx::Display* secondary_display); 355 356 Delegate* delegate_; // not owned. 357 358 scoped_ptr<ScreenAsh> screen_ash_; 359 // This is to have an accessor without ScreenAsh definition. 360 gfx::Screen* screen_; 361 362 scoped_ptr<DisplayLayoutStore> layout_store_; 363 364 int64 first_display_id_; 365 366 // List of current active displays. 367 DisplayList displays_; 368 369 int num_connected_displays_; 370 371 bool force_bounds_changed_; 372 373 // The mapping from the display ID to its internal data. 374 std::map<int64, DisplayInfo> display_info_; 375 376 // Selected display modes for displays. Key is the displays' ID. 377 std::map<int64, DisplayMode> display_modes_; 378 379 // When set to true, the host window's resize event updates 380 // the display's size. This is set to true when running on 381 // desktop environment (for debugging) so that resizing the host 382 // window will update the display properly. This is set to false 383 // on device as well as during the unit tests. 384 bool change_display_upon_host_resize_; 385 386 SecondDisplayMode second_display_mode_; 387 int64 mirrored_display_id_; 388 gfx::Display non_desktop_display_; 389 390 // User preference for rotation lock of the internal display. 391 bool registered_internal_display_rotation_lock_; 392 393 // User preference for the rotation of the internal display. 394 gfx::Display::Rotation registered_internal_display_rotation_; 395 396 DISALLOW_COPY_AND_ASSIGN(DisplayManager); 397 }; 398 399 } // namespace ash 400 401 #endif // ASH_DISPLAY_DISPLAY_MANAGER_H_ 402