kael 0.1.2

GPU-accelerated native UI framework for Rust — build desktop apps with Metal, DirectX, and Vulkan rendering
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
128
129
130

use refineable::Refineable as _;

use crate::{
    App, Bounds, Element, ElementId, GlobalElementId, InspectorElementId, IntoElement, Pixels,
    Style, StyleRefinement, Styled, Window,
};

/// Hidden trait backing the overloaded [`canvas`] helper.
#[doc(hidden)]
pub trait CanvasConstructor<Arg2> {
    /// The canvas type produced by the constructor.
    type Output;

    /// Construct a canvas element from the given arguments.
    fn into_canvas(self, arg2: Arg2) -> Self::Output;
}

/// Construct a canvas element.
///
/// This helper supports two forms:
///
/// - `canvas(prepaint, paint)` keeps the legacy low-level API that passes bounds through a
///   prepaint phase before painting.
/// - `canvas(size, draw)` creates an immediate-mode canvas powered by [`crate::DrawContext`].
pub fn canvas<Arg1, Arg2>(arg1: Arg1, arg2: Arg2) -> <Arg1 as CanvasConstructor<Arg2>>::Output
where
    Arg1: CanvasConstructor<Arg2>,
{
    arg1.into_canvas(arg2)
}

fn canvas_with_prepaint<T>(
    prepaint: impl 'static + for<'a, 'b> FnOnce(Bounds<Pixels>, &'a mut Window, &'b mut App) -> T,
    paint: impl 'static + for<'a, 'b> FnOnce(Bounds<Pixels>, T, &'a mut Window, &'b mut App),
) -> Canvas<T> {
    Canvas {
        prepaint: Some(Box::new(prepaint)),
        paint: Some(Box::new(paint)),
        style: StyleRefinement::default(),
    }
}

/// A canvas element, meant for accessing the low level paint API without defining a whole
/// custom element
pub struct Canvas<T> {
    prepaint: Option<Box<dyn for<'a, 'b> FnOnce(Bounds<Pixels>, &'a mut Window, &'b mut App) -> T>>,
    paint: Option<Box<dyn for<'a, 'b> FnOnce(Bounds<Pixels>, T, &'a mut Window, &'b mut App)>>,
    style: StyleRefinement,
}

impl<T, FPrepaint, FPaint> CanvasConstructor<FPaint> for FPrepaint
where
    T: 'static,
    FPrepaint: 'static + for<'a, 'b> FnOnce(Bounds<Pixels>, &'a mut Window, &'b mut App) -> T,
    FPaint: 'static + for<'a, 'b> FnOnce(Bounds<Pixels>, T, &'a mut Window, &'b mut App),
{
    type Output = Canvas<T>;

    fn into_canvas(self, paint: FPaint) -> Self::Output {
        canvas_with_prepaint(self, paint)
    }
}

impl<T: 'static> IntoElement for Canvas<T> {
    type Element = Self;

    fn into_element(self) -> Self::Element {
        self
    }
}

impl<T: 'static> Element for Canvas<T> {
    type RequestLayoutState = Style;
    type PrepaintState = Option<T>;

    fn id(&self) -> Option<ElementId> {
        None
    }

    fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
        None
    }

    fn request_layout(
        &mut self,
        _id: Option<&GlobalElementId>,
        _inspector_id: Option<&InspectorElementId>,
        window: &mut Window,
        cx: &mut App,
    ) -> (crate::LayoutId, Self::RequestLayoutState) {
        let mut style = Style::default();
        style.refine(&self.style);
        let layout_id = window.request_layout(style.clone(), [], cx);
        (layout_id, style)
    }

    fn prepaint(
        &mut self,
        _id: Option<&GlobalElementId>,
        _inspector_id: Option<&InspectorElementId>,
        bounds: Bounds<Pixels>,
        _request_layout: &mut Style,
        window: &mut Window,
        cx: &mut App,
    ) -> Option<T> {
        Some(self.prepaint.take().unwrap()(bounds, window, cx))
    }

    fn paint(
        &mut self,
        _id: Option<&GlobalElementId>,
        _inspector_id: Option<&InspectorElementId>,
        bounds: Bounds<Pixels>,
        style: &mut Style,
        prepaint: &mut Self::PrepaintState,
        window: &mut Window,
        cx: &mut App,
    ) {
        let prepaint = prepaint.take().unwrap();
        style.paint(bounds, window, cx, |window, cx| {
            (self.paint.take().unwrap())(bounds, prepaint, window, cx)
        });
    }
}

impl<T> Styled for Canvas<T> {
    fn style(&mut self) -> &mut crate::StyleRefinement {
        &mut self.style
    }
}