1// Copyright (c) 2013 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_INFO_H_
6#define ASH_DISPLAY_DISPLAY_INFO_H_
7
8#include <string>
9#include <vector>
10
11#include "ash/ash_export.h"
12#include "ui/display/types/display_constants.h"
13#include "ui/gfx/display.h"
14#include "ui/gfx/insets.h"
15#include "ui/gfx/rect.h"
16
17namespace ash {
18
19// A struct that represents the display's mode info.
20struct ASH_EXPORT DisplayMode {
21  DisplayMode();
22  DisplayMode(const gfx::Size& size,
23              float refresh_rate,
24              bool interlaced,
25              bool native);
26
27  // Returns the size in DIP which isvisible to the user.
28  gfx::Size GetSizeInDIP() const;
29
30  // Returns true if |other| has same size and scale factors.
31  bool IsEquivalent(const DisplayMode& other) const;
32
33  gfx::Size size;      // Physical pixel size of the display.
34  float refresh_rate;  // Refresh rate of the display, in Hz.
35  bool interlaced;     // True if mode is interlaced.
36  bool native;         // True if mode is native mode of the display.
37  float ui_scale;      // The UI scale factor of the mode.
38  float device_scale_factor;  // The device scale factor of the mode.
39};
40
41// DisplayInfo contains metadata for each display. This is used to
42// create |gfx::Display| as well as to maintain extra infomation
43// to manage displays in ash environment.
44// This class is intentionally made copiable.
45class ASH_EXPORT DisplayInfo {
46 public:
47  // Creates a DisplayInfo from string spec. 100+200-1440x800 creates display
48  // whose size is 1440x800 at the location (100, 200) in host coordinates.
49  // The format is
50  //
51  // [origin-]widthxheight[*device_scale_factor][#resolutions list]
52  //     [/<properties>][@ui-scale]
53  //
54  // where [] are optional:
55  // - |origin| is given in x+y- format.
56  // - |device_scale_factor| is either 2 or 1 (or empty).
57  // - properties can combination of 'o', which adds default overscan insets
58  //   (5%), and one rotation property where 'r' is 90 degree clock-wise
59  //   (to the 'r'ight) 'u' is 180 degrees ('u'pside-down) and 'l' is
60  //   270 degrees (to the 'l'eft).
61  // - ui-scale is floating value, e.g. @1.5 or @1.25.
62  // - |resolution list| is the list of size that is given in
63  //   |width x height [% refresh_rate]| separated by '|'.
64  //
65  // A couple of examples:
66  // "100x100"
67  //      100x100 window at 0,0 origin. 1x device scale factor. no overscan.
68  //      no rotation. 1.0 ui scale.
69  // "5+5-300x200*2"
70  //      300x200 window at 5,5 origin. 2x device scale factor.
71  //      no overscan, no rotation. 1.0 ui scale.
72  // "300x200/ol"
73  //      300x200 window at 0,0 origin. 1x device scale factor.
74  //      with 5% overscan. rotated to left (90 degree counter clockwise).
75  //      1.0 ui scale.
76  // "10+20-300x200/u@1.5"
77  //      300x200 window at 10,20 origin. 1x device scale factor.
78  //      no overscan. flipped upside-down (180 degree) and 1.5 ui scale.
79  // "200x100#300x200|200x100%59.0|100x100%60"
80  //      200x100 window at 0,0 origin, with 3 possible resolutions,
81  //      300x200, 200x100 at 59 Hz, and 100x100 at 60 Hz.
82  static DisplayInfo CreateFromSpec(const std::string& spec);
83
84  // Creates a DisplayInfo from string spec using given |id|.
85  static DisplayInfo CreateFromSpecWithID(const std::string& spec,
86                                          int64 id);
87
88  DisplayInfo();
89  DisplayInfo(int64 id, const std::string& name, bool has_overscan);
90  ~DisplayInfo();
91
92  // When this is set to true on the device whose internal display has
93  // 1.25 dsf, Chrome uses 1.0f as a default scale factor, and uses
94  // dsf 1.25 when UI scaling is set to 0.8f.
95  static void SetUse125DSFForUIScaling(bool enable);
96
97  int64 id() const { return id_; }
98
99  // The name of the display.
100  const std::string& name() const { return name_; }
101
102  // True if the display EDID has the overscan flag. This does not create the
103  // actual overscan automatically, but used in the message.
104  bool has_overscan() const { return has_overscan_; }
105
106  void set_rotation(gfx::Display::Rotation rotation) { rotation_ = rotation; }
107  gfx::Display::Rotation rotation() const { return rotation_; }
108
109  void set_touch_support(gfx::Display::TouchSupport support) {
110    touch_support_ = support;
111  }
112  gfx::Display::TouchSupport touch_support() const { return touch_support_; }
113
114  void set_touch_device_id(int id) { touch_device_id_ = id; }
115  int touch_device_id() const { return touch_device_id_; }
116
117  // Gets/Sets the device scale factor of the display.
118  float device_scale_factor() const { return device_scale_factor_; }
119  void set_device_scale_factor(float scale) { device_scale_factor_ = scale; }
120
121  // The native bounds for the display. The size of this can be
122  // different from the |size_in_pixel| when overscan insets are set
123  // and/or |configured_ui_scale_| is set.
124  const gfx::Rect& bounds_in_native() const {
125    return bounds_in_native_;
126  }
127
128  // The size for the display in pixels.
129  const gfx::Size& size_in_pixel() const { return size_in_pixel_; }
130
131  // The overscan insets for the display in DIP.
132  const gfx::Insets& overscan_insets_in_dip() const {
133    return overscan_insets_in_dip_;
134  }
135
136  // Sets/gets configured ui scale. This can be different from the ui
137  // scale actually used when the scale is 2.0 and DSF is 2.0.
138  // (the effective ui scale is 1.0 in this case).
139  float configured_ui_scale() const { return configured_ui_scale_; }
140  void set_configured_ui_scale(float scale) { configured_ui_scale_ = scale; }
141
142  // Returns the ui scale and device scale factor actually used to create
143  // display that chrome sees. This can be different from one obtained
144  // from dispaly or one specified by a user in following situation.
145  // 1) DSF is 2.0f and UI scale is 2.0f. (Returns 1.0f and 1.0f respectiely)
146  // 2) A user specified 0.8x on the device that has 1.25 DSF. 1.25 DSF device
147  //    uses 1.0f DFS unless 0.8x UI scaling is specified.
148  float GetEffectiveDeviceScaleFactor() const;
149
150  // Returns the ui scale used for the device scale factor. This
151  // return 1.0f if the ui scale and dsf are both set to 2.0.
152  float GetEffectiveUIScale() const;
153
154  // Copy the display info except for fields that can be modified by a
155  // user (|rotation_| and |configured_ui_scale_|). |rotation_| and
156  // |configured_ui_scale_| are copied when the |another_info| isn't native one.
157  void Copy(const DisplayInfo& another_info);
158
159  // Update the |bounds_in_native_| and |size_in_pixel_| using
160  // given |bounds_in_native|.
161  void SetBounds(const gfx::Rect& bounds_in_native);
162
163  // Update the |bounds_in_native| according to the current overscan
164  // and rotation settings.
165  void UpdateDisplaySize();
166
167  // Sets/Clears the overscan insets.
168  void SetOverscanInsets(const gfx::Insets& insets_in_dip);
169  gfx::Insets GetOverscanInsetsInPixel() const;
170
171  void set_native(bool native) { native_ = native; }
172  bool native() const { return native_; }
173
174  const std::vector<DisplayMode>& display_modes() const {
175    return display_modes_;
176  }
177  void set_display_modes(std::vector<DisplayMode>& display_modes) {
178    display_modes_.swap(display_modes);
179  }
180
181  // Returns the native mode size. If a native mode is not present, return an
182  // empty size.
183  gfx::Size GetNativeModeSize() const;
184
185  ui::ColorCalibrationProfile color_profile() const {
186    return color_profile_;
187  }
188
189  // Sets the color profile. It will ignore if the specified |profile| is not in
190  // |available_color_profiles_|.
191  void SetColorProfile(ui::ColorCalibrationProfile profile);
192
193  // Returns true if |profile| is in |available_color_profiles_|.
194  bool IsColorProfileAvailable(ui::ColorCalibrationProfile profile) const;
195
196  const std::vector<ui::ColorCalibrationProfile>&
197      available_color_profiles() const {
198    return available_color_profiles_;
199  }
200
201  void set_available_color_profiles(
202      const std::vector<ui::ColorCalibrationProfile>& profiles) {
203    available_color_profiles_ = profiles;
204  }
205
206  bool is_aspect_preserving_scaling() const {
207    return is_aspect_preserving_scaling_;
208  }
209
210  void set_is_aspect_preserving_scaling(bool value) {
211    is_aspect_preserving_scaling_ = value;
212  }
213
214  // Returns a string representation of the DisplayInfo, excluding display
215  // modes.
216  std::string ToString() const;
217
218  // Returns a string representation of the DisplayInfo, including display
219  // modes.
220  std::string ToFullString() const;
221
222 private:
223  int64 id_;
224  std::string name_;
225  bool has_overscan_;
226  gfx::Display::Rotation rotation_;
227  gfx::Display::TouchSupport touch_support_;
228
229  // If the display is also a touch device, it will have a positive
230  // |touch_device_id_|. Otherwise |touch_device_id_| is 0.
231  int touch_device_id_;
232
233  // This specifies the device's pixel density. (For example, a
234  // display whose DPI is higher than the threshold is considered to have
235  // device_scale_factor = 2.0 on Chrome OS).  This is used by the
236  // grapics layer to choose and draw appropriate images and scale
237  // layers properly.
238  float device_scale_factor_;
239  gfx::Rect bounds_in_native_;
240
241  // The size of the display in use. The size can be different from the size
242  // of |bounds_in_native_| if the display has overscan insets and/or rotation.
243  gfx::Size size_in_pixel_;
244  gfx::Insets overscan_insets_in_dip_;
245
246  // The pixel scale of the display. This is used to simply expand (or
247  // shrink) the desktop over the native display resolution (useful in
248  // HighDPI display).  Note that this should not be confused with the
249  // device scale factor, which specifies the pixel density of the
250  // display. The actuall scale value to be used depends on the device
251  // scale factor.  See |GetEffectiveScaleFactor()|.
252  float configured_ui_scale_;
253
254  // True if this comes from native platform (DisplayChangeObserver).
255  bool native_;
256
257  // True if the display is configured to preserve the aspect ratio. When the
258  // display is configured in a non-native mode, only parts of the display will
259  // be used such that the aspect ratio is preserved.
260  bool is_aspect_preserving_scaling_;
261
262  // The list of modes supported by this display.
263  std::vector<DisplayMode> display_modes_;
264
265  // The current profile of the color calibration.
266  ui::ColorCalibrationProfile color_profile_;
267
268  // The list of available variations for the color calibration.
269  std::vector<ui::ColorCalibrationProfile> available_color_profiles_;
270};
271
272}  // namespace ash
273
274#endif  //  ASH_DISPLAY_DISPLAY_INFO_H_
275