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 17 namespace ash { 18 19 // A struct that represents the display's mode info. 20 struct 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. 45 class 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 id()97 int64 id() const { return id_; } 98 99 // The name of the display. name()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. has_overscan()104 bool has_overscan() const { return has_overscan_; } 105 set_rotation(gfx::Display::Rotation rotation)106 void set_rotation(gfx::Display::Rotation rotation) { rotation_ = rotation; } rotation()107 gfx::Display::Rotation rotation() const { return rotation_; } 108 set_touch_support(gfx::Display::TouchSupport support)109 void set_touch_support(gfx::Display::TouchSupport support) { 110 touch_support_ = support; 111 } touch_support()112 gfx::Display::TouchSupport touch_support() const { return touch_support_; } 113 set_touch_device_id(int id)114 void set_touch_device_id(int id) { touch_device_id_ = id; } touch_device_id()115 int touch_device_id() const { return touch_device_id_; } 116 117 // Gets/Sets the device scale factor of the display. device_scale_factor()118 float device_scale_factor() const { return device_scale_factor_; } set_device_scale_factor(float scale)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. bounds_in_native()124 const gfx::Rect& bounds_in_native() const { 125 return bounds_in_native_; 126 } 127 128 // The size for the display in pixels. size_in_pixel()129 const gfx::Size& size_in_pixel() const { return size_in_pixel_; } 130 131 // The overscan insets for the display in DIP. overscan_insets_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). configured_ui_scale()139 float configured_ui_scale() const { return configured_ui_scale_; } set_configured_ui_scale(float 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 set_native(bool native)171 void set_native(bool native) { native_ = native; } native()172 bool native() const { return native_; } 173 display_modes()174 const std::vector<DisplayMode>& display_modes() const { 175 return display_modes_; 176 } set_display_modes(std::vector<DisplayMode> & display_modes)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 color_profile()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>& available_color_profiles()197 available_color_profiles() const { 198 return available_color_profiles_; 199 } 200 set_available_color_profiles(const std::vector<ui::ColorCalibrationProfile> & profiles)201 void set_available_color_profiles( 202 const std::vector<ui::ColorCalibrationProfile>& profiles) { 203 available_color_profiles_ = profiles; 204 } 205 is_aspect_preserving_scaling()206 bool is_aspect_preserving_scaling() const { 207 return is_aspect_preserving_scaling_; 208 } 209 set_is_aspect_preserving_scaling(bool value)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