ui/gfx/screen_win.cc

   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/screen_win.h"
   6
   7 #include <windows.h>
   8
   9 #include "base/hash.h"
  10 #include "base/logging.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/win/win_util.h"
  13 #include "ui/gfx/display.h"
  14 #include "ui/gfx/win/dpi.h"
  15
  16 namespace {
  17
  18 MONITORINFOEX GetMonitorInfoForMonitor(HMONITOR monitor) {
  19   MONITORINFOEX monitor_info;
  20   ZeroMemory(&monitor_info, sizeof(MONITORINFOEX));
  21   monitor_info.cbSize = sizeof(monitor_info);
  22   GetMonitorInfo(monitor, &monitor_info);
  23   return monitor_info;
  24 }
  25
  26 gfx::Display GetDisplay(MONITORINFOEX& monitor_info) {
  27   int64 id = static_cast<int64>(
  28       base::Hash(base::WideToUTF8(monitor_info.szDevice)));
  29   gfx::Rect bounds = gfx::Rect(monitor_info.rcMonitor);
  30   gfx::Display display(id, bounds);
  31   display.set_work_area(gfx::Rect(monitor_info.rcWork));
  32   display.SetScaleAndBounds(gfx::GetDPIScale(), bounds);
  33
  34   DEVMODE mode;
  35   memset(&mode, 0, sizeof(DEVMODE));
  36   mode.dmSize = sizeof(DEVMODE);
  37   mode.dmDriverExtra = 0;
  38   if (EnumDisplaySettings(monitor_info.szDevice,
  39                           ENUM_CURRENT_SETTINGS,
  40                           &mode)) {
  41     switch (mode.dmDisplayOrientation) {
  42     case DMDO_DEFAULT:
  43       display.set_rotation(gfx::Display::ROTATE_0);
  44       break;
  45     case DMDO_90:
  46       display.set_rotation(gfx::Display::ROTATE_90);
  47       break;
  48     case DMDO_180:
  49       display.set_rotation(gfx::Display::ROTATE_180);
  50       break;
  51     case DMDO_270:
  52       display.set_rotation(gfx::Display::ROTATE_270);
  53       break;
  54     default:
  55       NOTREACHED();
  56     }
  57   }
  58
  59   return display;
  60 }
  61
  62 BOOL CALLBACK EnumMonitorCallback(HMONITOR monitor,
  63                                   HDC hdc,
  64                                   LPRECT rect,
  65                                   LPARAM data) {
  66   std::vector<gfx::Display>* all_displays =
  67       reinterpret_cast<std::vector<gfx::Display>*>(data);
  68   DCHECK(all_displays);
  69
  70   MONITORINFOEX monitor_info = GetMonitorInfoForMonitor(monitor);
  71   gfx::Display display = GetDisplay(monitor_info);
  72   all_displays->push_back(display);
  73   return TRUE;
  74 }
  75
  76 std::vector<gfx::Display> GetDisplays() {
  77   std::vector<gfx::Display> displays;
  78   EnumDisplayMonitors(NULL, NULL, EnumMonitorCallback,
  79                       reinterpret_cast<LPARAM>(&displays));
  80   return displays;
  81 }
  82
  83 }  // namespace
  84
  85 namespace gfx {
  86
  87 ScreenWin::ScreenWin()
  88     : displays_(GetDisplays()) {
  89   SingletonHwnd::GetInstance()->AddObserver(this);
  90 }
  91
  92 ScreenWin::~ScreenWin() {
  93   SingletonHwnd::GetInstance()->RemoveObserver(this);
  94 }
  95
  96 gfx::Point ScreenWin::GetCursorScreenPoint() {
  97   POINT pt;
  98   GetCursorPos(&pt);
  99   gfx::Point cursor_pos_pixels(pt);
 100   return gfx::win::ScreenToDIPPoint(cursor_pos_pixels);
 101 }
 102
 103 gfx::NativeWindow ScreenWin::GetWindowUnderCursor() {
 104   POINT cursor_loc;
 105   HWND hwnd = GetCursorPos(&cursor_loc) ? WindowFromPoint(cursor_loc) : NULL;
 106   return GetNativeWindowFromHWND(hwnd);
 107 }
 108
 109 gfx::NativeWindow ScreenWin::GetWindowAtScreenPoint(const gfx::Point& point) {
 110   gfx::Point point_in_pixels = gfx::win::DIPToScreenPoint(point);
 111   return GetNativeWindowFromHWND(WindowFromPoint(point_in_pixels.ToPOINT()));
 112 }
 113
 114 int ScreenWin::GetNumDisplays() const {
 115   return GetSystemMetrics(SM_CMONITORS);
 116 }
 117
 118 std::vector<gfx::Display> ScreenWin::GetAllDisplays() const {
 119   return displays_;
 120 }
 121
 122 gfx::Display ScreenWin::GetDisplayNearestWindow(gfx::NativeView window) const {
 123   HWND window_hwnd = GetHWNDFromNativeView(window);
 124   if (!window_hwnd) {
 125     // When |window| isn't rooted to a display, we should just return the
 126     // default display so we get some correct display information like the
 127     // scaling factor.
 128     return GetPrimaryDisplay();
 129   }
 130
 131   MONITORINFOEX monitor_info;
 132   monitor_info.cbSize = sizeof(monitor_info);
 133   GetMonitorInfo(MonitorFromWindow(window_hwnd, MONITOR_DEFAULTTONEAREST),
 134                  &monitor_info);
 135   return GetDisplay(monitor_info);
 136 }
 137
 138 gfx::Display ScreenWin::GetDisplayNearestPoint(const gfx::Point& point) const {
 139   gfx::Point point_in_pixels = gfx::win::DIPToScreenPoint(point);
 140   POINT initial_loc = { point_in_pixels.x(), point_in_pixels.y() };
 141   HMONITOR monitor = MonitorFromPoint(initial_loc, MONITOR_DEFAULTTONEAREST);
 142   MONITORINFOEX mi;
 143   ZeroMemory(&mi, sizeof(MONITORINFOEX));
 144   mi.cbSize = sizeof(mi);
 145   if (monitor && GetMonitorInfo(monitor, &mi)) {
 146     return GetDisplay(mi);
 147   }
 148   return gfx::Display();
 149 }
 150
 151 gfx::Display ScreenWin::GetDisplayMatching(const gfx::Rect& match_rect) const {
 152   RECT other_bounds_rect = match_rect.ToRECT();
 153   MONITORINFOEX monitor_info = GetMonitorInfoForMonitor(MonitorFromRect(
 154       &other_bounds_rect, MONITOR_DEFAULTTONEAREST));
 155   return GetDisplay(monitor_info);
 156 }
 157
 158 gfx::Display ScreenWin::GetPrimaryDisplay() const {
 159   MONITORINFOEX mi = GetMonitorInfoForMonitor(
 160       MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY));
 161   gfx::Display display = GetDisplay(mi);
 162   // TODO(kevers|girard): Test if these checks can be reintroduced for high-DIP
 163   // once more of the app is DIP-aware.
 164   if (GetDPIScale() == 1.0) {
 165     DCHECK_EQ(GetSystemMetrics(SM_CXSCREEN), display.size().width());
 166     DCHECK_EQ(GetSystemMetrics(SM_CYSCREEN), display.size().height());
 167   }
 168   return display;
 169 }
 170
 171 void ScreenWin::AddObserver(DisplayObserver* observer) {
 172   change_notifier_.AddObserver(observer);
 173 }
 174
 175 void ScreenWin::RemoveObserver(DisplayObserver* observer) {
 176   change_notifier_.RemoveObserver(observer);
 177 }
 178
 179 void ScreenWin::OnWndProc(HWND hwnd,
 180                           UINT message,
 181                           WPARAM wparam,
 182                           LPARAM lparam) {
 183   if (message != WM_DISPLAYCHANGE)
 184     return;
 185
 186   std::vector<gfx::Display> old_displays = displays_;
 187   displays_ = GetDisplays();
 188
 189   change_notifier_.NotifyDisplaysChanged(old_displays, displays_);
 190 }
 191
 192 HWND ScreenWin::GetHWNDFromNativeView(NativeView window) const {
 193   NOTREACHED();
 194   return NULL;
 195 }
 196
 197 NativeWindow ScreenWin::GetNativeWindowFromHWND(HWND hwnd) const {
 198   NOTREACHED();
 199   return NULL;
 200 }
 201
 202 }  // namespace gfx