1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_GEOMETRY_PHYSICAL_SIZE_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_GEOMETRY_PHYSICAL_SIZE_H_
#include "third_party/blink/renderer/platform/geometry/layout_unit.h"
#include "third_party/blink/renderer/platform/platform_export.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/size_f.h"
namespace WTF {
class String;
} // namespace WTF
namespace blink {
enum AspectRatioFit { kAspectRatioFitShrink, kAspectRatioFitGrow };
// PhysicalSize is the size of a rect (typically a fragment) in the physical
// coordinate system.
// For more information about physical and logical coordinate systems, see:
// https://chromium.googlesource.com/chromium/src/+/main/third_party/blink/renderer/core/layout/README.md#coordinate-spaces
struct PLATFORM_EXPORT PhysicalSize {
constexpr PhysicalSize() = default;
constexpr PhysicalSize(LayoutUnit width, LayoutUnit height)
: width(width), height(height) {}
// This is deleted to avoid unwanted lossy conversion from float or double to
// LayoutUnit or int. Use explicit LayoutUnit constructor for each parameter,
// or use FromSizeF*() instead.
PhysicalSize(double, double) = delete;
// For testing only. It's defined in core/testing/core_unit_test_helper.h.
// 'constexpr' is to let compiler detect usage from production code.
constexpr PhysicalSize(int width, int height);
LayoutUnit width;
LayoutUnit height;
constexpr bool operator==(const PhysicalSize& other) const = default;
PhysicalSize operator+(const PhysicalSize& other) const {
return PhysicalSize{this->width + other.width, this->height + other.height};
}
PhysicalSize& operator+=(const PhysicalSize& other) {
*this = *this + other;
return *this;
}
PhysicalSize operator-() const {
return PhysicalSize{-this->width, -this->height};
}
PhysicalSize operator-(const PhysicalSize& other) const {
return PhysicalSize{this->width - other.width, this->height - other.height};
}
PhysicalSize& operator-=(const PhysicalSize& other) {
*this = *this - other;
return *this;
}
// Returns a new PhysicalSize scaling `this` by `scale`.
PhysicalSize operator*(float scale) const {
return PhysicalSize(LayoutUnit(this->width * scale),
LayoutUnit(this->height * scale));
}
constexpr bool IsEmpty() const {
return width == LayoutUnit() || height == LayoutUnit();
}
constexpr bool IsZero() const {
return width == LayoutUnit() && height == LayoutUnit();
}
constexpr bool HasFraction() const {
return width.HasFraction() || height.HasFraction();
}
void Scale(float s) {
width *= s;
height *= s;
}
void Scale(LayoutUnit s) {
width *= s;
height *= s;
}
// Returns a new PhysicalSize with the maximum width of `this` and `other`,
// and the maximum height of `this` and `other`.
PhysicalSize ExpandedTo(const PhysicalSize& other) const {
return {std::max(this->width, other.width),
std::max(this->height, other.height)};
}
// Returns a new PhysicalSize with the minimum width of `this` and `other`,
// and the minimum height of `this` and `other`.
PhysicalSize ShrunkTo(const PhysicalSize& other) const {
return {std::min(this->width, other.width),
std::min(this->height, other.height)};
}
void ClampNegativeToZero() {
width = std::max(width, LayoutUnit());
height = std::max(height, LayoutUnit());
}
PhysicalSize FitToAspectRatio(const PhysicalSize& aspect_ratio,
AspectRatioFit fit) const;
constexpr explicit operator gfx::SizeF() const { return {width, height}; }
static PhysicalSize FromSizeFRound(const gfx::SizeF& size) {
return {LayoutUnit::FromFloatRound(size.width()),
LayoutUnit::FromFloatRound(size.height())};
}
static PhysicalSize FromSizeFFloor(const gfx::SizeF& size) {
return {LayoutUnit::FromFloatFloor(size.width()),
LayoutUnit::FromFloatFloor(size.height())};
}
explicit PhysicalSize(const gfx::Size& size)
: width(size.width()), height(size.height()) {}
WTF::String ToString() const;
};
PLATFORM_EXPORT std::ostream& operator<<(std::ostream&, const PhysicalSize&);
// Convert an aspect ratio represented as a gfx::SizeF (width:height) to the
// closest PhysicalSize representation.
PLATFORM_EXPORT PhysicalSize LayoutRatioFromSizeF(gfx::SizeF ratio);
// TODO(crbug.com/41458361): These functions should upgraded to force correct
// pixel snapping in a type-safe way.
inline gfx::Size ToRoundedSize(const PhysicalSize& s) {
return {s.width.Round(), s.height.Round()};
}
inline gfx::Size ToFlooredSize(const PhysicalSize& s) {
return {s.width.Floor(), s.height.Floor()};
}
inline gfx::Size ToCeiledSize(const PhysicalSize& s) {
return {s.width.Ceil(), s.height.Ceil()};
}
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_GEOMETRY_PHYSICAL_SIZE_H_
|
