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