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 <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, Chrome switches High DPI when lower UI scale
  93   // (<1.0f) is specified on 1x device to make UI sharp, e.g, upgrade 0.6
  94   // scale on 1x DSF to 1.2 scale on 2x DSF.
  95   static void SetAllowUpgradeToHighDPI(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) Lower UI scale (< 1.0) is specified on 1.0f DSF device
 147   // when 2x resources is available. (Returns 2.0f DSF + 1.2f UI scale
 148   // for 1.0DSF + 0.6 UI scale).
 149   float GetEffectiveDeviceScaleFactor() const;
 150   float GetEffectiveUIScale() const;
 151
 152   // Copy the display info except for fields that can be modified by a
 153   // user (|rotation_| and |configured_ui_scale_|). |rotation_| and
 154   // |configured_ui_scale_| are copied when the |another_info| isn't native one.
 155   void Copy(const DisplayInfo& another_info);
 156
 157   // Update the |bounds_in_native_| and |size_in_pixel_| using
 158   // given |bounds_in_native|.
 159   void SetBounds(const gfx::Rect& bounds_in_native);
 160
 161   // Update the |bounds_in_native| according to the current overscan
 162   // and rotation settings.
 163   void UpdateDisplaySize();
 164
 165   // Sets/Clears the overscan insets.
 166   void SetOverscanInsets(const gfx::Insets& insets_in_dip);
 167   gfx::Insets GetOverscanInsetsInPixel() const;
 168
 169   void set_native(bool native) { native_ = native; }
 170   bool native() const { return native_; }
 171
 172   const std::vector<DisplayMode>& display_modes() const {
 173     return display_modes_;
 174   }
 175   void set_display_modes(std::vector<DisplayMode>& display_modes) {
 176     display_modes_.swap(display_modes);
 177   }
 178
 179   ui::ColorCalibrationProfile color_profile() const {
 180     return color_profile_;
 181   }
 182
 183   // Sets the color profile. It will ignore if the specified |profile| is not in
 184   // |available_color_profiles_|.
 185   void SetColorProfile(ui::ColorCalibrationProfile profile);
 186
 187   // Returns true if |profile| is in |available_color_profiles_|.
 188   bool IsColorProfileAvailable(ui::ColorCalibrationProfile profile) const;
 189
 190   const std::vector<ui::ColorCalibrationProfile>&
 191       available_color_profiles() const {
 192     return available_color_profiles_;
 193   }
 194
 195   void set_available_color_profiles(
 196       const std::vector<ui::ColorCalibrationProfile>& profiles) {
 197     available_color_profiles_ = profiles;
 198   }
 199
 200   bool is_aspect_preserving_scaling() const {
 201     return is_aspect_preserving_scaling_;
 202   }
 203
 204   void set_is_aspect_preserving_scaling(bool value) {
 205     is_aspect_preserving_scaling_ = value;
 206   }
 207
 208   // Returns a string representation of the DisplayInfo, excluding display
 209   // modes.
 210   std::string ToString() const;
 211
 212   // Returns a string representation of the DisplayInfo, including display
 213   // modes.
 214   std::string ToFullString() const;
 215
 216  private:
 217   int64 id_;
 218   std::string name_;
 219   bool has_overscan_;
 220   gfx::Display::Rotation rotation_;
 221   gfx::Display::TouchSupport touch_support_;
 222
 223   // If the display is also a touch device, it will have a positive
 224   // |touch_device_id_|. Otherwise |touch_device_id_| is 0.
 225   int touch_device_id_;
 226
 227   // This specifies the device's pixel density. (For example, a
 228   // display whose DPI is higher than the threshold is considered to have
 229   // device_scale_factor = 2.0 on Chrome OS).  This is used by the
 230   // grapics layer to choose and draw appropriate images and scale
 231   // layers properly.
 232   float device_scale_factor_;
 233   gfx::Rect bounds_in_native_;
 234
 235   // The size of the display in use. The size can be different from the size
 236   // of |bounds_in_native_| if the display has overscan insets and/or rotation.
 237   gfx::Size size_in_pixel_;
 238   gfx::Insets overscan_insets_in_dip_;
 239
 240   // The pixel scale of the display. This is used to simply expand (or
 241   // shrink) the desktop over the native display resolution (useful in
 242   // HighDPI display).  Note that this should not be confused with the
 243   // device scale factor, which specifies the pixel density of the
 244   // display. The actuall scale value to be used depends on the device
 245   // scale factor.  See |GetEffectiveScaleFactor()|.
 246   float configured_ui_scale_;
 247
 248   // True if this comes from native platform (DisplayChangeObserver).
 249   bool native_;
 250
 251   // True if the display is configured to preserve the aspect ratio. When the
 252   // display is configured in a non-native mode, only parts of the display will
 253   // be used such that the aspect ratio is preserved.
 254   bool is_aspect_preserving_scaling_;
 255
 256   // The list of modes supported by this display.
 257   std::vector<DisplayMode> display_modes_;
 258
 259   // The current profile of the color calibration.
 260   ui::ColorCalibrationProfile color_profile_;
 261
 262   // The list of available variations for the color calibration.
 263   std::vector<ui::ColorCalibrationProfile> available_color_profiles_;
 264 };
 265
 266 }  // namespace ash
 267
 268 #endif  //  ASH_DISPLAY_DISPLAY_INFO_H_