rgx 0.9.0

A 2D graphics toolkit for rust
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

use crate::ui::*;

/// A type of widget that implements a "control".
pub trait Controller<T, W: Widget<T>> {
    /// Analogous to [`Widget::event`].
    fn event(
        &mut self,
        child: &mut W,
        event: &WidgetEvent,
        ctx: &Context<'_>,
        data: &mut T,
    ) -> ControlFlow<()> {
        child.event(event, ctx, data)
    }

    /// Analogous to [`Widget::lifecycle`].
    fn lifecycle(
        &mut self,
        child: &mut W,
        lifecycle: &WidgetLifecycle<'_>,
        ctx: &Context<'_>,
        data: &T,
        env: &Env,
    ) {
        child.lifecycle(lifecycle, ctx, data, env)
    }

    /// Analogous to [`Widget::update`].
    fn update(&mut self, child: &mut W, ctx: &Context<'_>, data: &T) {
        child.update(ctx, data)
    }

    /// Analogous to [`Widget::frame`].
    fn frame(&mut self, child: &mut W, surfaces: &Surfaces, data: &mut T) {
        child.frame(surfaces, data)
    }
}

/// A [`Widget`] that manages a child and a [`Controller`].
pub struct Control<W, C> {
    widget: W,
    controller: C,
}

impl<W, C> Control<W, C> {
    pub fn new(widget: W, controller: C) -> Control<W, C> {
        Control { widget, controller }
    }
}

impl<T, W: Widget<T>, C: Controller<T, W>> Widget<T> for Control<W, C> {
    fn layout(&mut self, parent: Size, ctx: &LayoutCtx<'_>, data: &T, env: &Env) -> Size {
        self.widget.layout(parent, ctx, data, env)
    }

    fn paint(&mut self, canvas: Canvas<'_>, data: &T) {
        self.widget.paint(canvas, data)
    }

    fn contains(&self, point: Point) -> bool {
        self.widget.contains(point)
    }

    fn update(&mut self, ctx: &Context<'_>, data: &T) {
        self.controller.update(&mut self.widget, ctx, data)
    }

    fn event(&mut self, event: &WidgetEvent, ctx: &Context<'_>, data: &mut T) -> ControlFlow<()> {
        self.controller.event(&mut self.widget, event, ctx, data)
    }

    fn lifecycle(
        &mut self,
        lifecycle: &WidgetLifecycle<'_>,
        ctx: &Context<'_>,
        data: &T,
        env: &Env,
    ) {
        self.controller
            .lifecycle(&mut self.widget, lifecycle, ctx, data, env)
    }

    fn frame(&mut self, surfaces: &Surfaces, data: &mut T) {
        self.controller.frame(&mut self.widget, surfaces, data)
    }

    fn display(&self) -> String {
        format!("Control({})", self.widget.display())
    }
}