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
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
//! A builder for outlines.
//!
//! An [`OutlineBuilder`] is a point-oriented builder for a glyph's graphical outline,
//! not unlike a [fontTools point pen], but different, because it does not draw _into_ a
//! glyph due to ownership issues.
//!
//! To be used internally by [`super::parse::GlifParser`]. Does not keep track of identifier
//! uniqueness (`GlifParser` has to).
//!
//! [fontTools point pen]: https://fonttools.readthedocs.io/en/latest/pens/basePen.html
use crate::{
error::ErrorKind, AffineTransform, Component, Contour, ContourPoint, Identifier, Name,
PointType,
};
#[derive(Debug, Default)]
pub(crate) struct OutlineBuilder {
components: Vec<Component>,
contours: Vec<Contour>,
scratch_state: OutlineBuilderState,
}
#[derive(Debug, Default)]
enum OutlineBuilderState {
#[default]
Idle,
Drawing {
scratch_contour: Contour,
number_of_offcurves: u32,
},
}
impl OutlineBuilder {
pub(crate) fn new() -> Self {
Default::default()
}
/// Begin a new path to be added to the glyph.
///
/// It must be finished with [`Self::end_path`] before the outline can be
/// [`Self::finish`]ed and retrieved.
///
/// Errors when a path has been begun already but not ended yet.
///
/// On error, it won't begin a new path and you can continue drawing the previously
/// started path.
pub(crate) fn begin_path(
&mut self,
identifier: Option<Identifier>,
) -> Result<&mut Self, ErrorKind> {
match self.scratch_state {
OutlineBuilderState::Idle => {
self.scratch_state = OutlineBuilderState::Drawing {
scratch_contour: Contour::new(Vec::new(), identifier),
number_of_offcurves: 0,
};
Ok(self)
}
OutlineBuilderState::Drawing { .. } => Err(ErrorKind::UnfinishedDrawing),
}
}
/// Add a point to the path begun by `begin_path()`.
///
/// Errors when:
/// 1. [`Self::begin_path`] wasn't called first.
/// 2. the point sequence is forbidden by the specification.
///
/// If an off-curve point has the smooth attribute set, it is logged and ignored.
///
/// On error, it won't add any part of the point, but you can try again with a new
/// and improved point.
pub(crate) fn add_point(
&mut self,
(x, y): (f64, f64),
segment_type: PointType,
smooth: bool,
name: Option<Name>,
identifier: Option<Identifier>,
) -> Result<&mut Self, ErrorKind> {
match &mut self.scratch_state {
OutlineBuilderState::Idle => Err(ErrorKind::PenPathNotStarted),
OutlineBuilderState::Drawing { scratch_contour, number_of_offcurves } => {
match segment_type {
PointType::Move => {
if !scratch_contour.points.is_empty() {
return Err(ErrorKind::UnexpectedMove);
}
}
PointType::Line => {
if *number_of_offcurves > 0 {
return Err(ErrorKind::UnexpectedPointAfterOffCurve);
}
}
PointType::OffCurve => {
*number_of_offcurves = number_of_offcurves.saturating_add(1);
}
PointType::QCurve => *number_of_offcurves = 0,
PointType::Curve => {
if *number_of_offcurves > 2 {
return Err(ErrorKind::TooManyOffCurves);
}
*number_of_offcurves = 0;
}
}
scratch_contour.points.push(ContourPoint::new(
x,
y,
segment_type,
smooth,
name,
identifier,
));
Ok(self)
}
}
}
/// Ends the path begun by [`Self::begin_path`] and adds the contour to the glyph's
/// outline, unless it's empty.
///
/// Errors when:
/// 1. [`Self::begin_path`] wasn't called first.
/// 2. the point sequence is forbidden by the specification.
///
/// On error, it drops the path you were trying to end and you can
/// [`Self::begin_path`] again. It doesn't change the previously added paths.
pub(crate) fn end_path(&mut self) -> Result<&mut Self, ErrorKind> {
match std::mem::replace(&mut self.scratch_state, OutlineBuilderState::Idle) {
OutlineBuilderState::Idle => Err(ErrorKind::PenPathNotStarted),
OutlineBuilderState::Drawing { scratch_contour, mut number_of_offcurves } => {
// If ending a closed contour with off-curve points, wrap around and check
// from the beginning that we have a curve or qcurve following eventually.
if number_of_offcurves > 0 {
if scratch_contour.is_closed() {
for point in &scratch_contour.points {
match point.typ {
PointType::OffCurve => {
number_of_offcurves = number_of_offcurves.saturating_add(1);
}
PointType::QCurve => break,
PointType::Curve => {
if number_of_offcurves > 2 {
return Err(ErrorKind::TooManyOffCurves);
}
break;
}
PointType::Line => {
return Err(ErrorKind::UnexpectedPointAfterOffCurve);
}
PointType::Move => unreachable!(),
}
}
} else {
return Err(ErrorKind::TrailingOffCurves);
}
}
// Empty contours are allowed by the specification but make no sense, skip them.
if !scratch_contour.points.is_empty() {
self.contours.push(scratch_contour);
}
Ok(self)
}
}
}
/// Add a component to the glyph.
pub(crate) fn add_component(
&mut self,
base: Name,
transform: AffineTransform,
identifier: Option<Identifier>,
) -> &mut Self {
self.components.push(Component::new(base, transform, identifier));
self
}
/// Consume the builder and return the final [`Contour`]s and [`Component`]s.
///
/// Errors when a path has been begun but not ended.
///
/// On error, it won't finish the outline and return it to you, but you can
/// [`Self::end_path`] before trying to finish again.
pub(crate) fn finish(self) -> Result<(Vec<Contour>, Vec<Component>), ErrorKind> {
match self.scratch_state {
OutlineBuilderState::Idle => Ok((self.contours, self.components)),
OutlineBuilderState::Drawing { .. } => Err(ErrorKind::UnfinishedDrawing),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builder_basic() -> Result<(), ErrorKind> {
let mut outline_builder = OutlineBuilder::new();
outline_builder
.begin_path(Some(Identifier::new_raw("abc")))?
.add_point((173.0, 536.0), PointType::Line, false, None, None)?
.add_point((85.0, 536.0), PointType::Line, false, None, None)?
.add_point((85.0, 0.0), PointType::Line, false, None, None)?
.add_point(
(173.0, 0.0),
PointType::Line,
false,
None,
Some(Identifier::new_raw("def")),
)?
.end_path()?
.add_component(
Name::new_raw("hallo"),
AffineTransform::default(),
Some(Identifier::new_raw("xyz")),
);
let (contours, components) = outline_builder.finish()?;
assert_eq!(
contours,
vec![Contour::new(
vec![
ContourPoint::new(173.0, 536.0, PointType::Line, false, None, None),
ContourPoint::new(85.0, 536.0, PointType::Line, false, None, None),
ContourPoint::new(85.0, 0.0, PointType::Line, false, None, None),
ContourPoint::new(
173.0,
0.0,
PointType::Line,
false,
None,
Some(Identifier::new_raw("def")),
),
],
Some(Identifier::new_raw("abc")),
)]
);
assert_eq!(
components,
vec![Component::new(
Name::new_raw("hallo"),
AffineTransform {
x_scale: 1.0,
xy_scale: 0.0,
yx_scale: 0.0,
y_scale: 1.0,
x_offset: 0.0,
y_offset: 0.0,
},
Some(Identifier::new_raw("xyz")),
)]
);
Ok(())
}
#[test]
#[should_panic(expected = "UnfinishedDrawing")]
fn outline_builder_unfinished_drawing() {
let mut outline_builder = OutlineBuilder::new();
outline_builder.begin_path(Some(Identifier::new_raw("abc"))).unwrap();
outline_builder.finish().unwrap();
}
#[test]
#[should_panic(expected = "UnfinishedDrawing")]
fn outline_builder_unfinished_drawing2() {
OutlineBuilder::new()
.begin_path(Some(Identifier::new_raw("abc")))
.unwrap()
.begin_path(None)
.unwrap();
}
}