OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ui/gfx/screen_win.h" | 5 #include "ui/gfx/screen_win.h" |
6 | 6 |
7 #include <windows.h> | 7 #include <windows.h> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
11 #include "base/hash.h" | 11 #include "base/hash.h" |
12 #include "base/logging.h" | 12 #include "base/logging.h" |
13 #include "base/strings/utf_string_conversions.h" | 13 #include "base/strings/utf_string_conversions.h" |
14 #include "base/win/win_util.h" | 14 #include "base/win/win_util.h" |
15 #include "ui/gfx/display.h" | 15 #include "ui/gfx/display.h" |
| 16 #include "ui/gfx/geometry/point_conversions.h" |
| 17 #include "ui/gfx/geometry/vector2d.h" |
16 #include "ui/gfx/win/dpi.h" | 18 #include "ui/gfx/win/dpi.h" |
17 | 19 |
18 namespace { | 20 namespace { |
19 | 21 |
20 MONITORINFOEX GetMonitorInfoForMonitor(HMONITOR monitor) { | 22 gfx::Display GetDisplay(HMONITOR monitor) { |
21 MONITORINFOEX monitor_info; | 23 MONITORINFOEX monitor_info; |
22 ZeroMemory(&monitor_info, sizeof(MONITORINFOEX)); | 24 ::ZeroMemory(&monitor_info, sizeof(monitor_info)); |
23 monitor_info.cbSize = sizeof(monitor_info); | 25 monitor_info.cbSize = sizeof(monitor_info); |
24 GetMonitorInfo(monitor, &monitor_info); | 26 ::GetMonitorInfo(monitor, &monitor_info); |
25 return monitor_info; | |
26 } | |
27 | 27 |
28 gfx::Display GetDisplay(MONITORINFOEX& monitor_info) { | |
29 int64 id = static_cast<int64>( | 28 int64 id = static_cast<int64>( |
30 base::Hash(base::WideToUTF8(monitor_info.szDevice))); | 29 base::Hash(base::WideToUTF8(monitor_info.szDevice))); |
31 gfx::Rect bounds = gfx::Rect(monitor_info.rcMonitor); | 30 gfx::Rect bounds = gfx::Rect(monitor_info.rcMonitor); |
32 gfx::Display display(id, bounds); | 31 gfx::Display display(id, bounds); |
33 display.set_work_area(gfx::Rect(monitor_info.rcWork)); | 32 display.set_work_area(gfx::Rect(monitor_info.rcWork)); |
34 display.SetScaleAndBounds(gfx::GetDPIScale(), bounds); | 33 display.SetScaleAndBounds(gfx::GetDPIScale(), bounds); |
| 34 DCHECK(display.device_scale_factor() >= 1.0); |
35 | 35 |
36 DEVMODE mode; | 36 DEVMODE mode; |
37 memset(&mode, 0, sizeof(DEVMODE)); | 37 ::ZeroMemory(&mode, sizeof(mode)); |
38 mode.dmSize = sizeof(DEVMODE); | 38 mode.dmSize = sizeof(DEVMODE); |
39 mode.dmDriverExtra = 0; | 39 mode.dmDriverExtra = 0; |
40 if (EnumDisplaySettings(monitor_info.szDevice, | 40 if (::EnumDisplaySettings(monitor_info.szDevice, |
41 ENUM_CURRENT_SETTINGS, | 41 ENUM_CURRENT_SETTINGS, |
42 &mode)) { | 42 &mode)) { |
43 switch (mode.dmDisplayOrientation) { | 43 switch (mode.dmDisplayOrientation) { |
44 case DMDO_DEFAULT: | 44 case DMDO_DEFAULT: |
45 display.set_rotation(gfx::Display::ROTATE_0); | 45 display.set_rotation(gfx::Display::ROTATE_0); |
46 break; | 46 break; |
47 case DMDO_90: | 47 case DMDO_90: |
48 display.set_rotation(gfx::Display::ROTATE_90); | 48 display.set_rotation(gfx::Display::ROTATE_90); |
49 break; | 49 break; |
50 case DMDO_180: | 50 case DMDO_180: |
51 display.set_rotation(gfx::Display::ROTATE_180); | 51 display.set_rotation(gfx::Display::ROTATE_180); |
52 break; | 52 break; |
53 case DMDO_270: | 53 case DMDO_270: |
54 display.set_rotation(gfx::Display::ROTATE_270); | 54 display.set_rotation(gfx::Display::ROTATE_270); |
55 break; | 55 break; |
56 default: | 56 default: |
57 NOTREACHED(); | 57 NOTREACHED(); |
58 } | 58 } |
59 } | 59 } |
60 | 60 |
61 return display; | 61 return display; |
62 } | 62 } |
63 | 63 |
64 BOOL CALLBACK EnumMonitorCallback(HMONITOR monitor, | 64 BOOL CALLBACK EnumMonitorCallback(HMONITOR monitor, |
65 HDC hdc, | 65 HDC hdc, |
66 LPRECT rect, | 66 LPRECT rect, |
67 LPARAM data) { | 67 LPARAM data) { |
68 std::vector<gfx::Display>* all_displays = | 68 std::vector<gfx::Display>* all_displays = |
69 reinterpret_cast<std::vector<gfx::Display>*>(data); | 69 reinterpret_cast<std::vector<gfx::Display>*>(data); |
70 DCHECK(all_displays); | 70 DCHECK(all_displays); |
71 | 71 |
72 MONITORINFOEX monitor_info = GetMonitorInfoForMonitor(monitor); | 72 gfx::Display display = GetDisplay(monitor); |
73 gfx::Display display = GetDisplay(monitor_info); | |
74 all_displays->push_back(display); | 73 all_displays->push_back(display); |
75 return TRUE; | 74 return TRUE; |
76 } | 75 } |
77 | 76 |
78 std::vector<gfx::Display> GetDisplays() { | 77 std::vector<gfx::Display> GetDisplays() { |
79 std::vector<gfx::Display> displays; | 78 std::vector<gfx::Display> displays; |
80 EnumDisplayMonitors(NULL, NULL, EnumMonitorCallback, | 79 EnumDisplayMonitors(NULL, NULL, EnumMonitorCallback, |
81 reinterpret_cast<LPARAM>(&displays)); | 80 reinterpret_cast<LPARAM>(&displays)); |
82 return displays; | 81 return displays; |
83 } | 82 } |
84 | 83 |
85 } // namespace | 84 } // namespace |
86 | 85 |
87 namespace gfx { | 86 namespace gfx { |
88 | 87 |
89 ScreenWin::ScreenWin() | 88 ScreenWin::ScreenWin() |
90 : singleton_hwnd_observer_(new SingletonHwndObserver( | 89 : singleton_hwnd_observer_(new SingletonHwndObserver( |
91 base::Bind(&ScreenWin::OnWndProc, base::Unretained(this)))), | 90 base::Bind(&ScreenWin::OnWndProc, base::Unretained(this)))), |
92 displays_(GetDisplays()) { | 91 displays_(GetDisplays()) { |
93 } | 92 } |
94 | 93 |
95 ScreenWin::~ScreenWin() {} | 94 ScreenWin::~ScreenWin() {} |
96 | 95 |
| 96 // static |
| 97 Point ScreenWin::ScreenToDIPPoint(const Point& pixel_point) { |
| 98 gfx::Display display = GetDisplayNearestScreenPoint(pixel_point); |
| 99 float device_scale_factor = display.device_scale_factor(); |
| 100 const Rect& monitor_bounds = display.bounds(); |
| 101 Vector2d origin(monitor_bounds.x(), monitor_bounds.y()); |
| 102 |
| 103 // Monitors are anchored to their physical coordinate regardless of DPI. |
| 104 return ScaleToFlooredPoint(pixel_point - origin, 1.0f / device_scale_factor) + |
| 105 origin; |
| 106 } |
| 107 |
| 108 // static |
| 109 Point ScreenWin::DIPToScreenPoint(const Point& dip_point) { |
| 110 // Because origins don't change for screen points and scaling factors are |
| 111 // greater than 1, the monitor bounding rect always contains the DIP point. |
| 112 gfx::Display display = GetDisplayNearestScreenPoint(dip_point); |
| 113 float device_scale_factor = display.device_scale_factor(); |
| 114 const Rect& monitor_bounds = display.bounds(); |
| 115 Vector2d origin(monitor_bounds.x(), monitor_bounds.y()); |
| 116 |
| 117 return ScaleToFlooredPoint(dip_point - origin, device_scale_factor) + origin; |
| 118 } |
| 119 |
| 120 // static |
| 121 Point ScreenWin::ClientToDIPPoint(HWND hwnd, const Point& client_point) { |
| 122 return ScaleToFlooredPoint(client_point, 1.0f / GetScaleFactorForHWND(hwnd)); |
| 123 } |
| 124 |
| 125 Point ScreenWin::DIPToClientPoint(HWND hwnd, const Point& dip_point) { |
| 126 return ScaleToFlooredPoint(dip_point, GetScaleFactorForHWND(hwnd)); |
| 127 } |
| 128 |
| 129 // static |
| 130 Rect ScreenWin::ScreenToDIPRect(HWND hwnd, const Rect& pixel_bounds) { |
| 131 // It's important we scale the origin and size separately. If we instead |
| 132 // calculated the size from the floored origin and ceiled right the size could |
| 133 // vary depending upon where the two points land. That would cause problems |
| 134 // for the places this code is used (in particular mapping from native window |
| 135 // bounds to DIPs). |
| 136 if (hwnd) { |
| 137 return Rect(ScreenToDIPPoint(pixel_bounds.origin()), |
| 138 ScreenToDIPSize(hwnd, pixel_bounds.size())); |
| 139 } |
| 140 float scale_factor = |
| 141 GetDisplayNearestRect(pixel_bounds).device_scale_factor(); |
| 142 return Rect(ScreenToDIPPoint(pixel_bounds.origin()), |
| 143 ScaleToCeiledSize(pixel_bounds.size(), 1.0f / scale_factor)); |
| 144 } |
| 145 |
| 146 // static |
| 147 Rect ScreenWin::DIPToScreenRect(HWND hwnd, const Rect& dip_bounds) { |
| 148 // See comment in ScreenToDIPRect for why we calculate size like this. |
| 149 if (hwnd) { |
| 150 return Rect(DIPToScreenPoint(dip_bounds.origin()), |
| 151 DIPToScreenSize(hwnd, dip_bounds.size())); |
| 152 } |
| 153 // Because origins don't change for screen points and scaling factors are |
| 154 // greater than 1, the monitor bounding rect always contains the DIP point. |
| 155 float scale_factor = |
| 156 GetDisplayNearestRect(dip_bounds).device_scale_factor(); |
| 157 return Rect(DIPToScreenPoint(dip_bounds.origin()), |
| 158 ScaleToCeiledSize(dip_bounds.size(), scale_factor)); |
| 159 } |
| 160 |
| 161 // static |
| 162 Rect ScreenWin::ClientToDIPRect(HWND hwnd, const Rect& pixel_bounds) { |
| 163 // See comment in ScreenToDIPRect for why we calculate size like this. |
| 164 return Rect(ClientToDIPPoint(hwnd, pixel_bounds.origin()), |
| 165 ScreenToDIPSize(hwnd, pixel_bounds.size())); |
| 166 } |
| 167 |
| 168 // static |
| 169 Rect ScreenWin::DIPToClientRect(HWND hwnd, const Rect& dip_bounds) { |
| 170 // See comment in ScreenToDIPRect for why we calculate size like this. |
| 171 return Rect(DIPToClientPoint(hwnd, dip_bounds.origin()), |
| 172 DIPToScreenSize(hwnd, dip_bounds.size())); |
| 173 } |
| 174 |
| 175 // static |
| 176 Size ScreenWin::ScreenToDIPSize(HWND hwnd, const Size& size_in_pixels) { |
| 177 // Always ceil sizes. Otherwise we may be leaving off part of the bounds. |
| 178 return ScaleToCeiledSize(size_in_pixels, 1.0f / GetScaleFactorForHWND(hwnd)); |
| 179 } |
| 180 |
| 181 // static |
| 182 Size ScreenWin::DIPToScreenSize(HWND hwnd, const Size& dip_size) { |
| 183 // Always ceil sizes. Otherwise we may be leaving off part of the bounds. |
| 184 return ScaleToCeiledSize(dip_size, GetScaleFactorForHWND(hwnd)); |
| 185 } |
| 186 |
97 gfx::Point ScreenWin::GetCursorScreenPoint() { | 187 gfx::Point ScreenWin::GetCursorScreenPoint() { |
98 POINT pt; | 188 POINT pt; |
99 GetCursorPos(&pt); | 189 GetCursorPos(&pt); |
100 gfx::Point cursor_pos_pixels(pt); | 190 gfx::Point cursor_pos_pixels(pt); |
101 return gfx::win::ScreenToDIPPoint(cursor_pos_pixels); | 191 return ScreenToDIPPoint(cursor_pos_pixels); |
102 } | 192 } |
103 | 193 |
104 gfx::NativeWindow ScreenWin::GetWindowUnderCursor() { | 194 gfx::NativeWindow ScreenWin::GetWindowUnderCursor() { |
105 POINT cursor_loc; | 195 POINT cursor_loc; |
106 HWND hwnd = GetCursorPos(&cursor_loc) ? WindowFromPoint(cursor_loc) : NULL; | 196 HWND hwnd = GetCursorPos(&cursor_loc) ? WindowFromPoint(cursor_loc) : NULL; |
107 return GetNativeWindowFromHWND(hwnd); | 197 return GetNativeWindowFromHWND(hwnd); |
108 } | 198 } |
109 | 199 |
110 gfx::NativeWindow ScreenWin::GetWindowAtScreenPoint(const gfx::Point& point) { | 200 gfx::NativeWindow ScreenWin::GetWindowAtScreenPoint(const gfx::Point& point) { |
111 gfx::Point point_in_pixels = gfx::win::DIPToScreenPoint(point); | 201 gfx::Point point_in_pixels = DIPToScreenPoint(point); |
112 return GetNativeWindowFromHWND(WindowFromPoint(point_in_pixels.ToPOINT())); | 202 return GetNativeWindowFromHWND(WindowFromPoint(point_in_pixels.ToPOINT())); |
113 } | 203 } |
114 | 204 |
115 int ScreenWin::GetNumDisplays() const { | 205 int ScreenWin::GetNumDisplays() const { |
116 return GetSystemMetrics(SM_CMONITORS); | 206 return GetSystemMetrics(SM_CMONITORS); |
117 } | 207 } |
118 | 208 |
119 std::vector<gfx::Display> ScreenWin::GetAllDisplays() const { | 209 std::vector<gfx::Display> ScreenWin::GetAllDisplays() const { |
120 return displays_; | 210 return displays_; |
121 } | 211 } |
122 | 212 |
123 gfx::Display ScreenWin::GetDisplayNearestWindow(gfx::NativeView window) const { | 213 gfx::Display ScreenWin::GetDisplayNearestWindow(gfx::NativeView window) const { |
124 HWND window_hwnd = GetHWNDFromNativeView(window); | 214 HWND window_hwnd = GetHWNDFromNativeView(window); |
125 if (!window_hwnd) { | 215 if (!window_hwnd) { |
126 // When |window| isn't rooted to a display, we should just return the | 216 // When |window| isn't rooted to a display, we should just return the |
127 // default display so we get some correct display information like the | 217 // default display so we get some correct display information like the |
128 // scaling factor. | 218 // scaling factor. |
129 return GetPrimaryDisplay(); | 219 return GetPrimaryDisplay(); |
130 } | 220 } |
131 | 221 |
132 MONITORINFOEX monitor_info; | 222 return GetDisplayNearestHWND(window_hwnd); |
133 monitor_info.cbSize = sizeof(monitor_info); | |
134 GetMonitorInfo(MonitorFromWindow(window_hwnd, MONITOR_DEFAULTTONEAREST), | |
135 &monitor_info); | |
136 return GetDisplay(monitor_info); | |
137 } | 223 } |
138 | 224 |
139 gfx::Display ScreenWin::GetDisplayNearestPoint(const gfx::Point& point) const { | 225 gfx::Display ScreenWin::GetDisplayNearestPoint(const gfx::Point& point) const { |
140 gfx::Point point_in_pixels = gfx::win::DIPToScreenPoint(point); | 226 return GetDisplayNearestScreenPoint(DIPToScreenPoint(point)); |
141 POINT initial_loc = { point_in_pixels.x(), point_in_pixels.y() }; | |
142 HMONITOR monitor = MonitorFromPoint(initial_loc, MONITOR_DEFAULTTONEAREST); | |
143 MONITORINFOEX mi; | |
144 ZeroMemory(&mi, sizeof(MONITORINFOEX)); | |
145 mi.cbSize = sizeof(mi); | |
146 if (monitor && GetMonitorInfo(monitor, &mi)) { | |
147 return GetDisplay(mi); | |
148 } | |
149 return gfx::Display(); | |
150 } | 227 } |
151 | 228 |
152 gfx::Display ScreenWin::GetDisplayMatching(const gfx::Rect& match_rect) const { | 229 gfx::Display ScreenWin::GetDisplayMatching(const gfx::Rect& match_rect) const { |
153 RECT other_bounds_rect = match_rect.ToRECT(); | 230 return GetDisplayNearestRect(match_rect); |
154 MONITORINFOEX monitor_info = GetMonitorInfoForMonitor(MonitorFromRect( | |
155 &other_bounds_rect, MONITOR_DEFAULTTONEAREST)); | |
156 return GetDisplay(monitor_info); | |
157 } | 231 } |
158 | 232 |
159 gfx::Display ScreenWin::GetPrimaryDisplay() const { | 233 gfx::Display ScreenWin::GetPrimaryDisplay() const { |
160 MONITORINFOEX mi = GetMonitorInfoForMonitor( | 234 gfx::Display display = |
161 MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY)); | 235 GetDisplay(MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY)); |
162 gfx::Display display = GetDisplay(mi); | |
163 // TODO(kevers|girard): Test if these checks can be reintroduced for high-DIP | 236 // TODO(kevers|girard): Test if these checks can be reintroduced for high-DIP |
164 // once more of the app is DIP-aware. | 237 // once more of the app is DIP-aware. |
165 if (GetDPIScale() == 1.0) { | 238 if (display.device_scale_factor() == 1.0) { |
166 DCHECK_EQ(GetSystemMetrics(SM_CXSCREEN), display.size().width()); | 239 DCHECK_EQ(GetSystemMetrics(SM_CXSCREEN), display.size().width()); |
167 DCHECK_EQ(GetSystemMetrics(SM_CYSCREEN), display.size().height()); | 240 DCHECK_EQ(GetSystemMetrics(SM_CYSCREEN), display.size().height()); |
168 } | 241 } |
169 return display; | 242 return display; |
170 } | 243 } |
171 | 244 |
172 void ScreenWin::AddObserver(DisplayObserver* observer) { | 245 void ScreenWin::AddObserver(DisplayObserver* observer) { |
173 change_notifier_.AddObserver(observer); | 246 change_notifier_.AddObserver(observer); |
174 } | 247 } |
175 | 248 |
176 void ScreenWin::RemoveObserver(DisplayObserver* observer) { | 249 void ScreenWin::RemoveObserver(DisplayObserver* observer) { |
177 change_notifier_.RemoveObserver(observer); | 250 change_notifier_.RemoveObserver(observer); |
178 } | 251 } |
179 | 252 |
| 253 // static |
| 254 gfx::Display ScreenWin::GetDisplayNearestHWND(HWND hwnd) { |
| 255 return GetDisplay(::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST)); |
| 256 } |
| 257 |
| 258 // static |
| 259 gfx::Display ScreenWin::GetDisplayNearestRect(const Rect& rect) { |
| 260 RECT winRect = rect.ToRECT(); |
| 261 return GetDisplay(::MonitorFromRect(&winRect, MONITOR_DEFAULTTONEAREST)); |
| 262 } |
| 263 |
| 264 // static |
| 265 gfx::Display ScreenWin::GetDisplayNearestScreenPoint( |
| 266 const Point& screen_point) { |
| 267 POINT initial_loc = { screen_point.x(), screen_point.y() }; |
| 268 return GetDisplay(::MonitorFromPoint(initial_loc, MONITOR_DEFAULTTONEAREST)); |
| 269 } |
| 270 |
| 271 // static |
| 272 float ScreenWin::GetScaleFactorForHWND(HWND hwnd) { |
| 273 DCHECK(hwnd); |
| 274 HWND hwndTopLevel = GetAncestor(hwnd, GA_ROOT); |
| 275 return GetDisplayNearestHWND(hwndTopLevel).device_scale_factor(); |
| 276 } |
| 277 |
| 278 // static |
| 279 float ScreenWin::GetScaleFactorForScreenPoint(const Point& screen_point) { |
| 280 return GetDisplayNearestScreenPoint(screen_point).device_scale_factor(); |
| 281 } |
| 282 |
180 void ScreenWin::OnWndProc(HWND hwnd, | 283 void ScreenWin::OnWndProc(HWND hwnd, |
181 UINT message, | 284 UINT message, |
182 WPARAM wparam, | 285 WPARAM wparam, |
183 LPARAM lparam) { | 286 LPARAM lparam) { |
184 if (message != WM_DISPLAYCHANGE) | 287 if (message != WM_DISPLAYCHANGE) |
185 return; | 288 return; |
186 | 289 |
187 std::vector<gfx::Display> old_displays = displays_; | 290 std::vector<gfx::Display> old_displays = displays_; |
188 displays_ = GetDisplays(); | 291 displays_ = GetDisplays(); |
189 | 292 |
190 change_notifier_.NotifyDisplaysChanged(old_displays, displays_); | 293 change_notifier_.NotifyDisplaysChanged(old_displays, displays_); |
191 } | 294 } |
192 | 295 |
193 HWND ScreenWin::GetHWNDFromNativeView(NativeView window) const { | 296 HWND ScreenWin::GetHWNDFromNativeView(NativeView window) const { |
194 NOTREACHED(); | 297 NOTREACHED(); |
195 return NULL; | 298 return NULL; |
196 } | 299 } |
197 | 300 |
198 NativeWindow ScreenWin::GetNativeWindowFromHWND(HWND hwnd) const { | 301 NativeWindow ScreenWin::GetNativeWindowFromHWND(HWND hwnd) const { |
199 NOTREACHED(); | 302 NOTREACHED(); |
200 return NULL; | 303 return NULL; |
201 } | 304 } |
202 | 305 |
203 } // namespace gfx | 306 } // namespace gfx |
OLD | NEW |