ash/display/display_info.h

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