Multiple DPI Tracking for ScreenWin

ui/gfx/screen_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/screen_win.h"
 
 #include <windows.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/win/display_info.h"
 #include "ui/gfx/win/dpi.h"
+#include "ui/gfx/win/rect_util.h"
 #include "ui/gfx/win/screen_win_display.h"
 
 namespace {
 
+gfx::ScreenWin* g_screen_win_instance = nullptr;
+
+std::vector<gfx::win::DisplayInfo>::const_iterator FindTouchingDisplayInfo(
+    const gfx::win::ScreenWinDisplay& screen_win_display,
+    const std::vector<gfx::win::DisplayInfo>& display_infos) {
+  auto end = display_infos.end();
+  for (auto display_info_iter = display_infos.begin();
+       display_info_iter != end;
+       display_info_iter++) {
+    gfx::win::RectEdge edge =
+        gfx::win::FindTouchingRectEdge(screen_win_display.pixel_bounds(),
+                                       display_info_iter->screen_rect());
+    if (edge != gfx::win::RectEdge::NONE)
+      return display_info_iter;
+  }
+  return end;
+}
+
+// Windows historically has had a hard time handling displays of DPIs higher
+// than 96. Handling multiple DPI displays means we have to deal with Windows'
+// monitor physical coordinates and map into Chrome's DIP coordinates.
+//
+// To do this, DisplayInfosToScreenWinDisplays reasons over monitors as a tree
+// using the primary monitor as the root. Any monitor touching this root is
+// considered a child. Subsequent generations are formed similarly, having
+// preferring parents that are discovered earlier. As a result, if there is a
+// monitor that touches two other monitors, the earliest discovered monitor is
+// the parent.
+//
+// This also presumes that all monitors are connected components. Windows, by UI
+// construction restricts the layout of monitors to connected components except
+// when DPI virtualization is happening. When this happens, we scale relative
+// to (0, 0) like before.
+//
+// All subsequent scaling transformations are performed with respect to the
+// calculated physical-DIP mapping on ScreenWinDisplay.
+//
+// Note that this does not handle cases where a scaled display may have
+// insufficient room to lay out its children. In these cases, a DIP point could
+// map to multiple screen points due to overlap. The first discovered screen
+// will take precedence.
 std::vector<gfx::win::ScreenWinDisplay> DisplayInfosToScreenWinDisplays(
     const std::vector<gfx::win::DisplayInfo>& display_infos) {
+  std::vector<gfx::win::DisplayInfo> display_infos_remaining = display_infos;
+
+  // Seed the primary display to layout all the other displays.
   std::vector<gfx::win::ScreenWinDisplay> screen_win_displays;
-  for (const auto& display_info : display_infos)
+  for (auto current = display_infos_remaining.begin();
+       current != display_infos_remaining.end();
+       current++) {
+    if (current->screen_rect().origin().IsOrigin()) {
+      screen_win_displays.push_back(gfx::win::ScreenWinDisplay(*current));
+      display_infos_remaining.erase(current);
+      break;
+    }
+  }
+
+  // Scale touching display_infos relative to each other.
+  // If the DisplayInfo count doesn't change through one cycle of the loop, it
+  // either means we're done or we have non-touching DisplayInfos in the vector.
+  size_t display_infos_at_cycle_start = 0;
+  while ((display_infos_remaining.size() > 0) &&
+         (display_infos_remaining.size() != display_infos_at_cycle_start)) {
+    display_infos_at_cycle_start = display_infos_remaining.size();
+    for (const auto& screen_win_display : screen_win_displays) {
+      auto display_info = FindTouchingDisplayInfo(screen_win_display,
+                                                  display_infos_remaining);
+      if (display_info != display_infos_remaining.end()) {
+        screen_win_displays.push_back(
+            gfx::win::ScreenWinDisplay(screen_win_display, *display_info));
+        display_infos_remaining.erase(display_info);
+        break;
+      }
+    }
+  }
+
+  // Under Windows DPI virtualization, not all display_infos touch, so scale
+  // the remaining display infos relative to the origin.
+  for (const auto& display_info : display_infos_remaining)
     screen_win_displays.push_back(gfx::win::ScreenWinDisplay(display_info));
 
   return screen_win_displays;
 }
 
 std::vector<gfx::Display> ScreenWinDisplaysToDisplays(
     const std::vector<gfx::win::ScreenWinDisplay>& screen_win_displays) {
   std::vector<gfx::Display> displays;
   for (const auto& screen_win_display : screen_win_displays)
     displays.push_back(screen_win_display.display());
@@ skipping 24 matching lines @@
 
 std::vector<gfx::win::DisplayInfo> GetDisplayInfosFromSystem() {
   std::vector<gfx::win::DisplayInfo> display_infos;
   EnumDisplayMonitors(nullptr, nullptr, EnumMonitorCallback,
                       reinterpret_cast<LPARAM>(&display_infos));
   DCHECK_EQ(static_cast<size_t>(::GetSystemMetrics(SM_CMONITORS)),
             display_infos.size());
   return display_infos;
 }
 
+// Returns a point in |to_origin|'s coordinates and position scaled by
+// |scale_factor|.
+gfx::Point ScalePointRelative(const gfx::Point& from_origin,
+                              const gfx::Point& to_origin,
+                              const float scale_factor,
+                              const gfx::Point& point) {
+  gfx::Vector2d from_origin_vector(from_origin.x(), from_origin.y());
+  gfx::Vector2d to_origin_vector(to_origin.x(), to_origin.y());
+  gfx::Point scaled_relative_point(
+      gfx::ScaleToFlooredPoint(point - from_origin_vector, scale_factor));
+  return scaled_relative_point + to_origin_vector;
+}
+
 }  // namespace
 
 namespace gfx {
 
 ScreenWin::ScreenWin() {
+  DCHECK(g_screen_win_instance == nullptr);

[oshima, 2016/02/11 22:59:58]

DCHECK(!g_screen_win_instance) is more common

[robliao, 2016/02/12 01:52:53]

Done.

+  g_screen_win_instance = this;
   Initialize();
 }
 
-ScreenWin::~ScreenWin() = default;
+ScreenWin::~ScreenWin() {
+  DCHECK(g_screen_win_instance == this);
+  g_screen_win_instance = nullptr;
+}
+
+// static
+Point ScreenWin::ScreenToDIPPoint(const Point& pixel_point) {
+  const gfx::win::ScreenWinDisplay screen_win_display =
+      ScreenWin::GetScreenWinDisplayVia(
+          &ScreenWin::GetScreenWinDisplayNearestScreenPoint, pixel_point);
+  const Display display = screen_win_display.display();
+  return ScalePointRelative(screen_win_display.pixel_bounds().origin(),
+                            display.bounds().origin(),
+                            1.0f / display.device_scale_factor(),
+                            pixel_point);
+}
+
+// static
+Point ScreenWin::DIPToScreenPoint(const Point& dip_point) {
+  const gfx::win::ScreenWinDisplay screen_win_display =
+      ScreenWin::GetScreenWinDisplayVia(
+          &ScreenWin::GetScreenWinDisplayNearestDIPPoint, dip_point);
+  const Display display = screen_win_display.display();
+  return ScalePointRelative(display.bounds().origin(),
+                            screen_win_display.pixel_bounds().origin(),
+                            display.device_scale_factor(),
+                            dip_point);
+}
+
+// static
+Point ScreenWin::ClientToDIPPoint(HWND hwnd, const Point& client_point) {
+  const float scale_factor = ScreenWin::GetScaleFactorForHWND(hwnd);
+  return ScaleToFlooredPoint(client_point, 1.0f / scale_factor);
+}
+
+// static
+Point ScreenWin::DIPToClientPoint(HWND hwnd, const Point& dip_point) {
+  float scale_factor = ScreenWin::GetScaleFactorForHWND(hwnd);
+  return ScaleToFlooredPoint(dip_point, scale_factor);
+}
+
+// static
+Rect ScreenWin::ScreenToDIPRect(HWND hwnd, const Rect& pixel_bounds) {
+  float scale_factor = hwnd ?
+      ScreenWin::GetScaleFactorForHWND(hwnd) :
+      ScreenWin::GetScreenWinDisplayVia(
+          &ScreenWin::GetScreenWinDisplayNearestScreenRect, pixel_bounds).
+              display().device_scale_factor();
+  gfx::Rect dip_rect = ScaleToEnclosingRect(pixel_bounds, 1.0f / scale_factor);
+  dip_rect.set_origin(ScreenWin::ScreenToDIPPoint(pixel_bounds.origin()));
+  return dip_rect;
+}
+
+// static
+Rect ScreenWin::DIPToScreenRect(HWND hwnd, const Rect& dip_bounds) {
+  float scale_factor = hwnd ?
+      ScreenWin::GetScaleFactorForHWND(hwnd) :
+      ScreenWin::GetScreenWinDisplayVia(
+          &ScreenWin::GetScreenWinDisplayNearestDIPRect, dip_bounds).
+              display().device_scale_factor();
+  gfx::Rect screen_rect = ScaleToEnclosingRect(dip_bounds, scale_factor);
+  screen_rect.set_origin(ScreenWin::DIPToScreenPoint(dip_bounds.origin()));
+  return screen_rect;
+}
+
+// static
+Rect ScreenWin::ClientToDIPRect(HWND hwnd, const Rect& pixel_bounds) {
+  float scale_factor = ScreenWin::GetScaleFactorForHWND(hwnd);
+  return ScaleToEnclosingRect(pixel_bounds, 1.0f / scale_factor);
+}
+
+// static
+Rect ScreenWin::DIPToClientRect(HWND hwnd, const Rect& dip_bounds) {
+  float scale_factor = ScreenWin::GetScaleFactorForHWND(hwnd);
+  return ScaleToEnclosingRect(dip_bounds, scale_factor);
+}
+
+// static
+Size ScreenWin::ScreenToDIPSize(HWND hwnd, const Size& size_in_pixels) {
+  float scale_factor = ScreenWin::GetScaleFactorForHWND(hwnd);
+  // Always ceil sizes. Otherwise we may be leaving off part of the bounds.
+  return ScaleToCeiledSize(size_in_pixels, 1.0f / scale_factor);
+}
+
+// static
+Size ScreenWin::DIPToScreenSize(HWND hwnd, const Size& dip_size) {
+  float scale_factor = ScreenWin::GetScaleFactorForHWND(hwnd);
+  // Always ceil sizes. Otherwise we may be leaving off part of the bounds.
+  return ScaleToCeiledSize(dip_size, scale_factor);
+}
 
 HWND ScreenWin::GetHWNDFromNativeView(NativeView window) const {
   NOTREACHED();
   return nullptr;
 }
 
 NativeWindow ScreenWin::GetNativeWindowFromHWND(HWND hwnd) const {
   NOTREACHED();
   return nullptr;
 }
 
 gfx::Point ScreenWin::GetCursorScreenPoint() {
   POINT pt;
   ::GetCursorPos(&pt);
   gfx::Point cursor_pos_pixels(pt);
-  return gfx::win::ScreenToDIPPoint(cursor_pos_pixels);
+  return ScreenWin::ScreenToDIPPoint(cursor_pos_pixels);
 }
 
 gfx::NativeWindow ScreenWin::GetWindowUnderCursor() {
   POINT cursor_loc;
   HWND hwnd =
       ::GetCursorPos(&cursor_loc) ? ::WindowFromPoint(cursor_loc) : nullptr;
   return GetNativeWindowFromHWND(hwnd);
 }
 
 gfx::NativeWindow ScreenWin::GetWindowAtScreenPoint(const gfx::Point& point) {
-  gfx::Point point_in_pixels = gfx::win::DIPToScreenPoint(point);
+  gfx::Point point_in_pixels = ScreenWin::DIPToScreenPoint(point);
   return GetNativeWindowFromHWND(WindowFromPoint(point_in_pixels.ToPOINT()));
 }
 
 int ScreenWin::GetNumDisplays() const {
   return static_cast<int>(screen_win_displays_.size());
 }
 
 std::vector<gfx::Display> ScreenWin::GetAllDisplays() const {
   return ScreenWinDisplaysToDisplays(screen_win_displays_);
 }
 
 gfx::Display ScreenWin::GetDisplayNearestWindow(gfx::NativeView window) const {
   HWND window_hwnd = GetHWNDFromNativeView(window);
   if (!window_hwnd) {
     // When |window| isn't rooted to a display, we should just return the
     // default display so we get some correct display information like the
     // scaling factor.
     return GetPrimaryDisplay();
   }
   gfx::win::ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayNearestHWND(window_hwnd);
   return screen_win_display.display();
 }
 
 gfx::Display ScreenWin::GetDisplayNearestPoint(const gfx::Point& point) const {
-  gfx::Point screen_point(gfx::win::DIPToScreenPoint(point));
+  gfx::Point screen_point(ScreenWin::DIPToScreenPoint(point));
   gfx::win::ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayNearestScreenPoint(screen_point);
   return screen_win_display.display();
 }
 
 gfx::Display ScreenWin::GetDisplayMatching(const gfx::Rect& match_rect) const {
   gfx::win::ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayNearestScreenRect(match_rect);
   return screen_win_display.display();
 }
 
 gfx::Display ScreenWin::GetPrimaryDisplay() const {
   return GetPrimaryScreenWinDisplay().display();
 }
 
 void ScreenWin::AddObserver(DisplayObserver* observer) {
   change_notifier_.AddObserver(observer);
 }
 
 void ScreenWin::RemoveObserver(DisplayObserver* observer) {
   change_notifier_.RemoveObserver(observer);
 }
 
+gfx::Rect ScreenWin::ScreenToDIPRectInWindow(
+    NativeView view, const gfx::Rect& screen_rect) const {
+  HWND hwnd = view ? GetHWNDFromNativeView(view) : NULL;

[oshima, 2016/02/11 22:59:58]

nit: nullptr throughout the CL

[robliao, 2016/02/12 01:52:53]

Done.

+  return ScreenWin::ScreenToDIPRect(hwnd, screen_rect);
+}
+
+gfx::Rect ScreenWin::DIPToScreenRectInWindow(NativeView view,
+                                             const gfx::Rect& dip_rect) const {
+  HWND hwnd = view ? GetHWNDFromNativeView(view) : NULL;
+  return ScreenWin::DIPToScreenRect(hwnd, dip_rect);
+}
+
 void ScreenWin::UpdateFromDisplayInfos(
     const std::vector<gfx::win::DisplayInfo>& display_infos) {
   screen_win_displays_ = DisplayInfosToScreenWinDisplays(display_infos);
 }
 
 void ScreenWin::Initialize() {
   singleton_hwnd_observer_.reset(
       new gfx::SingletonHwndObserver(
           base::Bind(&ScreenWin::OnWndProc, base::Unretained(this))));
   UpdateFromDisplayInfos(GetDisplayInfosFromSystem());
@@ skipping 43 matching lines @@
 gfx::win::ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestScreenRect(
     const Rect& screen_rect) const {
   return GetScreenWinDisplay(MonitorInfoFromScreenRect(screen_rect));
 }
 
 gfx::win::ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestScreenPoint(
     const Point& screen_point) const {
   return GetScreenWinDisplay(MonitorInfoFromScreenPoint(screen_point));
 }
 
+gfx::win::ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestDIPPoint(
+    const Point& dip_point) const {
+  gfx::win::ScreenWinDisplay primary_screen_win_display;
+  for (const auto& screen_win_display : screen_win_displays_) {
+    Display display = screen_win_display.display();
+    const gfx::Rect dip_bounds = display.bounds();
+    if (dip_bounds.Contains(dip_point))
+      return screen_win_display;
+    else if (dip_bounds.origin().IsOrigin())
+      primary_screen_win_display = screen_win_display;
+  }
+  return primary_screen_win_display;
+}
+
+gfx::win::ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestDIPRect(
+    const Rect& dip_rect) const {
+  gfx::win::ScreenWinDisplay closest_screen_win_display;
+  int64_t closest_distance_squared = INT64_MAX;
+  for (const auto& screen_win_display : screen_win_displays_) {
+    Display display = screen_win_display.display();
+    gfx::Rect dip_bounds = display.bounds();
+    int64_t distance_squared =
+        gfx::win::SquaredDistanceBetweenRects(dip_rect, dip_bounds);

[oshima, 2016/02/11 22:59:58]

can this be manhattan distance?

you can also move the impl to here if this is only place used.

[robliao, 2016/02/12 01:52:53]

Using Manhattan distance seems like it would return the wrong result as it would
overshoot the actual direct distance between rectangles, favoring rectangles
lying on the same axis over diagonal ones.

+    if (distance_squared == 0) {
+      return screen_win_display;
+    } else if (distance_squared < closest_distance_squared) {
+      closest_distance_squared = distance_squared;
+      closest_screen_win_display = screen_win_display;
+    }
+  }
+  return closest_screen_win_display;
+}
+
 gfx::win::ScreenWinDisplay ScreenWin::GetPrimaryScreenWinDisplay() const {
   MONITORINFOEX monitor_info = MonitorInfoFromWindow(nullptr,
                                                      MONITOR_DEFAULTTOPRIMARY);
   gfx::win::ScreenWinDisplay screen_win_display =
       GetScreenWinDisplay(monitor_info);
   gfx::Display display = screen_win_display.display();
   // The Windows primary monitor is defined to have an origin of (0, 0).
   DCHECK_EQ(0, display.bounds().origin().x());
   DCHECK_EQ(0, display.bounds().origin().y());
   return screen_win_display;
 }
 
 gfx::win::ScreenWinDisplay ScreenWin::GetScreenWinDisplay(
     const MONITORINFOEX& monitor_info) const {
   int64_t id =
       gfx::win::DisplayInfo::DeviceIdFromDeviceName(monitor_info.szDevice);
   for (const auto& screen_win_display : screen_win_displays_) {
     if (screen_win_display.display().id() == id)
       return screen_win_display;
   }
   // There is 1:1 correspondence between MONITORINFOEX and ScreenWinDisplay.
   // If we make it here, it means we have no displays and we should hand out the
   // default display.
   DCHECK_EQ(screen_win_displays_.size(), 0u);
   return gfx::win::ScreenWinDisplay();
 }
 
+// static
+float ScreenWin::GetScaleFactorForHWND(HWND hwnd) {
+  if (!g_screen_win_instance)
+    return gfx::win::ScreenWinDisplay().display().device_scale_factor();
+
+  DCHECK(hwnd);
+  HWND rootHwnd = g_screen_win_instance->GetRootWindow(hwnd);
+  gfx::win::ScreenWinDisplay screen_win_display =
+      g_screen_win_instance->GetScreenWinDisplayNearestHWND(rootHwnd);
+  return screen_win_display.display().device_scale_factor();
+}
+
+// static
+template <typename Getter, typename GetterType>
+gfx::win::ScreenWinDisplay ScreenWin::GetScreenWinDisplayVia(Getter getter,
+                                                             GetterType value) {
+  if (!g_screen_win_instance)
+    return gfx::win::ScreenWinDisplay();
+
+  return (g_screen_win_instance->*getter)(value);
+}
+
 }  // namespace gfx