display_manager.h revision 8bcbed890bc3ce4d7a057a8f32cab53fa534672e 
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(bool display_removed) = 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  // Sets the layout for the current display pair. The |layout| specifies
117  // the locaion of the secondary display relative to the primary.
118  void SetLayoutForCurrentDisplays(
119      const DisplayLayout& layout_relative_to_primary);
120
121  // Returns display for given |id|;
122  const gfx::Display& GetDisplayForId(int64 id) const;
123
124  // Finds the display that contains |point| in screeen coordinates.
125  // Returns invalid display if there is no display that can satisfy
126  // the condition.
127  const gfx::Display& FindDisplayContainingPoint(
128      const gfx::Point& point_in_screen) const;
129
130  // Sets the work area's |insets| to the display given by |display_id|.
131  bool UpdateWorkAreaOfDisplay(int64 display_id, const gfx::Insets& insets);
132
133  // Registers the overscan insets for the display of the specified ID. Note
134  // that the insets size should be specified in DIP size. It also triggers the
135  // display's bounds change.
136  void SetOverscanInsets(int64 display_id, const gfx::Insets& insets_in_dip);
137
138  // Sets the display's rotation.
139  void SetDisplayRotation(int64 display_id, gfx::Display::Rotation rotation);
140
141  // Sets the display's ui scale.
142  void SetDisplayUIScale(int64 display_id, float ui_scale);
143
144  // Sets the display's resolution.
145  void SetDisplayResolution(int64 display_id, const gfx::Size& resolution);
146
147  // Register per display properties. |overscan_insets| is NULL if
148  // the display has no custom overscan insets.
149  void RegisterDisplayProperty(int64 display_id,
150                               gfx::Display::Rotation rotation,
151                               float ui_scale,
152                               const gfx::Insets* overscan_insets,
153                               const gfx::Size& resolution_in_pixels);
154
155  // Returns the display's selected resolution.
156  bool GetSelectedResolutionForDisplayId(int64 display_id,
157                                         gfx::Size* resolution_out) const;
158
159  // Tells if the virtual resolution feature is enabled.
160  bool IsDisplayUIScalingEnabled() const;
161
162  // Returns the current overscan insets for the specified |display_id|.
163  // Returns an empty insets (0, 0, 0, 0) if no insets are specified for
164  // the display.
165  gfx::Insets GetOverscanInsets(int64 display_id) const;
166
167  // Called when display configuration has changed. The new display
168  // configurations is passed as a vector of Display object, which
169  // contains each display's new infomration.
170  void OnNativeDisplaysChanged(
171      const std::vector<DisplayInfo>& display_info_list);
172
173  // Updates the internal display data and notifies observers about the changes.
174  void UpdateDisplays(const std::vector<DisplayInfo>& display_info_list);
175
176  // Updates current displays using current |display_info_|.
177  void UpdateDisplays();
178
179  // Returns the display at |index|. The display at 0 is
180  // no longer considered "primary".
181  const gfx::Display& GetDisplayAt(size_t index) const;
182
183  const gfx::Display& GetPrimaryDisplayCandidate() const;
184
185  // Returns the logical number of displays. This returns 1
186  // when displays are mirrored.
187  size_t GetNumDisplays() const;
188
189  const std::vector<gfx::Display>& displays() const { return displays_; }
190
191  // Returns the number of connected displays. This returns 2
192  // when displays are mirrored.
193  size_t num_connected_displays() const { return num_connected_displays_; }
194
195  // Returns the mirroring status.
196  bool IsMirrored() const;
197  const gfx::Display& mirrored_display() const { return mirrored_display_; }
198
199  // Retuns the display info associated with |display_id|.
200  const DisplayInfo& GetDisplayInfo(int64 display_id) const;
201
202  // Returns the human-readable name for the display |id|.
203  std::string GetDisplayNameForId(int64 id);
204
205  // Returns the display id that is capable of UI scaling. On device,
206  // this returns internal display's ID if its device scale factor is 2,
207  // or invalid ID if such internal display doesn't exist. On linux
208  // desktop, this returns the first display ID.
209  int64 GetDisplayIdForUIScaling() const;
210
211  // Change the mirror mode.
212  void SetMirrorMode(bool mirrored);
213
214  // Used to emulate display change when run in a desktop environment instead
215  // of on a device.
216  void AddRemoveDisplay();
217  void ToggleDisplayScaleFactor();
218
219  // SoftwareMirroringController override:
220#if defined(OS_CHROMEOS)
221  virtual void SetSoftwareMirroring(bool enabled) OVERRIDE;
222#else
223  void SetSoftwareMirroring(bool enabled);
224#endif
225  bool software_mirroring_enabled() const {
226    return software_mirroring_enabled_;
227  };
228
229  // Update the bounds of the display given by |display_id|.
230  bool UpdateDisplayBounds(int64 display_id,
231                           const gfx::Rect& new_bounds);
232
233  // Creates mirror window if the software mirror mode is enabled.
234  // This is used only for bootstrap.
235  void CreateMirrorWindowIfAny();
236
237private:
238  FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, ConvertPoint);
239  FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, TestNativeDisplaysChanged);
240  FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest,
241                           NativeDisplaysChangedAfterPrimaryChange);
242  FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, AutomaticOverscanInsets);
243  friend class ash::AcceleratorControllerTest;
244  friend class test::DisplayManagerTestApi;
245  friend class test::SystemGestureEventFilterTest;
246  friend class DisplayManagerTest;
247
248  typedef std::vector<gfx::Display> DisplayList;
249
250  void set_change_display_upon_host_resize(bool value) {
251    change_display_upon_host_resize_ = value;
252  }
253
254  gfx::Display* FindDisplayForId(int64 id);
255
256  // Add the mirror display's display info if the software based
257  // mirroring is in use.
258  void AddMirrorDisplayInfoIfAny(std::vector<DisplayInfo>* display_info_list);
259
260  // Inserts and update the DisplayInfo according to the overscan
261  // state. Note that The DisplayInfo stored in the |internal_display_info_|
262  // can be different from |new_info| (due to overscan state), so
263  // you must use |GetDisplayInfo| to get the correct DisplayInfo for
264  // a display.
265  void InsertAndUpdateDisplayInfo(const DisplayInfo& new_info);
266
267  // Creates a display object from the DisplayInfo for |display_id|.
268  gfx::Display CreateDisplayFromDisplayInfoById(int64 display_id);
269
270  // Updates the bounds of the secondary display in |display_list|
271  // using the layout registered for the display pair and set the
272  // index of display updated to |updated_index|. Returns true
273  // if the secondary display's bounds has been changed from current
274  // value, or false otherwise.
275  bool UpdateSecondaryDisplayBoundsForLayout(DisplayList* display_list,
276                                             size_t* updated_index) const;
277
278  static void UpdateDisplayBoundsForLayout(
279      const DisplayLayout& layout,
280      const gfx::Display& primary_display,
281      gfx::Display* secondary_display);
282
283  Delegate* delegate_;  // not owned.
284
285  scoped_ptr<DisplayLayoutStore> layout_store_;
286
287  int64 first_display_id_;
288
289  gfx::Display mirrored_display_;
290
291  // List of current active dispays.
292  DisplayList displays_;
293
294  int num_connected_displays_;
295
296  bool force_bounds_changed_;
297
298  // The mapping from the display ID to its internal data.
299  std::map<int64, DisplayInfo> display_info_;
300
301  // Selected resolutions for displays. Key is the displays' ID.
302  std::map<int64, gfx::Size> resolutions_;
303
304  // When set to true, the host window's resize event updates
305  // the display's size. This is set to true when running on
306  // desktop environment (for debugging) so that resizing the host
307  // window wil update the display properly. This is set to false
308  // on device as well as during the unit tests.
309  bool change_display_upon_host_resize_;
310
311  bool software_mirroring_enabled_;
312
313  DISALLOW_COPY_AND_ASSIGN(DisplayManager);
314};
315
316}  // namespace internal
317}  // namespace ash
318
319#endif  // ASH_DISPLAY_DISPLAY_MANAGER_H_
320