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 {
 
+// Represents the amount of rotation an object has about a coordinate plane.
+enum class CoordinateRotation {
+  COORDINATE_ROTATE_0,
+  COORDINATE_ROTATE_90,
+  COORDINATE_ROTATE_180,
+  COORDINATE_ROTATE_270,
+};
+
+// Returns the CoordinateRotation necessary for |ref| and |other| so that |ref|
+// is positioned on top of |other|.
+CoordinateRotation ComputeCoordinateRotationRefTop(const gfx::Rect& ref,
+                                                   const gfx::Rect& other) {
+  if (ref.bottom() <= other.y())
+    return CoordinateRotation::COORDINATE_ROTATE_0;
+  if (other.right() <= ref.x())
+    return CoordinateRotation::COORDINATE_ROTATE_90;
+  if (other.bottom() <= ref.y())
+    return CoordinateRotation::COORDINATE_ROTATE_180;
+
+  return CoordinateRotation::COORDINATE_ROTATE_270;
+}
+
+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 CoordinateRotateRect(const gfx::Rect& rect,
+                               CoordinateRotation rotation) {
+  switch (rotation) {
+    case CoordinateRotation::COORDINATE_ROTATE_90:
+      return CoordinateRotateRectangle90(rect);
+    case CoordinateRotation::COORDINATE_ROTATE_180:
+      return CoordinateRotateRectangle180(rect);
+    case CoordinateRotation::COORDINATE_ROTATE_270:
+      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,

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

Since the commnd says ref is on top of rect, why don't we just call them

rect_top, rect_bottom?

What way, the code is more descriptive.

[robliao, 2016/05/26 23:19:24]

At this point ref is not necessarily on top of rect. It would be misleading to
rename ref to rect_top.

[oshima, 2016/05/26 23:43:13]

Ah ok. nvm.

+// 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;
+
+  CoordinateRotation degrees = ComputeCoordinateRotationRefTop(ref, rect);
+  gfx::Rect top_rect(CoordinateRotateRect(ref, degrees));
+  gfx::Rect bottom_rect(CoordinateRotateRect(rect, degrees));
+  if (bottom_rect.right() < top_rect.x())
+    return (bottom_rect.top_right() - top_rect.bottom_left()).LengthSquared();
+  else if (top_rect.right() < bottom_rect.x())
+    return (bottom_rect.origin() - top_rect.bottom_right()).LengthSquared();
+
+  int distance = bottom_rect.y() - top_rect.bottom();
+  return distance * distance;
+}
+
 }  // namespace win
 }  // namespace display