Multiple DPI Tracking for ScreenWin

ui/gfx/win/rect_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/gfx/win/rect_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,
+};
+
+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 CoordinateReflectRectangleYAxis(const gfx::Rect& rect) {
+  return gfx::Rect(-rect.x() - rect.width(), rect.y(),
+                   rect.width(), rect.height());
+}
+
+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);
+  }
+  return rect;
+}
+
+gfx::Rect CanonicalizeTouchingEdge(const gfx::Rect& rect,
+                                   gfx::win::RectEdge edge) {
+  switch (edge) {
+    case gfx::win::RectEdge::LEFT:
+      return CoordinateRotateRectangle90(rect);
+    case gfx::win::RectEdge::TOP:
+      // Helps prefer left and top alignment.
+      return CoordinateReflectRectangleYAxis(
+          CoordinateRotateRectangle180(rect));
+    case gfx::win::RectEdge::RIGHT:
+      // Helps prefer left and top alignment.
+      return CoordinateReflectRectangleYAxis(
+          CoordinateRotateRectangle270(rect));
+  }
+  return rect;
+}
+
+// Inverse of CanonicalizeTouchingEdge.
+gfx::Rect RevertToOriginalEdge(const gfx::Rect& rect, gfx::win::RectEdge edge) {
+  switch (edge) {
+    case gfx::win::RectEdge::LEFT:
+      return CoordinateRotateRectangle270(rect);
+    case gfx::win::RectEdge::TOP:
+      return CoordinateRotateRectangle180(
+          CoordinateReflectRectangleYAxis(rect));
+    case gfx::win::RectEdge::RIGHT:
+      return CoordinateRotateRectangle90(
+          CoordinateReflectRectangleYAxis(rect));
+  }
+  return rect;
+}
+
+bool InRange(int target, int lower_bound, int upper_bound) {
+  return lower_bound <= target && target <= upper_bound;
+}
+
+// Scales |val| within |old_min| and |old_max| to |new_min| and |new_max|.
+int ScaleValue(int new_min, int new_max, int old_min, int old_max, int val) {
+  int old_delta = old_max - old_min;
+  if (old_delta == 0) {
+    DCHECK_EQ(new_min, new_max);
+    return new_min;
+  }
+  float percent =
+      static_cast<float>(val - old_min) / static_cast<float>(old_delta);
+  return new_min + gfx::ToFlooredInt(percent * (float)(new_max - new_min));
+}
+
+// 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;
+}
+
+}  // namespace
+
+namespace gfx {
+namespace win {
+
+RectEdge FindTouchingRectEdge(const gfx::Rect& ref, const gfx::Rect& test) {
+  int max_x = std::max(ref.x(), test.x());

[sky, 2016/02/18 17:02:58]

I have a hard time reading this code because max_x implies the biggest
x-coordinate, but that's not what this is. It's the biggest left value. How
about max_left and max_top? That better matches min_bottom and min_right.

[robliao, 2016/02/19 00:26:29]

sgtm. Done. As an aside, the original naming from gfx::Rect was rx, ry, rr, rb,
which I had renamed here to [min|max]_[rect property name]

+  int max_y = std::max(ref.y(), test.y());
+  int min_right = std::min(ref.right(), test.right());
+  int min_bottom = std::min(ref.bottom(), test.bottom());
+  if (max_x == min_right && max_y == min_bottom) {
+    // Corner touching.
+    if (ref.bottom() == max_y)
+      return RectEdge::BOTTOM;
+    if (ref.x() == max_x)
+      return RectEdge::LEFT;
+
+    return RectEdge::TOP;
+  }
+  if (max_x == min_right) {
+    // Vertical edge touching.
+    return ref.x() == max_x ? RectEdge::LEFT : RectEdge::RIGHT;
+  }
+  if (max_y == min_bottom) {
+    // Horizontal edge touching.
+    return ref.y() == max_y ? RectEdge::TOP : RectEdge::BOTTOM;
+  }
+  return RectEdge::NONE;
+}
+
+// Writing code that specifically deals with scaling each rect is tedious and
+// error prone. Instead, this function transforms the positions of the
+// two rects so that |ref_scaled_rect| is always on top of |ref_unscaled_rect|,
+// calculates the scaled and positioned target rect, and then reverses the
+// transforms. As a result, the position logic can be written in terms of the
+// bottom of the |ref_unscaled_rect| instead of the bottom, left, top, and
+// right.
+gfx::Rect ScaleAndPositionRect(const gfx::Rect& ref_scaled_rect,
+                               const gfx::Rect& ref_unscaled_rect,
+                               const gfx::Rect& unscaled_rect,
+                               float unscaled_rect_scale_factor) {
+  RectEdge orig_edge = FindTouchingRectEdge(ref_unscaled_rect, unscaled_rect);
+
+  // Scale size only since the scaled origin location will be determined below.
+  gfx::Rect scaled_rect(
+      gfx::ScaleToEnclosingRect(unscaled_rect,
+                                1.0f / unscaled_rect_scale_factor));
+  scaled_rect.set_origin(gfx::Point(0, 0));
+
+  if (orig_edge == RectEdge::NONE) {
+    // ScaleAndPositionRect depends on unscaled rectangles touching.
+    DCHECK(false);
+    scaled_rect.set_origin(unscaled_rect.origin());
+  }
+
+  // Transform rectangles so we can simply deal with bottom edge sharing.
+  gfx::Rect ref_scaled_rect_work(
+      CanonicalizeTouchingEdge(ref_scaled_rect, orig_edge));
+  gfx::Rect ref_unscaled_rect_work(
+      CanonicalizeTouchingEdge(ref_unscaled_rect, orig_edge));
+  gfx::Rect unscaled_rect_work(
+      CanonicalizeTouchingEdge(unscaled_rect,orig_edge));
+  scaled_rect = CanonicalizeTouchingEdge(scaled_rect, orig_edge);
+
+  // Position the rect.
+  scaled_rect.set_y(ref_scaled_rect_work.bottom());
+  int x;
+  if (unscaled_rect_work.right() == ref_unscaled_rect_work.right()) {
+    // Maintain right alignment. If the rectangle was left-aligned, the next
+    // case will catch that.
+    x = ref_scaled_rect_work.right() - scaled_rect.width();
+  } else if (InRange(unscaled_rect_work.x(),
+                     ref_unscaled_rect_work.x(),
+                     ref_unscaled_rect_work.right())) {
+    // Position using the left point relative to the reference rect.
+    x = ScaleValue(ref_scaled_rect_work.x(), ref_scaled_rect_work.right(),
+                   ref_unscaled_rect_work.x(), ref_unscaled_rect_work.right(),
+                   unscaled_rect_work.x());
+  } else if (InRange(unscaled_rect_work.right(),
+                     ref_unscaled_rect_work.x(),
+                     ref_unscaled_rect_work.right())) {
+    // Position using the right point relative to the reference rect.
+    x = ScaleValue(ref_scaled_rect_work.x(), ref_scaled_rect_work.right(),
+                   ref_unscaled_rect_work.x(), ref_unscaled_rect_work.right(),
+                   unscaled_rect_work.right()) - scaled_rect.width();
+  } else if (InRange(ref_scaled_rect_work.x(),
+                     unscaled_rect_work.x(),
+                     unscaled_rect_work.right())) {
+    // Position relative to the left point of the reference rect.
+    int offset = ScaleValue(0, scaled_rect.width(),
+                            0, unscaled_rect_work.width(),
+                            ref_unscaled_rect_work.x() -
+                                unscaled_rect_work.x());
+    x = ref_scaled_rect_work.x() - offset;
+  } else {
+    // Position relative to the right point of the reference rect.
+    int offset = ScaleValue(0, scaled_rect.width(),
+                            0, unscaled_rect_work.width(),
+                            ref_unscaled_rect_work.right() -
+                                unscaled_rect_work.x());
+    x = ref_scaled_rect_work.x() - offset - scaled_rect.width();
+  }
+  scaled_rect.set_x(x);
+  DCHECK(FindTouchingRectEdge(ref_scaled_rect_work, scaled_rect) ==
+             RectEdge::BOTTOM);
+
+  // Reverse the transformation.
+  return RevertToOriginalEdge(scaled_rect, orig_edge);
+}
+
+// This function takes the same approach as ScaleAndPositionRect, transforming
+// the two input rects so that the relative positions are always the same.
+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));
+  // 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 gfx