open-gpui-canvas 0.2.0

Extensible infinite canvas model and interaction primitives for Open GPUI.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use super::model::{CanvasPaintModel, CanvasPaintTheme};
use crate::{CanvasEdge, CanvasKindPaint, CanvasNode, CanvasShape, CanvasStyle};
use open_gpui::{Hsla, Pixels};

#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct CanvasResolvedPaintStyle {
    pub(super) fill: Hsla,
    pub(super) stroke: Hsla,
    pub(super) stroke_width: Pixels,
    pub(super) corner_radius: Pixels,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct CanvasResolvedEdgePaintStyle {
    pub(super) stroke: Hsla,
    pub(super) stroke_width: Pixels,
}

pub(super) fn node_paint_style(
    model: &CanvasPaintModel,
    node: &CanvasNode,
    theme: CanvasPaintTheme,
) -> CanvasResolvedPaintStyle {
    record_paint_style(
        &node.style,
        model.kind_registry.node_paint(node).as_ref(),
        CanvasResolvedPaintStyle {
            fill: theme.node_fill,
            stroke: theme.node_stroke,
            stroke_width: theme.node_stroke_width,
            corner_radius: theme.node_corner_radius,
        },
    )
}

pub(super) fn shape_paint_style(
    model: &CanvasPaintModel,
    shape: &CanvasShape,
    theme: CanvasPaintTheme,
) -> CanvasResolvedPaintStyle {
    record_paint_style(
        &shape.style,
        model.kind_registry.shape_paint(shape).as_ref(),
        CanvasResolvedPaintStyle {
            fill: theme.shape_fill,
            stroke: theme.shape_stroke,
            stroke_width: theme.shape_stroke_width,
            corner_radius: Pixels::ZERO,
        },
    )
}

pub(super) fn edge_paint_style(
    model: &CanvasPaintModel,
    edge: &CanvasEdge,
    theme: CanvasPaintTheme,
) -> CanvasResolvedEdgePaintStyle {
    let fallback = model.kind_registry.edge_paint(edge);
    CanvasResolvedEdgePaintStyle {
        stroke: paint_color(
            &edge.style.stroke,
            fallback.as_ref().and_then(|paint| paint.stroke.as_deref()),
            theme.edge_stroke,
        ),
        stroke_width: paint_pixels(
            edge.style.stroke_width,
            fallback.as_ref().and_then(|paint| paint.stroke_width),
            theme.edge_stroke_width,
        ),
    }
}

fn record_paint_style(
    style: &CanvasStyle,
    fallback: Option<&CanvasKindPaint>,
    theme: CanvasResolvedPaintStyle,
) -> CanvasResolvedPaintStyle {
    CanvasResolvedPaintStyle {
        fill: paint_color(
            &style.fill,
            fallback.and_then(|paint| paint.fill.as_deref()),
            theme.fill,
        ),
        stroke: paint_color(
            &style.stroke,
            fallback.and_then(|paint| paint.stroke.as_deref()),
            theme.stroke,
        ),
        stroke_width: paint_pixels(
            style.stroke_width,
            fallback.and_then(|paint| paint.stroke_width),
            theme.stroke_width,
        ),
        corner_radius: fallback
            .and_then(|paint| paint.corner_radius)
            .filter(|value| positive_pixels(*value))
            .unwrap_or(theme.corner_radius),
    }
}

pub(super) fn positive_pixels(value: Pixels) -> bool {
    value > Pixels::ZERO && value.as_f32().is_finite()
}

fn paint_pixels(value: Pixels, fallback: Option<Pixels>, theme: Pixels) -> Pixels {
    if positive_pixels(value) {
        value
    } else {
        fallback
            .filter(|value| positive_pixels(*value))
            .unwrap_or(theme)
    }
}

fn paint_color(value: &Option<String>, fallback: Option<&str>, theme: Hsla) -> Hsla {
    style_color(value)
        .or_else(|| fallback.and_then(parse_color))
        .unwrap_or(theme)
}

pub(super) fn style_color(value: &Option<String>) -> Option<Hsla> {
    value.as_deref().and_then(parse_color)
}

pub(super) fn parse_color(value: &str) -> Option<Hsla> {
    open_gpui::Rgba::try_from(value).ok().map(Hsla::from)
}