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
|
use crate::{input::mouse, Column, Element, Event, Layout, MouseCursor, Point};
use std::hash::Hasher;
use stretch::result;
/// A set of interactive graphical elements with a specific layout.
pub struct UserInterface<'a, Message, Renderer> {
hash: u64,
root: Element<'a, Message, Renderer>,
layout: result::Layout,
cursor_position: Point,
}
impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
pub fn build(
root: Element<'a, Message, Renderer>,
renderer: &Renderer,
cache: Cache,
) -> Self {
let hasher = &mut crate::Hasher::default();
root.hash(hasher);
let hash = hasher.finish();
let layout = if hash == cache.hash {
cache.layout
} else {
root.compute_layout(renderer)
};
UserInterface {
hash,
root,
layout,
cursor_position: cache.cursor_position,
}
}
pub fn update(
&mut self,
events: impl Iterator<Item = Event>,
) -> Vec<Message> {
let mut messages = Vec::new();
for event in events {
match event {
Event::Mouse(mouse::Event::CursorMoved { x, y }) => {
self.cursor_position = Point::new(x, y);
}
_ => {}
}
self.root.widget.on_event(
event,
Layout::new(&self.layout),
self.cursor_position,
&mut messages,
);
}
messages
}
pub fn draw(&self, renderer: &mut Renderer) -> MouseCursor {
let cursor = self.root.widget.draw(
renderer,
Layout::new(&self.layout),
self.cursor_position,
);
cursor
}
pub fn into_cache(self) -> Cache {
Cache {
hash: self.hash,
layout: self.layout,
cursor_position: self.cursor_position,
}
}
}
#[derive(Debug, Clone)]
pub struct Cache {
hash: u64,
layout: result::Layout,
cursor_position: Point,
}
impl Cache {
pub fn new() -> Cache {
let root: Element<'_, (), ()> = Column::new().into();
let hasher = &mut crate::Hasher::default();
root.hash(hasher);
Cache {
hash: hasher.finish(),
layout: root.compute_layout(&()),
cursor_position: Point::new(0.0, 0.0),
}
}
}
impl Default for Cache {
fn default() -> Cache {
Cache::new()
}
}
impl PartialEq for Cache {
fn eq(&self, other: &Cache) -> bool {
self.hash == other.hash && self.cursor_position == other.cursor_position
}
}
impl Eq for Cache {}
|
