Multiple DPI Tracking for ScreenWin

ui/gfx/win/rect_util.h

Index: ui/gfx/win/rect_util.h
diff --git a/ui/gfx/win/rect_util.h b/ui/gfx/win/rect_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..60c109d335bfc89b8352f65ac69fa2008baadae4
--- /dev/null
+++ b/ui/gfx/win/rect_util.h
@@ -0,0 +1,130 @@
+// 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|.
+// Returns RectEdge::NONE if |ref| and |test| do not touch.
+// At corners, the bottom corners are clamped to BOTTOM, the upper left corner
+// is clamped to LEFT and the upper right corner is clamped to TOP.
+GFX_EXPORT RectEdge FindTouchingRectEdge(const gfx::Rect& ref,
+                                         const gfx::Rect& test);
+
+// Returns a scaled and position rect from |unscaled_rect|, positioned against
+// |ref_scaled_rect| based off of the original edge positioning on
+// |ref_unscaled_rect|, and downscaled by |unscaled_rect_scale_factor|.
+// As such, |unscaled_rect| and |ref_unscaled_rect| must be touching rectangles.
+//
+// Examples:
+// Scaled and Unscaled Coordinates
+// +--------------+              Since both rectangles are of the same scale
+// |              |              factor, relative positions remain the same.
+// |              |
+// |    REF 1x    +----------+
+// |              |          |
+// +--------------+    1x    |
+//                |          |
+//                +----------+
+//
+// Unscaled Coordinates
+// +--------------+              The 2x rectangle is scaled down while
+// |              |              maintaining a similar neighboring relationship
+// |              |              with the REF 1x rectangle.
+// |    REF 1x    +----------+
+// |              |          |
+// +--------------+    2x    |
+//                |          |
+//                +----------+
+// Scaled Coordinates
+// +--------------+
+// |              |
+// |              |
+// |    REF 1x    |
+// |              +-----+
+// +--------------+  2x |
+//                +-----+
+//
+// Unscaled Coordinates
+// +--------------+              The reference rectangle has been scaled by 2x
+// |              |              from |ref_unscaled_rect| to |ref_scaled_rect|.
+// |              |              ScaleAndPositionRect maintains the same
+// |    REF 2x    +----------+   relative positioning of the unscaled rect in
+// |              |          |   the scaled coordinate space.
+// |              |          |
+// |              |    1x    |
+// +--------------+          |
+//                |          |
+//                +----------+
+// Scaled Coordinates
+// +-------+
+// |       |
+// | REF 2x+----------+
+// |       |          |
+// +-------+          |
+//         |    1x    |
+//         |          |
+//         |          |
+//         +----------+
+GFX_EXPORT gfx::Rect ScaleAndPositionRect(const gfx::Rect& ref_scaled_rect,

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

Thanks for the comments. I think I understand what you're trying to do here now.
Why can't you take the top/left corner of unscaled_rect, apply the scale of ref
rect to get the origin of the resulting rect. For the size of the resulting rect
scale the unscaled_rects size by unscaled_rect_scale_factor. Isn't this
effectively what this function wants to do?

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

The sizing is straightforward. The positioning is tricky.

To rephrase, the proposal above is to have (correct me if I'm wrong)...
ScaledRectOrigin(unscaled_rect.origin(), ref_scale_factor)

One of the fun parts about MultiDPI is that while the reference rectangle may
have a scale factor of 1x, it can move between unscaled and scaled coordinate
systems.

Consider 3 monitors side-by-side:
[Left 3x], [Middle 1x], [Right 1x]
The left monitor will shrink when we go from unscaled to scaled. This means to
place the middle monitor, we need to know the size of the left monitor and the
scale factor. That's fine.

However, to position the right monitor, we need to figure out how much the
middle monitor moved from unscaled to scaled so that the right monitor can
remain side-by-side in scaled. This means having the scale factor is insufficent
to place the right monitor. We need to have the unscaled and scaled origins of
the middle monitor.

So now we have
ScaledRectOrigin(unscaled_rect.origin(), ref_scale_factor,
ref_unscaled.origin(), ref_scaled.origin())


The next case is case #2 in the comment.
If we only consider the reference scale, then the unscaled_rect origin doesn't
move. This means the bottom edge of the reference rectangle is no longer
perpendicular to the left edge of unscaled_rect with sufficient scaling.

This shows up in monitors that are aligned across the bottom:

+------+
| REF  +----+
|  1x  |    |
|      | 2x |   
+------+----+

Since REF 1x basically doesn't change between unscaled and scaled coordinates,
to maintain the bottom alignment of the unscaled_rect, we need to know how it
was positioned along the reference rect.

This led to the need to know the reference rect in both unscaled and scaled
coordinates for positioning.

+                                          const gfx::Rect& ref_unscaled_rect,
+                                          const gfx::Rect& unscaled_rect,
+                                          float unscaled_rect_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 segment generally 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 greater than 1 unit.
+GFX_EXPORT int64_t SquaredDistanceBetweenRects(const gfx::Rect& ref,
+                                               const gfx::Rect& rect);
+
+}  // namespace win
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_RECT_UTIL_H_