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 "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"
+
+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(gfx::Rect rect,
+                                       RelativePosition relative_position) {
+  switch (relative_position) {
+    case RelativePosition::LEFT:
+      rect = CoordinateRotateRectangle90(rect);

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

nit: simply return instead of assigning to rect. same for other places. You may
pass rect by const reference.

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

Done.

+      break;
+    case RelativePosition::TOP:
+      rect = CoordinateRotateRectangle180(rect);
+      break;
+    case RelativePosition::RIGHT:
+      rect = CoordinateRotateRectangle270(rect);
+      break;
+    }

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

indent. same for other places.

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

Done.

+  return rect;
+}
+
+gfx::Rect CanonicalizeTouchingEdge(gfx::Rect rect,
+                                   gfx::win::RectEdge edge) {
+  switch (edge) {
+    case gfx::win::RectEdge::LEFT:
+      rect = CoordinateRotateRectangle90(rect);
+      break;
+    case gfx::win::RectEdge::TOP:
+      rect = CoordinateRotateRectangle180(rect);
+      // Helps prefer left and top alignment.
+      rect = CoordinateReflectRectangleYAxis(rect);
+      break;
+    case gfx::win::RectEdge::RIGHT:
+      rect = CoordinateRotateRectangle270(rect);
+      // Helps prefer left and top alignment.
+      rect = CoordinateReflectRectangleYAxis(rect);
+      break;
+    }
+  return rect;
+}
+
+// Inverse of CanonicalizeTouchingEdge.
+gfx::Rect RevertToOriginalEdge(gfx::Rect rect, gfx::win::RectEdge edge) {
+  switch (edge) {
+    case gfx::win::RectEdge::LEFT:
+      rect = CoordinateRotateRectangle270(rect);
+      break;
+    case gfx::win::RectEdge::TOP:
+      rect = CoordinateReflectRectangleYAxis(rect);
+      rect = CoordinateRotateRectangle180(rect);
+      break;
+    case gfx::win::RectEdge::RIGHT:
+      rect = CoordinateReflectRectangleYAxis(rect);
+      rect = CoordinateRotateRectangle90(rect);
+      break;
+    }
+  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(new_min == new_max);

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

DCHECK_EQ

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

Done.

+    return new_min;
+  }
+  float percent = (float)(val - old_min) / (float)old_delta;

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

static_cast

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

Done.

