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
use crate::{
core::{
pool::Handle,
math::{
vec2::Vec2,
Rect,
},
},
UINode,
widget::{
Widget,
WidgetBuilder,
},
Control,
message::UiMessage,
BuildContext,
UserInterface
};
use std::ops::{Deref, DerefMut};
pub struct Canvas<M: 'static, C: 'static + Control<M, C>> {
widget: Widget<M, C>,
}
impl<M: 'static, C: 'static + Control<M, C>> Deref for Canvas<M, C> {
type Target = Widget<M, C>;
fn deref(&self) -> &Self::Target {
&self.widget
}
}
impl<M: 'static, C: 'static + Control<M, C>> DerefMut for Canvas<M, C> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.widget
}
}
impl<M: 'static, C: 'static + Control<M, C>> Control<M, C> for Canvas<M, C> {
fn raw_copy(&self) -> UINode<M, C> {
UINode::Canvas(Self {
widget: self.widget.raw_copy()
})
}
fn measure_override(&self, ui: &UserInterface<M, C>, _available_size: Vec2) -> Vec2 {
let size_for_child = Vec2::new(
std::f32::INFINITY,
std::f32::INFINITY,
);
for child_handle in self.widget.children() {
ui.node(*child_handle).measure(ui, size_for_child);
}
Vec2::ZERO
}
fn arrange_override(&self, ui: &UserInterface<M, C>, final_size: Vec2) -> Vec2 {
for child_handle in self.widget.children() {
let child = ui.nodes.borrow(*child_handle);
child.arrange(ui, &Rect::new(
child.desired_local_position().x,
child.desired_local_position().y,
child.desired_size().x,
child.desired_size().y));
}
final_size
}
fn handle_routed_message(&mut self, ui: &mut UserInterface<M, C>, message: &mut UiMessage<M, C>) {
self.widget.handle_routed_message(ui, message);
}
}
impl<M: 'static, C: 'static + Control<M, C>> Canvas<M, C> {
pub fn new(widget: Widget<M, C>) -> Self {
Self {
widget
}
}
}
pub struct CanvasBuilder<M: 'static, C: 'static + Control<M, C>> {
widget_builder: WidgetBuilder<M, C>,
}
impl<M: 'static, C: 'static + Control<M, C>> CanvasBuilder<M, C> {
pub fn new(widget_builder: WidgetBuilder<M, C>) -> Self {
Self {
widget_builder,
}
}
pub fn build(self, ui: &mut BuildContext<M, C>) -> Handle<UINode<M, C>> {
let canvas = Canvas {
widget: self.widget_builder.build()
};
ui.add_node(UINode::Canvas(canvas))
}
}