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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/HashMap.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/Optional.h>
#include <AK/String.h>
#include <AK/Vector.h>
#include <LibGfx/Forward.h>
#include <LibGfx/Point.h>
#include <LibGfx/Rect.h>
namespace Gfx {
class Segment : public RefCounted<Segment> {
public:
enum class Type {
Invalid,
MoveTo,
LineTo,
QuadraticBezierCurveTo,
CubicBezierCurveTo,
EllipticalArcTo,
};
Segment(const FloatPoint& point)
: m_point(point)
{
}
virtual ~Segment() = default;
const FloatPoint& point() const { return m_point; }
virtual Type type() const = 0;
protected:
FloatPoint m_point;
};
class MoveSegment final : public Segment {
public:
MoveSegment(const FloatPoint& point)
: Segment(point)
{
}
private:
virtual Type type() const override { return Segment::Type::MoveTo; }
};
class LineSegment final : public Segment {
public:
LineSegment(const FloatPoint& point)
: Segment(point)
{
}
virtual ~LineSegment() override = default;
private:
virtual Type type() const override { return Segment::Type::LineTo; }
};
class QuadraticBezierCurveSegment final : public Segment {
public:
QuadraticBezierCurveSegment(const FloatPoint& point, const FloatPoint& through)
: Segment(point)
, m_through(through)
{
}
virtual ~QuadraticBezierCurveSegment() override = default;
const FloatPoint& through() const { return m_through; }
private:
virtual Type type() const override { return Segment::Type::QuadraticBezierCurveTo; }
FloatPoint m_through;
};
class CubicBezierCurveSegment final : public Segment {
public:
CubicBezierCurveSegment(const FloatPoint& point, const FloatPoint& through_0, const FloatPoint& through_1)
: Segment(point)
, m_through_0(through_0)
, m_through_1(through_1)
{
}
virtual ~CubicBezierCurveSegment() override = default;
const FloatPoint& through_0() const { return m_through_0; }
const FloatPoint& through_1() const { return m_through_1; }
private:
virtual Type type() const override { return Segment::Type::CubicBezierCurveTo; }
FloatPoint m_through_0;
FloatPoint m_through_1;
};
class EllipticalArcSegment final : public Segment {
public:
EllipticalArcSegment(const FloatPoint& point, const FloatPoint& center, const FloatPoint radii, float x_axis_rotation, float theta_1, float theta_delta)
: Segment(point)
, m_center(center)
, m_radii(radii)
, m_x_axis_rotation(x_axis_rotation)
, m_theta_1(theta_1)
, m_theta_delta(theta_delta)
{
}
virtual ~EllipticalArcSegment() override = default;
const FloatPoint& center() const { return m_center; }
const FloatPoint& radii() const { return m_radii; }
float x_axis_rotation() const { return m_x_axis_rotation; }
float theta_1() const { return m_theta_1; }
float theta_delta() const { return m_theta_delta; }
private:
virtual Type type() const override { return Segment::Type::EllipticalArcTo; }
FloatPoint m_center;
FloatPoint m_radii;
float m_x_axis_rotation;
float m_theta_1;
float m_theta_delta;
};
class Path {
public:
Path() { }
void move_to(const FloatPoint& point)
{
append_segment<MoveSegment>(point);
}
void line_to(const FloatPoint& point)
{
append_segment<LineSegment>(point);
invalidate_split_lines();
}
void quadratic_bezier_curve_to(const FloatPoint& through, const FloatPoint& point)
{
append_segment<QuadraticBezierCurveSegment>(point, through);
invalidate_split_lines();
}
void cubic_bezier_curve_to(FloatPoint const& c1, FloatPoint const& c2, FloatPoint const& p2)
{
append_segment<CubicBezierCurveSegment>(p2, c1, c2);
invalidate_split_lines();
}
void elliptical_arc_to(const FloatPoint& point, const FloatPoint& radii, double x_axis_rotation, bool large_arc, bool sweep);
void arc_to(const FloatPoint& point, float radius, bool large_arc, bool sweep)
{
elliptical_arc_to(point, { radius, radius }, 0, large_arc, sweep);
}
// Note: This does not do any sanity checks!
void elliptical_arc_to(const FloatPoint& endpoint, const FloatPoint& center, const FloatPoint& radii, double x_axis_rotation, double theta, double theta_delta)
{
append_segment<EllipticalArcSegment>(
endpoint,
center,
radii,
x_axis_rotation,
theta,
theta_delta);
invalidate_split_lines();
}
void close();
void close_all_subpaths();
struct SplitLineSegment {
FloatPoint from, to;
float inverse_slope;
float x_of_minimum_y;
float maximum_y;
float minimum_y;
float x;
};
const NonnullRefPtrVector<Segment>& segments() const { return m_segments; }
auto& split_lines() const
{
if (!m_split_lines.has_value()) {
const_cast<Path*>(this)->segmentize_path();
VERIFY(m_split_lines.has_value());
}
return m_split_lines.value();
}
void clear()
{
m_segments.clear();
m_split_lines.clear();
}
Gfx::FloatRect const& bounding_box() const
{
if (!m_bounding_box.has_value()) {
const_cast<Path*>(this)->segmentize_path();
VERIFY(m_bounding_box.has_value());
}
return m_bounding_box.value();
}
String to_string() const;
private:
void invalidate_split_lines()
{
m_split_lines.clear();
}
void segmentize_path();
template<typename T, typename... Args>
void append_segment(Args&&... args)
{
m_segments.append(adopt_ref(*new T(forward<Args>(args)...)));
}
NonnullRefPtrVector<Segment> m_segments {};
Optional<Vector<SplitLineSegment>> m_split_lines {};
Optional<Gfx::FloatRect> m_bounding_box;
};
}
|
