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