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
23namespace gfx {
24class Display;
25class Insets;
26class Rect;
27class Screen;
28}
29
30namespace ash {
31class AcceleratorControllerTest;
32class DisplayController;
33class DisplayLayoutStore;
34class ScreenAsh;
35
36namespace test {
37class DisplayManagerTestApi;
38class 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.
45class 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:
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
94  DisplayLayoutStore* layout_store() {
95    return layout_store_.get();
96  }
97
98  gfx::Screen* screen() {
99    return screen_;
100  }
101
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.
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.
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.
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|.
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
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.
250  size_t num_connected_displays() const { return num_connected_displays_; }
251
252  // Returns the mirroring status.
253  bool IsMirrored() const;
254  int64 mirrored_display_id() const { return mirrored_display_id_; }
255
256  // Returns the display object that is not a part of desktop.
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
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);
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
307private:
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
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