Multiple DPI Tracking for ScreenWin

ui/display/win/scaling_util.cc

 // Copyright 2016 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/display/win/scaling_util.h"
 
 #include <algorithm>
 
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/range/range.h"
 
 namespace {
 
+enum class RelativePosition {
+  BOTTOM = 0,
+  LEFT = 1,
+  TOP = 2,
+  RIGHT = 3,
+};
+
+// Returns the relative position of |test| with respect to |ref|.
+// If |test| is below |ref|, then the return value is RelativePosition::BOTTOM.
+// The precedence of relative position in order of highest to lowest is
+// BOTTOM, LEFT, TOP, and finally RIGHT.
+// In other words, if |test| is both below and to the left of |ref|, then the
+// RelativePosition is BOTTOM.
+RelativePosition RectRelativePosition(const gfx::Rect& ref,
+                                      const gfx::Rect& test) {
+  if (ref.bottom() <= test.y())
+    return RelativePosition::BOTTOM;
+  if (test.right() <= ref.x())
+    return RelativePosition::LEFT;
+  if (test.bottom() <= ref.y())
+    return RelativePosition::TOP;
+
+  return RelativePosition::RIGHT;
+}
+
+gfx::Rect CoordinateRotateRectangle90(const gfx::Rect& rect) {
+  return gfx::Rect(rect.y(), -rect.x() - rect.width(),
+                   rect.height(), rect.width());
+}
+
+gfx::Rect CoordinateRotateRectangle180(const gfx::Rect& rect) {
+  return gfx::Rect(-rect.x() - rect.width(), -rect.y() -rect.height(),
+                   rect.width(), rect.height());
+}
+
+gfx::Rect CoordinateRotateRectangle270(const gfx::Rect& rect) {
+  return gfx::Rect(-rect.y() - rect.height(), rect.x(),
+                   rect.height(), rect.width());
+}
+
+gfx::Rect CanonicalizeRelativePosition(const gfx::Rect& rect,
+                                       RelativePosition relative_position) {
+  switch (relative_position) {
+    case RelativePosition::LEFT:
+      return CoordinateRotateRectangle90(rect);
+    case RelativePosition::TOP:
+      return CoordinateRotateRectangle180(rect);
+    case RelativePosition::RIGHT:
+      return CoordinateRotateRectangle270(rect);
+    default:
+      return rect;
+  }
+}
+
 bool InRange(int target, int lower_bound, int upper_bound) {
   return lower_bound <= target && target <= upper_bound;
 }
 
 // Scaled |unscaled_offset| to the same relative position on |unscaled_length|
 // based off of |unscaled_length|'s |scale_factor|.
 int ScaleOffset(int unscaled_length, float scale_factor, int unscaled_offset) {
   float scaled_length = static_cast<float>(unscaled_length) / scale_factor;
   float percent =
       static_cast<float>(unscaled_offset) / static_cast<float>(unscaled_length);
@@ skipping 135 matching lines @@
   } else {
     DCHECK(InRange(parent_begin, current_begin, current_end));
     placement.offset = ScaleOffset(current_end - current_begin,
                                    current.device_scale_factor(),
                                    current_begin);
   }
 
   return placement;
 }
 
+// This function rotates the rectangles so that ref is always on top of rect,
+// allowing the function to concentrate on comparing |ref|'s bottom corners and
+// |rect|'s top corners when the rects don't overlap vertically.
+int64_t SquaredDistanceBetweenRects(const gfx::Rect& ref,
+                                    const gfx::Rect& rect) {
+  if (ref.Intersects(rect))
+    return 0;
+
+  RelativePosition relative_position = RectRelativePosition(ref, rect);
+  gfx::Rect ref_work(CanonicalizeRelativePosition(ref, relative_position));
+  gfx::Rect rect_work(CanonicalizeRelativePosition(rect, relative_position));

[oshima, 2016/05/26 21:52:57]

Just naming suggestion. how about:

Rotation degree = ComputeRotationToLayoutPortrait(rect_to_be_upper,
rect_top_be_lower); // LayoutVertical?

upper_rect = RotateRect(rect_to_be_upper, degree);
lower_rect = RotateRect(rect_to_be_lower, degree);

...


?

[robliao, 2016/05/26 22:28:47]

I want to avoid using display::Rotation as that semantically has a different
meaning than the rotation used here. I'll use CoordinateRotation instead.

display::Rotation is a rotation with respect to the display. The rotation here
is with respect to a coordinate plane.

The layout considered here is a specific layout where |ref| is always on the
top. 

Adjusted the code to reflect the intent behind the comment.

[oshima, 2016/05/26 22:54:47]

I didn't mean to suggest display::Rotation. Sorry it wasn't clear.

What I wanted to say is that, the code rotates the rect so naming should reflect
that. The new one looks good. thanks.

+  // Now that the ref is on top, we can concentrate ref bottom
+  // and rect top calculations.
+  if (rect_work.right() < ref_work.x())
+    return (rect_work.top_right() - ref_work.bottom_left()).LengthSquared();
+  else if (ref_work.right() < rect_work.x())
+    return (rect_work.origin() - ref_work.bottom_right()).LengthSquared();
+
+  int distance = rect_work.y() - ref_work.bottom();
+  return distance * distance;
+}
+
 }  // namespace win
 }  // namespace display