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
131
132
133
134
135
136
use {
Backend,
Color,
Colorable,
PointPath,
Positionable,
Scalar,
Sizeable,
Widget,
};
use num;
use utils;
use widget;
pub struct PlotPath<X, Y, F> {
common: widget::CommonBuilder,
style: Style,
min_x: X,
max_x: X,
min_y: Y,
max_y: Y,
f: F,
}
pub const KIND: widget::Kind = "PlotPath";
widget_style!{
KIND;
style Style {
- thickness: Scalar { 1.0 }
- color: Color { theme.shape_color }
}
}
#[derive(Debug, PartialEq)]
pub struct State {
point_path_idx: widget::IndexSlot,
}
impl<X, Y, F> PlotPath<X, Y, F> {
pub fn new(min_x: X, max_x: X, min_y: Y, max_y: Y, f: F) -> Self {
PlotPath {
common: widget::CommonBuilder::new(),
style: Style::new(),
min_x: min_x,
max_x: max_x,
min_y: min_y,
max_y: max_y,
f: f,
}
}
}
impl<X, Y, F> Widget for PlotPath<X, Y, F>
where X: num::NumCast + Clone,
Y: num::NumCast + Clone,
F: FnMut(X) -> Y,
{
type State = State;
type Style = Style;
fn common(&self) -> &widget::CommonBuilder {
&self.common
}
fn common_mut(&mut self) -> &mut widget::CommonBuilder {
&mut self.common
}
fn unique_kind(&self) -> widget::Kind {
KIND
}
fn init_state(&self) -> Self::State {
State {
point_path_idx: widget::IndexSlot::new(),
}
}
fn style(&self) -> Self::Style {
self.style.clone()
}
fn update<B: Backend>(self, args: widget::UpdateArgs<Self, B>) {
let widget::UpdateArgs { idx, state, style, rect, mut ui, .. } = args;
let PlotPath { min_x, max_x, min_y, max_y, mut f, .. } = self;
let y_to_scalar =
|y| utils::map_range(y, min_y.clone(), max_y.clone(), rect.bottom(), rect.top());
let scalar_to_x =
|s| utils::map_range(s, rect.left(), rect.right(), min_x.clone(), max_x.clone());
let point_iter = (0 .. rect.w() as usize)
.map(|x_scalar| {
let x_scalar = x_scalar as Scalar + rect.x.start;
let x = scalar_to_x(x_scalar);
let y = f(x);
let y_scalar = y_to_scalar(y);
[x_scalar, y_scalar]
});
let point_path_idx = state.point_path_idx.get(&mut ui);
let thickness = style.thickness(ui.theme());
let color = style.color(ui.theme());
PointPath::new(point_iter)
.wh(rect.dim())
.xy(rect.xy())
.color(color)
.thickness(thickness)
.parent(idx)
.graphics_for(idx)
.set(point_path_idx, &mut ui);
}
}
impl<X, Y, F> Colorable for PlotPath<X, Y, F> {
builder_method!(color { style.color = Some(Color) });
}