hydrolysis-m3 0.3.0

Material 3 widget theme for WaterUI self-drawn backends
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

use vello::kurbo::RoundedRectRadii;
use waterui::color::Color;
use waterui::reactive::{Computed, SignalExt as _, signal::IntoComputed, zip};
use waterui::{Environment, Signal as _, Str};
use waterui_backend_core::widget::{ButtonMetrics, InteractionStyle};
use waterui_controls::label::Label;
use waterui_core::resolve::Resolvable;
use waterui_graphics::color::ResolvedColor;

pub fn label_plain_text(label: &Label) -> Str {
    label
        .semantic_text()
        .clone()
        .resolve(&Environment::new())
        .content
        .get()
        .to_plain()
}

pub fn interaction_style(
    state_layer_color: impl Into<Color>,
    corner_radius: f64,
) -> InteractionStyle {
    InteractionStyle::new(
        ButtonMetrics::new(0.0, 0.0, 0.0, 0.0),
        state_layer_color,
        RoundedRectRadii::from(corner_radius),
    )
}

pub fn interaction_style_with_radii(
    state_layer_color: impl Into<Color>,
    radii: RoundedRectRadii,
) -> InteractionStyle {
    InteractionStyle::new(
        ButtonMetrics::new(0.0, 0.0, 0.0, 0.0),
        state_layer_color,
        radii,
    )
}

pub fn conditional_color(
    condition: impl IntoComputed<bool>,
    when_true: impl Into<Color>,
    when_false: impl Into<Color>,
) -> ConditionalColor {
    ConditionalColor {
        condition: condition.into_computed(),
        when_true: when_true.into(),
        when_false: when_false.into(),
    }
}

#[derive(Debug, Clone)]
pub struct ConditionalColor {
    condition: Computed<bool>,
    when_true: Color,
    when_false: Color,
}

impl Resolvable for ConditionalColor {
    type Resolved = ResolvedColor;

    fn resolve(&self, env: &Environment) -> impl waterui::Signal<Output = Self::Resolved> {
        zip::zip(
            zip::zip(self.condition.clone(), self.when_true.resolve(env)),
            self.when_false.resolve(env),
        )
        .map(
            |((condition, when_true), when_false)| {
                if condition { when_true } else { when_false }
            },
        )
    }
}