i_slint_core/graphics/
path.rs

1// Copyright © SixtyFPS GmbH <info@slint.dev>
2// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
3
4/*!
5This module contains path related types and functions for the run-time library.
6*/
7
8use crate::debug_log;
9use crate::items::PathEvent;
10#[cfg(feature = "rtti")]
11use crate::rtti::*;
12use auto_enums::auto_enum;
13use const_field_offset::FieldOffsets;
14use i_slint_core_macros::*;
15
16#[repr(C)]
17#[derive(FieldOffsets, Default, SlintElement, Clone, Debug, PartialEq)]
18#[pin]
19/// PathMoveTo describes the event of setting the cursor on the path to use as starting
20/// point for sub-sequent events, such as `LineTo`. Moving the cursor also implicitly closes
21/// sub-paths and therefore beings a new sub-path.
22pub struct PathMoveTo {
23    #[rtti_field]
24    /// The x coordinate where the current position should be.
25    pub x: f32,
26    #[rtti_field]
27    /// The y coordinate where the current position should be.
28    pub y: f32,
29}
30
31#[repr(C)]
32#[derive(FieldOffsets, Default, SlintElement, Clone, Debug, PartialEq)]
33#[pin]
34/// PathLineTo describes the event of moving the cursor on the path to the specified location
35/// along a straight line.
36pub struct PathLineTo {
37    #[rtti_field]
38    /// The x coordinate where the line should go to.
39    pub x: f32,
40    #[rtti_field]
41    /// The y coordinate where the line should go to.
42    pub y: f32,
43}
44
45#[repr(C)]
46#[derive(FieldOffsets, Default, SlintElement, Clone, Debug, PartialEq)]
47#[pin]
48/// PathArcTo describes the event of moving the cursor on the path across an arc to the specified
49/// x/y coordinates, with the specified x/y radius and additional properties.
50pub struct PathArcTo {
51    #[rtti_field]
52    /// The x coordinate where the arc should end up.
53    pub x: f32,
54    #[rtti_field]
55    /// The y coordinate where the arc should end up.
56    pub y: f32,
57    #[rtti_field]
58    /// The radius on the x-axis of the arc.
59    pub radius_x: f32,
60    #[rtti_field]
61    /// The radius on the y-axis of the arc.
62    pub radius_y: f32,
63    #[rtti_field]
64    /// The rotation along the x-axis of the arc in degrees.
65    pub x_rotation: f32,
66    #[rtti_field]
67    /// large_arc indicates whether to take the long or the shorter path to complete the arc.
68    pub large_arc: bool,
69    #[rtti_field]
70    /// sweep indicates the direction of the arc. If true, a clockwise direction is chosen,
71    /// otherwise counter-clockwise.
72    pub sweep: bool,
73}
74
75#[repr(C)]
76#[derive(FieldOffsets, Default, SlintElement, Clone, Debug, PartialEq)]
77#[pin]
78/// PathCubicTo describes a smooth Bézier curve from the path's current position
79/// to the specified x/y location, using two control points.
80pub struct PathCubicTo {
81    #[rtti_field]
82    /// The x coordinate of the curve's end point.
83    pub x: f32,
84    #[rtti_field]
85    /// The y coordinate of the curve's end point.
86    pub y: f32,
87    #[rtti_field]
88    /// The x coordinate of the curve's first control point.
89    pub control_1_x: f32,
90    #[rtti_field]
91    /// The y coordinate of the curve's first control point.
92    pub control_1_y: f32,
93    #[rtti_field]
94    /// The x coordinate of the curve's second control point.
95    pub control_2_x: f32,
96    #[rtti_field]
97    /// The y coordinate of the curve's second control point.
98    pub control_2_y: f32,
99}
100
101#[repr(C)]
102#[derive(FieldOffsets, Default, SlintElement, Clone, Debug, PartialEq)]
103#[pin]
104/// PathCubicTo describes a smooth Bézier curve from the path's current position
105/// to the specified x/y location, using one control points.
106pub struct PathQuadraticTo {
107    #[rtti_field]
108    /// The x coordinate of the curve's end point.
109    pub x: f32,
110    #[rtti_field]
111    /// The y coordinate of the curve's end point.
112    pub y: f32,
113    #[rtti_field]
114    /// The x coordinate of the curve's control point.
115    pub control_x: f32,
116    #[rtti_field]
117    /// The y coordinate of the curve's control point.
118    pub control_y: f32,
119}
120
121#[repr(C)]
122#[derive(Clone, Debug, PartialEq, derive_more::From)]
123/// PathElement describes a single element on a path, such as move-to, line-to, etc.
124pub enum PathElement {
125    /// The MoveTo variant sets the current position on the path.
126    MoveTo(PathMoveTo),
127    /// The LineTo variant describes a line.
128    LineTo(PathLineTo),
129    /// The PathArcTo variant describes an arc.
130    ArcTo(PathArcTo),
131    /// The CubicTo variant describes a Bézier curve with two control points.
132    CubicTo(PathCubicTo),
133    /// The QuadraticTo variant describes a Bézier curve with one control point.
134    QuadraticTo(PathQuadraticTo),
135    /// Indicates that the path should be closed now by connecting to the starting point.
136    Close,
137}
138
139struct ToLyonPathEventIterator<'a> {
140    events_it: core::slice::Iter<'a, PathEvent>,
141    coordinates_it: core::slice::Iter<'a, lyon_path::math::Point>,
142    first: Option<&'a lyon_path::math::Point>,
143    last: Option<&'a lyon_path::math::Point>,
144}
145
146impl Iterator for ToLyonPathEventIterator<'_> {
147    type Item = lyon_path::Event<lyon_path::math::Point, lyon_path::math::Point>;
148    fn next(&mut self) -> Option<Self::Item> {
149        use lyon_path::Event;
150
151        self.events_it.next().map(|event| match event {
152            PathEvent::Begin => Event::Begin { at: *self.coordinates_it.next().unwrap() },
153            PathEvent::Line => Event::Line {
154                from: *self.coordinates_it.next().unwrap(),
155                to: *self.coordinates_it.next().unwrap(),
156            },
157            PathEvent::Quadratic => Event::Quadratic {
158                from: *self.coordinates_it.next().unwrap(),
159                ctrl: *self.coordinates_it.next().unwrap(),
160                to: *self.coordinates_it.next().unwrap(),
161            },
162            PathEvent::Cubic => Event::Cubic {
163                from: *self.coordinates_it.next().unwrap(),
164                ctrl1: *self.coordinates_it.next().unwrap(),
165                ctrl2: *self.coordinates_it.next().unwrap(),
166                to: *self.coordinates_it.next().unwrap(),
167            },
168            PathEvent::EndOpen => {
169                Event::End { first: *self.first.unwrap(), last: *self.last.unwrap(), close: false }
170            }
171            PathEvent::EndClosed => {
172                Event::End { first: *self.first.unwrap(), last: *self.last.unwrap(), close: true }
173            }
174        })
175    }
176
177    fn size_hint(&self) -> (usize, Option<usize>) {
178        self.events_it.size_hint()
179    }
180}
181
182impl ExactSizeIterator for ToLyonPathEventIterator<'_> {}
183
184struct TransformedLyonPathIterator<EventIt> {
185    it: EventIt,
186    transform: lyon_path::math::Transform,
187}
188
189impl<EventIt: Iterator<Item = lyon_path::Event<lyon_path::math::Point, lyon_path::math::Point>>>
190    Iterator for TransformedLyonPathIterator<EventIt>
191{
192    type Item = lyon_path::Event<lyon_path::math::Point, lyon_path::math::Point>;
193    fn next(&mut self) -> Option<Self::Item> {
194        self.it.next().map(|ev| ev.transformed(&self.transform))
195    }
196
197    fn size_hint(&self) -> (usize, Option<usize>) {
198        self.it.size_hint()
199    }
200}
201
202impl<EventIt: Iterator<Item = lyon_path::Event<lyon_path::math::Point, lyon_path::math::Point>>>
203    ExactSizeIterator for TransformedLyonPathIterator<EventIt>
204{
205}
206
207/// PathDataIterator is a data structure that acts as starting point for iterating
208/// through the low-level events of a path. If the path was constructed from said
209/// events, then it is a very thin abstraction. If the path was created from higher-level
210/// elements, then an intermediate lyon path is required/built.
211pub struct PathDataIterator {
212    it: LyonPathIteratorVariant,
213    transform: lyon_path::math::Transform,
214}
215
216enum LyonPathIteratorVariant {
217    FromPath(lyon_path::Path),
218    FromEvents(crate::SharedVector<PathEvent>, crate::SharedVector<lyon_path::math::Point>),
219}
220
221impl PathDataIterator {
222    /// Create a new iterator for path traversal.
223    #[auto_enum(Iterator)]
224    pub fn iter(
225        &self,
226    ) -> impl Iterator<Item = lyon_path::Event<lyon_path::math::Point, lyon_path::math::Point>> + '_
227    {
228        match &self.it {
229            LyonPathIteratorVariant::FromPath(path) => {
230                TransformedLyonPathIterator { it: path.iter(), transform: self.transform }
231            }
232            LyonPathIteratorVariant::FromEvents(events, coordinates) => {
233                TransformedLyonPathIterator {
234                    it: ToLyonPathEventIterator {
235                        events_it: events.iter(),
236                        coordinates_it: coordinates.iter(),
237                        first: coordinates.first(),
238                        last: coordinates.last(),
239                    },
240                    transform: self.transform,
241                }
242            }
243        }
244    }
245
246    /// Applies a transformation on the elements this iterator provides that tries to fit everything
247    /// into the specified width/height, respecting the provided viewbox. If no viewbox is specified,
248    /// the bounding rectangle of the path is used.
249    pub fn fit(&mut self, width: f32, height: f32, viewbox: Option<lyon_path::math::Box2D>) {
250        if width > 0. || height > 0. {
251            let viewbox =
252                viewbox.unwrap_or_else(|| lyon_algorithms::aabb::bounding_box(self.iter()));
253            self.transform = lyon_algorithms::fit::fit_box(
254                &viewbox,
255                &lyon_path::math::Box2D::from_size(lyon_path::math::Size::new(width, height)),
256                lyon_algorithms::fit::FitStyle::Min,
257            );
258        }
259    }
260}
261
262#[repr(C)]
263#[derive(Clone, Debug, PartialEq)]
264/// PathData represents a path described by either high-level elements or low-level
265/// events and coordinates.
266pub enum PathData {
267    /// None is the variant when the path is empty.
268    None,
269    /// The Elements variant is used to make a Path from shared arrays of elements.
270    Elements(crate::SharedVector<PathElement>),
271    /// The Events variant describes the path as a series of low-level events and
272    /// associated coordinates.
273    Events(crate::SharedVector<PathEvent>, crate::SharedVector<lyon_path::math::Point>),
274    /// The Commands variant describes the path as a series of SVG encoded path commands.
275    Commands(crate::SharedString),
276}
277
278impl Default for PathData {
279    fn default() -> Self {
280        Self::None
281    }
282}
283
284impl PathData {
285    /// This function returns an iterator that allows traversing the path by means of lyon events.
286    pub fn iter(self) -> Option<PathDataIterator> {
287        PathDataIterator {
288            it: match self {
289                PathData::None => return None,
290                PathData::Elements(elements) => LyonPathIteratorVariant::FromPath(
291                    PathData::build_path(elements.as_slice().iter()),
292                ),
293                PathData::Events(events, coordinates) => {
294                    LyonPathIteratorVariant::FromEvents(events, coordinates)
295                }
296                PathData::Commands(commands) => {
297                    let mut builder = lyon_path::Path::builder();
298                    let mut parser = lyon_extra::parser::PathParser::new();
299                    match parser.parse(
300                        &lyon_extra::parser::ParserOptions::DEFAULT,
301                        &mut lyon_extra::parser::Source::new(commands.chars()),
302                        &mut builder,
303                    ) {
304                        Ok(()) => LyonPathIteratorVariant::FromPath(builder.build()),
305                        Err(e) => {
306                            debug_log!("Error while parsing path commands '{commands}': {e:?}");
307                            LyonPathIteratorVariant::FromPath(Default::default())
308                        }
309                    }
310                }
311            },
312            transform: Default::default(),
313        }
314        .into()
315    }
316
317    fn build_path(element_it: core::slice::Iter<PathElement>) -> lyon_path::Path {
318        use lyon_geom::SvgArc;
319        use lyon_path::ArcFlags;
320        use lyon_path::math::{Angle, Point, Vector};
321        use lyon_path::traits::SvgPathBuilder;
322
323        let mut path_builder = lyon_path::Path::builder().with_svg();
324        for element in element_it {
325            match element {
326                PathElement::MoveTo(PathMoveTo { x, y }) => {
327                    path_builder.move_to(Point::new(*x, *y));
328                }
329                PathElement::LineTo(PathLineTo { x, y }) => {
330                    path_builder.line_to(Point::new(*x, *y));
331                }
332                PathElement::ArcTo(PathArcTo {
333                    x,
334                    y,
335                    radius_x,
336                    radius_y,
337                    x_rotation,
338                    large_arc,
339                    sweep,
340                }) => {
341                    let radii = Vector::new(*radius_x, *radius_y);
342                    let x_rotation = Angle::degrees(*x_rotation);
343                    let flags = ArcFlags { large_arc: *large_arc, sweep: *sweep };
344                    let to = Point::new(*x, *y);
345
346                    let svg_arc = SvgArc {
347                        from: path_builder.current_position(),
348                        radii,
349                        x_rotation,
350                        flags,
351                        to,
352                    };
353
354                    if svg_arc.is_straight_line() {
355                        path_builder.line_to(to);
356                    } else {
357                        path_builder.arc_to(radii, x_rotation, flags, to)
358                    }
359                }
360                PathElement::CubicTo(PathCubicTo {
361                    x,
362                    y,
363                    control_1_x,
364                    control_1_y,
365                    control_2_x,
366                    control_2_y,
367                }) => {
368                    path_builder.cubic_bezier_to(
369                        Point::new(*control_1_x, *control_1_y),
370                        Point::new(*control_2_x, *control_2_y),
371                        Point::new(*x, *y),
372                    );
373                }
374                PathElement::QuadraticTo(PathQuadraticTo { x, y, control_x, control_y }) => {
375                    path_builder.quadratic_bezier_to(
376                        Point::new(*control_x, *control_y),
377                        Point::new(*x, *y),
378                    );
379                }
380                PathElement::Close => path_builder.close(),
381            }
382        }
383
384        path_builder.build()
385    }
386}
387
388#[cfg(not(target_arch = "wasm32"))]
389pub(crate) mod ffi {
390    #![allow(unsafe_code)]
391
392    use super::super::*;
393    use super::*;
394
395    #[allow(non_camel_case_types)]
396    type c_void = ();
397
398    #[unsafe(no_mangle)]
399    /// This function is used for the low-level C++ interface to allocate the backing vector for a shared path element array.
400    pub unsafe extern "C" fn slint_new_path_elements(
401        out: *mut c_void,
402        first_element: *const PathElement,
403        count: usize,
404    ) {
405        let arr =
406            crate::SharedVector::from(unsafe { core::slice::from_raw_parts(first_element, count) });
407        unsafe { core::ptr::write(out as *mut crate::SharedVector<PathElement>, arr) };
408    }
409
410    #[unsafe(no_mangle)]
411    /// This function is used for the low-level C++ interface to allocate the backing vector for a shared path event array.
412    pub unsafe extern "C" fn slint_new_path_events(
413        out_events: *mut c_void,
414        out_coordinates: *mut c_void,
415        first_event: *const PathEvent,
416        event_count: usize,
417        first_coordinate: *const Point,
418        coordinate_count: usize,
419    ) {
420        let events = crate::SharedVector::from(unsafe {
421            core::slice::from_raw_parts(first_event, event_count)
422        });
423        unsafe { core::ptr::write(out_events as *mut crate::SharedVector<PathEvent>, events) };
424        let coordinates = crate::SharedVector::from(unsafe {
425            core::slice::from_raw_parts(first_coordinate, coordinate_count)
426        });
427        unsafe {
428            core::ptr::write(out_coordinates as *mut crate::SharedVector<Point>, coordinates)
429        };
430    }
431}
i_slint_core/graphics/path.rs

i_slint_core/graphics/
path.rs
