sequoia-draw 0.1.1

Sequoia GUI framework — vector paths and rasterization
Documentation 
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

#![forbid(unsafe_code)]

use sequoia_core::{Color, Quad, Rect};

mod cache;
mod flatten;
mod gradient;
mod path;
mod raster;
mod stroke;
mod svg_path;
mod transform;
mod waveform;

pub use cache::{DEFAULT_CAPACITY, Shape, ShapeCache, ShapeStats};
pub use flatten::{Contour, flatten};
pub use gradient::{Gradient, GradientStop};
pub use path::{FillRule, Path, PathError, PathSeg, Radius};
pub use raster::{FillStyle, RasterOptions, fill, fill_contours, fill_styled};
pub use stroke::{Dash, LineCap, LineJoin, StrokeStyle, stroke, stroke_path};
pub use transform::Transform;
pub use waveform::{
    MinMax, Peaks, WaveformCache, WaveformOpts, bake_strip, layout_bars, waveform_line_points,
    white_noise,
};

pub const TOLERANCE: f32 = 0.25;

pub const DEFAULT_OPTIONS: RasterOptions = RasterOptions {
    tolerance: TOLERANCE,
    row_height: 1.0,
    merge_tol: 0.35,
    aa_samples: 4,
    analytic: true,
};

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Span {
    pub rect: Rect,

    pub radius: f32,

    pub alpha: f32,
}

impl Span {
    pub fn rect(rect: Rect) -> Self {
        Self {
            rect,
            radius: 0.0,
            alpha: 1.0,
        }
    }

    pub fn rounded(rect: Rect, radius: f32) -> Self {
        Self {
            rect,
            radius,
            alpha: 1.0,
        }
    }

    pub fn solid(rect: Rect) -> Self {
        Self::rect(rect)
    }

    pub fn edge(rect: Rect, coverage: f32) -> Self {
        Self::rect(rect).with_alpha(coverage)
    }

    #[must_use]
    pub fn with_alpha(mut self, alpha: f32) -> Self {
        self.alpha = alpha.clamp(0.0, 1.0);
        self
    }

    pub fn quad(self, color: Color) -> Quad {
        Quad {
            rect: self.rect,
            color: Color {
                a: color.a * self.alpha,
                ..color
            },
            radius: self.radius,
            border_color: Color::TRANSPARENT,
            border_width: 0.0,
        }
    }

    pub fn is_visible(&self) -> bool {
        !self.rect.is_empty() && self.alpha > 0.0
    }
}

pub(crate) fn union_rect(a: Rect, b: Rect) -> Rect {
    if a.is_empty() {
        return b;
    }
    if b.is_empty() {
        return a;
    }
    let x0 = a.left().min(b.left());
    let y0 = a.top().min(b.top());
    let x1 = a.right().max(b.right());
    let y1 = a.bottom().max(b.bottom());
    Rect::from_xywh(x0, y0, x1 - x0, y1 - y0)
}