kael_ui 0.2.0

Professional shadcn-inspired UI component library for Kael. 100+ accessible components for building beautiful, performant desktop applications.
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

//! Direct Kael painting surface with Styled support.

use kael::{prelude::FluentBuilder as _, *};
use std::rc::Rc;

type PaintCallback = Rc<dyn Fn(Bounds<Pixels>, &mut Window, &mut App)>;
type PrepareCallback = Rc<dyn Fn(Bounds<Pixels>, &mut Window, &mut App)>;

#[derive(IntoElement)]
pub struct CanvasComponent {
    id: ElementId,
    on_paint: Option<PaintCallback>,
    on_prepare: Option<PrepareCallback>,
    style: StyleRefinement,
}

impl CanvasComponent {
    pub fn new(id: impl Into<ElementId>) -> Self {
        Self {
            id: id.into(),
            on_paint: None,
            on_prepare: None,
            style: StyleRefinement::default(),
        }
    }

    pub fn on_paint(
        mut self,
        callback: impl Fn(Bounds<Pixels>, &mut Window, &mut App) + 'static,
    ) -> Self {
        self.on_paint = Some(Rc::new(callback));
        self
    }

    pub fn on_prepare(
        mut self,
        callback: impl Fn(Bounds<Pixels>, &mut Window, &mut App) + 'static,
    ) -> Self {
        self.on_prepare = Some(Rc::new(callback));
        self
    }
}

impl Styled for CanvasComponent {
    fn style(&mut self) -> &mut StyleRefinement {
        &mut self.style
    }
}

impl RenderOnce for CanvasComponent {
    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
        let user_style = self.style;
        let paint_cb = self.on_paint;
        let prepare_cb = self.on_prepare;

        div()
            .id(self.id)
            .relative()
            .child(
                canvas_with_prepaint(
                    move |bounds, window, cx| {
                        if let Some(ref cb) = prepare_cb {
                            cb(bounds, window, cx);
                        }
                    },
                    move |bounds, _, window, cx| {
                        if let Some(ref cb) = paint_cb {
                            cb(bounds, window, cx);
                        }
                    },
                )
                .absolute()
                .inset_0()
                .size_full(),
            )
            .map(|this| {
                let mut el = this;
                el.style().refine(&user_style);
                el
            })
    }
}