gazpatcho 1.1.0

Simple node-based graph editor for Rust. Register nodes, let the user mingle with them, read the result.
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

extern crate imgui;

use crate::vec2;

const HORIZONTAL_MARGIN: f32 = 10.0;
const HEIGHT: f32 = 20.0;
const MIN_WIDTH: f32 = 100.0;

pub struct Slider {
    id: imgui::ImString,
    position: [f32; 2],
    min: f32,
    max: f32,
    value: f32,
    min_width: f32,
    display_format: imgui::ImString,
    value_callback: Option<Box<dyn FnOnce(f32)>>,
}

impl Slider {
    pub fn new(id: imgui::ImString, min: f32, max: f32, value: f32) -> Self {
        let id = imgui::ImString::from(format!("##{}", id));
        Self {
            id,
            position: [0.0, 0.0],
            min,
            max,
            value,
            min_width: MIN_WIDTH,
            display_format: imgui::ImString::new("%.3f"),
            value_callback: None,
        }
    }

    pub fn position(mut self, position: [f32; 2]) -> Self {
        self.position = position;
        self
    }

    pub fn min_width(mut self, min_width: f32) -> Self {
        self.min_width = min_width;
        self
    }

    pub fn display_format(mut self, display_format: imgui::ImString) -> Self {
        self.display_format = display_format;
        self
    }

    pub fn value_callback(mut self, value_callback: Box<dyn FnOnce(f32)>) -> Self {
        self.value_callback = Some(value_callback);
        self
    }

    pub fn get_min_width(&self) -> f32 {
        self.min_width + 2.0 * HORIZONTAL_MARGIN
    }

    pub fn get_height(&self) -> f32 {
        HEIGHT
    }

    pub fn build(mut self, ui: &imgui::Ui, width: f32) {
        ui.set_cursor_screen_pos(vec2::sum(&[self.position, [HORIZONTAL_MARGIN, 0.0]]));
        ui.push_item_width(width - 2.0 * HORIZONTAL_MARGIN);
        imgui::Slider::new(&self.id)
            .range(-self.min..=self.max)
            .display_format(&self.display_format)
            .build(ui, &mut self.value);

        if let Some(value_callback) = self.value_callback {
            value_callback(self.value);
        }
    }
}