+  return new_min + gfx::ToFlooredInt(percent * (float)(new_max - new_min));
+}
+
+RelativePosition RectRelativePosition(gfx::Rect ref, gfx::Rect test) {
+  int i = 0;
+  for (; i <= 3; ++i) {
+    if (ref.bottom() <= test.y()) {
+      break;
+    } else {
+      ref = CoordinateRotateRectangle90(ref);
+      test = CoordinateRotateRectangle90(test);
+    }
+  }
+  switch (i) {
+    case 0:
+      return RelativePosition::BOTTOM;
+    case 1:
+      return RelativePosition::LEFT;
+    case 2:
+      return RelativePosition::TOP;
+    default:
+      DCHECK(i == 3);
+      return RelativePosition::RIGHT;
+  }
+}
+
+}  // namespace
+
+namespace gfx {
+namespace win {
+
+RectEdge FindTouchingRectEdge(gfx::Rect ref, gfx::Rect test) {
+  for (int i = 0; i <= 3; ++i) {
+    if (ref.bottom() == test.y() &&
+        (InRange(test.x(), ref.x(), ref.right()) ||
+            InRange(test.right(), ref.x(), ref.right()) ||
+            InRange(ref.x(), test.x(), test.right()) ||
+            InRange(ref.right(), test.x(), test.right()))) {

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

this indent looks odd to me.

I believe this is testing if two overlaps. Can it be

!(test.right() < ref.x() || ref.right() < test.x())

? or use Range::Intersects

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

The parens certainly make it look odd, but I think this is the right break if we
group the statements together.
if (Statement1 &&
    Statement2
        Continuation of Statement 2
        Continuation of Statement 2
        Continuation of Statement 2)

As for the comparison, the rects actually may have negative coordinates, which
means we can't use gfx::Range (unsigned ints).

What's the motivation of directly inlining InRange into its boolean statement?

Variations of
ref.x() <= test.x() && test.x() <= ref.right()
!(ref.x() > test.x() || test.x() > ref.right())
!(test.x() < ref.x() || ref.right() < test.x())
repeated many times seem harder to read than
InRange(test.x(), ref.x(), ref.right()) especially as the expressions get
longer:
ref_original_rect.x() <= target_rect.right() && 
    target_rect.right() <= ref_original_rect.right())
!(ref_original_rect.x() > target_rect.right() ||
    target_rect.right() > ref_original_rect.right()))
!(target_rect.right() < ref_original_rect.x()  ||
    ref_original_rect.right() < target_rect.right())
vs.
InRange(target_rect.right(),
        ref_original_rect.x(),
        ref_original_rect.right())

[oshima, 2016/02/12 23:18:26]

It looks to me that this is more like

if (Statement &&
    (NestedStatement ||
     NestedStatement ||
     NestedStatement ||
     NestedStatement)) {


Both git cl format and emacs's google style script format this as

  for (int i = 0; i <= 3; ++i) {
    if (ref.bottom() == test.y() &&
        (InRange(test.x(), ref.x(), ref.right()) ||
         InRange(test.right(), ref.x(), ref.right()) ||
         InRange(ref.x(), test.x(), test.right()) ||
         InRange(ref.right(), test.x(), test.right()))) {
Bummer. I should have been fixed to use ints. There is gfx::RectF, which accepts
float
although it's probably overkill.
What I'm saying is that the following single line does the same thing:

!(test.right() < ref.x() || ref.right() < test.x())

[robliao, 2016/02/13 01:27:49]

Applied the formatting.

We're in agreement that InRange and the above boolean expression does the same
thing (proof of equivalence available in my comment).

Because this statement is repeated many times, I created InRange to make this
easier to read.

[oshima, 2016/02/16 06:03:26]

Acknowledged.

+      switch (i) {
+        case 0:
+          return RectEdge::BOTTOM;
+        case 1:
+          return RectEdge::LEFT;
+        case 2:
+          return RectEdge::TOP;
+        case 3:
+          return RectEdge::RIGHT;
+      }
+    } else {
+      ref = CoordinateRotateRectangle90(ref);
+      test = CoordinateRotateRectangle90(test);
+    }
+  }
+  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_original_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_original_rect| instead of the bottom, left, top, and
+// right.
+gfx::Rect ScaleAndPositionRect(gfx::Rect ref_scaled_rect,
+                               gfx::Rect ref_original_rect,
+                               gfx::Rect target_rect,
+                               float target_scale_factor) {
+  RectEdge orig_edge = FindTouchingRectEdge(ref_original_rect, target_rect);
+
+  // Scale size only since the scaled origin location will be determined below.
+  gfx::Rect scaled_rect = gfx::ScaleToEnclosingRect(target_rect,
+                                                    1.0f / target_scale_factor);
+  scaled_rect.set_origin(gfx::Point(0, 0));
+
+  if (orig_edge == RectEdge::NONE) {
+    // Currently, we expect all rectangles to touch each other.
+    NOTREACHED();
+    scaled_rect.set_origin(target_rect.origin());
+  }
+
+  // Transform rectangles so we can simply deal with bottom edge sharing.
+  ref_scaled_rect = CanonicalizeTouchingEdge(ref_scaled_rect, orig_edge);
+  ref_original_rect = CanonicalizeTouchingEdge(ref_original_rect, orig_edge);
+  target_rect = CanonicalizeTouchingEdge(target_rect, orig_edge);
+  scaled_rect = CanonicalizeTouchingEdge(scaled_rect, orig_edge);
+
+  // Position the rect.
+  scaled_rect.set_y(ref_scaled_rect.bottom());
+  int x;
+  if (target_rect.right() == ref_original_rect.right()) {
+    // Maintain right alignment. If the rectangle was left-aligned, the next
+    // case will catch that.
+    x = ref_scaled_rect.right() - scaled_rect.width();
+  } else if (InRange(target_rect.x(),
+                     ref_original_rect.x(),
+                     ref_original_rect.right())) {
+    // Position using the left point relative to the reference rect.
+    x = ScaleValue(ref_scaled_rect.x(), ref_scaled_rect.right(),
+                   ref_original_rect.x(), ref_original_rect.right(),
+                   target_rect.x());
+  } else if (InRange(target_rect.right(),
+                     ref_original_rect.x(),
+                     ref_original_rect.right())) {
+    // Position using the right point relative to the reference rect.
+    x = ScaleValue(ref_scaled_rect.x(), ref_scaled_rect.right(),
+                   ref_original_rect.x(), ref_original_rect.right(),
+                   target_rect.right()) - scaled_rect.width();
+  } else if (InRange(ref_scaled_rect.x(),
+                     target_rect.x(),
+                     target_rect.right())) {
+    // Position relative to the left point of the reference rect.
+    int offset = ScaleValue(0, scaled_rect.width(),
+                            0, target_rect.width(),
+                            ref_original_rect.x() - target_rect.x());
+    x = ref_scaled_rect.x() - offset;
+  } else {
+    // Position relative to the right point of the reference rect.
+    int offset = ScaleValue(0, scaled_rect.width(),
+                            0, target_rect.width(),
+                            ref_original_rect.right() - target_rect.x());
+    x = ref_scaled_rect.x() - offset - scaled_rect.width();
+  }
+  scaled_rect.set_x(x);
+  DCHECK(
+      FindTouchingRectEdge(ref_scaled_rect, 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(gfx::Rect ref, gfx::Rect rect) {
+  if (ref.Intersects(rect))
+    return 0;
+
+  RelativePosition relative_position = RectRelativePosition(ref, rect);
+  ref = CanonicalizeRelativePosition(ref, relative_position);
+  rect = CanonicalizeRelativePosition(rect, relative_position);
+  // Now that the ref is on top, we can concentrate ref bottom
+  // and rect top calculations.
+  if (rect.right() < ref.x())
+    return (rect.top_right() - ref.bottom_left()).LengthSquared();
+  else if (ref.right() < rect.x())
+    return (rect.origin() - ref.bottom_right()).LengthSquared();
+
+  int distance = rect.y() - ref.bottom();
+  return distance * distance;
+}
+
+}  // namespace win
+}  // namespace gfx