Home | History | Annotate | Download | only in gfx 
      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 UI_GFX_DISPLAY_H_
      6 #define UI_GFX_DISPLAY_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/compiler_specific.h"
     10 #include "ui/gfx/gfx_export.h"
     11 #include "ui/gfx/rect.h"
     12 
     13 namespace gfx {
     14 
     15 // This class typically, but does not always, correspond to a physical display
     16 // connected to the system. A fake Display may exist on a headless system, or a
     17 // Display may correspond to a remote, virtual display.
     18 //
     19 // Note: The screen and display currently uses pixel coordinate
     20 // system. For platforms that support DIP (density independent pixel),
     21 // |bounds()| and |work_area| will return values in DIP coordinate
     22 // system, not in backing pixels.
     23 class GFX_EXPORT Display {
     24  public:
     25   // Screen Rotation in clock-wise degrees.
     26   enum Rotation {
     27     ROTATE_0 = 0,
     28     ROTATE_90,
     29     ROTATE_180,
     30     ROTATE_270,
     31   };
     32 
     33   // Touch support for the display.
     34   enum TouchSupport {
     35     TOUCH_SUPPORT_UNKNOWN,
     36     TOUCH_SUPPORT_AVAILABLE,
     37     TOUCH_SUPPORT_UNAVAILABLE,
     38   };
     39 
     40   // Creates a display with kInvalidDisplayID as default.
     41   Display();
     42   explicit Display(int64 id);
     43   Display(int64 id, const Rect& bounds);
     44   ~Display();
     45 
     46   // Returns the forced device scale factor, which is given by
     47   // "--force-device-scale-factor".
     48   static float GetForcedDeviceScaleFactor();
     49 
     50   // Indicates if a device scale factor is being explicitly enforced from the
     51   // command line via "--force-device-scale-factor".
     52   static bool HasForceDeviceScaleFactor();
     53 
     54   // Sets/Gets unique identifier associated with the display.
     55   // -1 means invalid display and it doesn't not exit.
     56   int64 id() const { return id_; }
     57   void set_id(int64 id) { id_ = id; }
     58 
     59   // Gets/Sets the display's bounds in gfx::Screen's coordinates.
     60   const Rect& bounds() const { return bounds_; }
     61   void set_bounds(const Rect& bounds) { bounds_ = bounds; }
     62 
     63   // Gets/Sets the display's work area in gfx::Screen's coordinates.
     64   const Rect& work_area() const { return work_area_; }
     65   void set_work_area(const Rect& work_area) { work_area_ = work_area; }
     66 
     67   // Output device's pixel scale factor. This specifies how much the
     68   // UI should be scaled when the actual output has more pixels than
     69   // standard displays (which is around 100~120dpi.) The potential return
     70   // values depend on each platforms.
     71   float device_scale_factor() const { return device_scale_factor_; }
     72   void set_device_scale_factor(float scale) { device_scale_factor_ = scale; }
     73 
     74   Rotation rotation() const { return rotation_; }
     75   void set_rotation(Rotation rotation) { rotation_ = rotation; }
     76   int RotationAsDegree() const;
     77   void SetRotationAsDegree(int rotation);
     78 
     79   TouchSupport touch_support() const { return touch_support_; }
     80   void set_touch_support(TouchSupport support) { touch_support_ = support; }
     81 
     82   // Utility functions that just return the size of display and
     83   // work area.
     84   const Size& size() const { return bounds_.size(); }
     85   const Size& work_area_size() const { return work_area_.size(); }
     86 
     87   // Returns the work area insets.
     88   Insets GetWorkAreaInsets() const;
     89 
     90   // Sets the device scale factor and display bounds in pixel. This
     91   // updates the work are using the same insets between old bounds and
     92   // work area.
     93   void SetScaleAndBounds(float device_scale_factor,
     94                          const gfx::Rect& bounds_in_pixel);
     95 
     96   // Sets the display's size. This updates the work area using the same insets
     97   // between old bounds and work area.
     98   void SetSize(const gfx::Size& size_in_pixel);
     99 
    100   // Computes and updates the display's work are using
    101   // |work_area_insets| and the bounds.
    102   void UpdateWorkAreaFromInsets(const gfx::Insets& work_area_insets);
    103 
    104   // Returns the display's size in pixel coordinates.
    105   gfx::Size GetSizeInPixel() const;
    106 
    107   // Returns a string representation of the display;
    108   std::string ToString() const;
    109 
    110   // True if the display contains valid display id.
    111   bool is_valid() const { return id_ != kInvalidDisplayID; }
    112 
    113   // True if the display corresponds to internal panel.
    114   bool IsInternal() const;
    115 
    116   // Gets/Sets an id of display corresponding to internal panel.
    117   static int64 InternalDisplayId();
    118   static void SetInternalDisplayId(int64 internal_display_id);
    119 
    120   static const int64 kInvalidDisplayID;
    121 
    122  private:
    123   int64 id_;
    124   Rect bounds_;
    125   Rect work_area_;
    126   float device_scale_factor_;
    127   Rotation rotation_;
    128   TouchSupport touch_support_;
    129 };
    130 
    131 }  // namespace gfx
    132 
    133 #endif  // UI_GFX_DISPLAY_H_
    134