Multiple DPI Tracking for ScreenWin

ui/gfx/win/rect_util.h

+// 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.
+
+#ifndef UI_GFX_WIN_RECT_UTIL_H_
+#define UI_GFX_WIN_RECT_UTIL_H_
+
+#include <stdint.h>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class Rect;
+
+namespace win {
+
+enum class RectEdge {
+  BOTTOM = 0,
+  LEFT = 1,
+  TOP = 2,
+  RIGHT = 3,
+  NONE = 4,
+};
+
+// Returns |ref|'s RectEdge touching |test|.
+GFX_EXPORT RectEdge FindTouchingRectEdge(gfx::Rect ref, gfx::Rect test);

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

const &

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

These actually started as const gfx::Rect& and then I removed them because
things got pretty messy as the first thing all of these functions would do is
copy all of the incoming values like so.

gfx::Rect ref_work(ref);
gfx::Rect test_work(test);

And then it was important that no code afterwards references ref or test ever
again otherwise they would be doing something very wrong. Inlining the copy
seemed like the right thing to do.

Do you have a better way that prevents the duplicate variable names?

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

For correctness, I'd rely on the unit tests rather than the use of copy, as
the actual effect can be opposite.
 
Not really, other than changing the logic not to rotate the rects.

If it were me, I'd get the intersect of two rects, (you can use what gfx::Rect
is doing, without the code that emptying out) then tell horizontal or vertical
edge by checking width/height, then compare the x/y with center point of the
intersect to decide which side. It's easier to follow and could be less code,
although I have no proof.

I'll leave it to your and owner though.

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

Thanks for the intersecting rect pointer. I probably got carried away with the
transformations since ScaleAndPositionRect was on the mind.

I have the proof since I coded up the solution. It passes unit tests we'll go
ahead and use it. That also cleaned up RectRelativePosition.

This allows both of them to be const Rect&'s. ScaleAndPositionRect as well as
SquaredDistanceBetweenRects are more difficult to change, so I'm going to leave
them as is. It doesn't change the callers either way.

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

Ok. I'll leave the rest to owners review. (I don't own ui/gfx/win)

+
+// Returns a scaled and positioned rect based off of target_rect and context.
+// The reference rectangle and target rectangle may scale at different rates.
+// This function attempts to preserve the relative positioning of the target
+// rectangle with respect to the scaled rectangle in the face of differing
+// scale factors.
+//
+// Examples:
+// +--------------+              Since both rectangles are of the same
+// |              |              scale factor, positions and sizes
+// |              |              remain the same.
+// |    REF 1x    +----------+
+// |              |          |
+// +--------------+    1x    |
+//                |          |
+//                +----------+
+//
+// Original
+// +--------------+              The 2x rectangle is scaled down while
+// |              |              maintaining a similar neighboring relationship
+// |              |              with the 1x rectangle.
+// |    REF 1x    +----------+
+// |              |          |
+// +--------------+    2x    |
+//                |          |
+//                +----------+
+// Scaled
+// +--------------+
+// |              |
+// |              |
+// |    REF 1x    |
+// |              +-----+
+// +--------------+  2x |
+//                +-----+
+GFX_EXPORT gfx::Rect ScaleAndPositionRect(gfx::Rect ref_scaled_rect,
+                                          gfx::Rect ref_original_rect,
+                                          gfx::Rect target_rect,
+                                          float target_scale_factor);
+
+// Returns the squared distance between two rects.
+// The distance between two rects is the length of the shortest segment that can
+// be drawn between two rectangles. This generally the segment connects two
+// opposing corners between rectangles like this...
+//
+// +----------+
+// |          |
+// +----------+
+//             \  <--- Shortest Segment
+//              \
+//               +---+
+//               |   |
+//               |   |
+//               +---+
+// For rectangles that share coordinates within the same axis, that generally
+// means the segment is parallel to the axis and perpendicular to the edges.
+//
+//                 One of many shortest segments
+//  +----------+  /                            \    +--------+
+//  |          |  |                             \   |        |
+//  |          |  V  +---+                       \  +--------+
+//  |          |-----|   |                        \-->|
+//  +----------+     |   |                            +----+
+//                   |   |                            |    |
+//                   +---+                            +----+
+//
+// For rectangles that intersect each other, the distance is 0.
+//
+// The squared distance is used to avoid taking the square root as the common
+// usage is to compare distances greather than 1 unit.
+GFX_EXPORT int64_t SquaredDistanceBetweenRects(gfx::Rect ref, gfx::Rect rect);
+
+}  // namespace win
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_RECT_UTIL_H_