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 #include "ui/gfx/display.h"
6
7 #include <algorithm>
8
9 #include "base/command_line.h"
10 #include "base/logging.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/strings/stringprintf.h"
13 #include "ui/gfx/insets.h"
14 #include "ui/gfx/point_conversions.h"
15 #include "ui/gfx/point_f.h"
16 #include "ui/gfx/size_conversions.h"
17 #include "ui/gfx/switches.h"
18
19 namespace gfx {
20 namespace {
21
HasForceDeviceScaleFactorImpl()22 bool HasForceDeviceScaleFactorImpl() {
23 return CommandLine::ForCurrentProcess()->HasSwitch(
24 switches::kForceDeviceScaleFactor);
25 }
26
GetForcedDeviceScaleFactorImpl()27 float GetForcedDeviceScaleFactorImpl() {
28 double scale_in_double = 1.0;
29 if (HasForceDeviceScaleFactorImpl()) {
30 std::string value = CommandLine::ForCurrentProcess()->
31 GetSwitchValueASCII(switches::kForceDeviceScaleFactor);
32 if (!base::StringToDouble(value, &scale_in_double))
33 LOG(ERROR) << "Failed to parse the default device scale factor:" << value;
34 }
35 return static_cast<float>(scale_in_double);
36 }
37
38 const int64 kInvalidDisplayIDForCompileTimeInit = -1;
39 int64 internal_display_id_ = kInvalidDisplayIDForCompileTimeInit;
40
41 } // namespace
42
43 const int64 Display::kInvalidDisplayID = kInvalidDisplayIDForCompileTimeInit;
44
45 // static
GetForcedDeviceScaleFactor()46 float Display::GetForcedDeviceScaleFactor() {
47 static const float kForcedDeviceScaleFactor =
48 GetForcedDeviceScaleFactorImpl();
49 return kForcedDeviceScaleFactor;
50 }
51
52 //static
HasForceDeviceScaleFactor()53 bool Display::HasForceDeviceScaleFactor() {
54 return HasForceDeviceScaleFactorImpl();
55 }
56
Display()57 Display::Display()
58 : id_(kInvalidDisplayID),
59 device_scale_factor_(GetForcedDeviceScaleFactor()),
60 rotation_(ROTATE_0),
61 touch_support_(TOUCH_SUPPORT_UNKNOWN) {
62 }
63
Display(int64 id)64 Display::Display(int64 id)
65 : id_(id),
66 device_scale_factor_(GetForcedDeviceScaleFactor()),
67 rotation_(ROTATE_0),
68 touch_support_(TOUCH_SUPPORT_UNKNOWN) {
69 }
70
Display(int64 id,const gfx::Rect & bounds)71 Display::Display(int64 id, const gfx::Rect& bounds)
72 : id_(id),
73 bounds_(bounds),
74 work_area_(bounds),
75 device_scale_factor_(GetForcedDeviceScaleFactor()),
76 rotation_(ROTATE_0),
77 touch_support_(TOUCH_SUPPORT_UNKNOWN) {
78 #if defined(USE_AURA)
79 SetScaleAndBounds(device_scale_factor_, bounds);
80 #endif
81 }
82
~Display()83 Display::~Display() {
84 }
85
GetWorkAreaInsets() const86 Insets Display::GetWorkAreaInsets() const {
87 return gfx::Insets(work_area_.y() - bounds_.y(),
88 work_area_.x() - bounds_.x(),
89 bounds_.bottom() - work_area_.bottom(),
90 bounds_.right() - work_area_.right());
91 }
92
SetScaleAndBounds(float device_scale_factor,const gfx::Rect & bounds_in_pixel)93 void Display::SetScaleAndBounds(
94 float device_scale_factor,
95 const gfx::Rect& bounds_in_pixel) {
96 Insets insets = bounds_.InsetsFrom(work_area_);
97 if (!HasForceDeviceScaleFactor()) {
98 #if defined(OS_MACOSX)
99 // Unless an explicit scale factor was provided for testing, ensure the
100 // scale is integral.
101 device_scale_factor = static_cast<int>(device_scale_factor);
102 #endif
103 device_scale_factor_ = device_scale_factor;
104 }
105 device_scale_factor_ = std::max(1.0f, device_scale_factor_);
106 bounds_ = gfx::Rect(
107 gfx::ToFlooredPoint(gfx::ScalePoint(bounds_in_pixel.origin(),
108 1.0f / device_scale_factor_)),
109 gfx::ToFlooredSize(gfx::ScaleSize(bounds_in_pixel.size(),
110 1.0f / device_scale_factor_)));
111 UpdateWorkAreaFromInsets(insets);
112 }
113
SetSize(const gfx::Size & size_in_pixel)114 void Display::SetSize(const gfx::Size& size_in_pixel) {
115 gfx::Point origin = bounds_.origin();
116 #if defined(USE_AURA)
117 gfx::PointF origin_f = origin;
118 origin_f.Scale(device_scale_factor_);
119 origin.SetPoint(origin_f.x(), origin_f.y());
120 #endif
121 SetScaleAndBounds(device_scale_factor_, gfx::Rect(origin, size_in_pixel));
122 }
123
UpdateWorkAreaFromInsets(const gfx::Insets & insets)124 void Display::UpdateWorkAreaFromInsets(const gfx::Insets& insets) {
125 work_area_ = bounds_;
126 work_area_.Inset(insets);
127 }
128
GetSizeInPixel() const129 gfx::Size Display::GetSizeInPixel() const {
130 return gfx::ToFlooredSize(gfx::ScaleSize(size(), device_scale_factor_));
131 }
132
ToString() const133 std::string Display::ToString() const {
134 return base::StringPrintf(
135 "Display[%lld] bounds=%s, workarea=%s, scale=%f, %s",
136 static_cast<long long int>(id_),
137 bounds_.ToString().c_str(),
138 work_area_.ToString().c_str(),
139 device_scale_factor_,
140 IsInternal() ? "internal" : "external");
141 }
142
IsInternal() const143 bool Display::IsInternal() const {
144 return is_valid() && (id_ == internal_display_id_);
145 }
146
InternalDisplayId()147 int64 Display::InternalDisplayId() {
148 return internal_display_id_;
149 }
150
SetInternalDisplayId(int64 internal_display_id)151 void Display::SetInternalDisplayId(int64 internal_display_id) {
152 internal_display_id_ = internal_display_id;
153 }
154
155 } // namespace gfx
156