ezui 0.0.2

An eazy to use small GUI library. main purpose of this crate is to help you to make GUI for VST audio plugins.
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
91
92

use glium::backend::glutin_backend;

#[derive(Default, Clone, Copy, Debug, PartialEq)]
pub struct MouseStatus {
    position: (f32, f32),
    delta_position: (f32, f32),
    button: MouseButtonStatus,
}

impl MouseStatus {
    pub fn update(&mut self, target: &glium::Frame, events: glutin_backend::PollEventsIter) {
        use glium::Surface;
        use glutin_backend::glutin::Event::*;

        self.delta_position = (0.0, 0.0);

        events.for_each(|ev| match ev {
            MouseMoved(x, y) => {
                let (w, h) = target.get_dimensions();
                let (w, h) = (w as f32, h as f32);
                let (x, y) = (x as f32, y as f32);
                let (x, y) = (x / w, y / h);
                self.delta_position = (x - self.position.0, y - self.position.1);
                self.position = (x, y);
            }
            MouseInput(state, button) => self.button.update(state, button, self.position),
            _ => (),
        });
    }
    pub fn position(&self) -> (f32, f32) {
        self.position
    }
    pub fn delta_position(&self) -> (f32, f32) {
        self.delta_position
    }
    pub fn button(&self) -> MouseButtonStatus {
        self.button
    }
}

#[derive(Default, Clone, Copy, Debug, PartialEq)]
pub struct MouseButtonStatus {
    left: ButtonState,
    right: ButtonState,
    middle: ButtonState,
}

impl MouseButtonStatus {
    fn update(
        &mut self,
        state: winit::ElementState,
        button: winit::MouseButton,
        position: (f32, f32),
    ) {
        use winit::ElementState;
        use winit::MouseButton;

        let state = match state {
            ElementState::Pressed => ButtonState::Pressed(position.0, position.1),
            ElementState::Released => ButtonState::Released,
        };

        match button {
            MouseButton::Left => self.left = state,
            MouseButton::Right => self.right = state,
            MouseButton::Middle => self.middle = state,
            _ => (),
        }
    }

    pub fn left(&self) -> ButtonState {
        self.left
    }
    pub fn middle(&self) -> ButtonState {
        self.middle
    }
    pub fn right(&self) -> ButtonState {
        self.right
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ButtonState {
    Pressed(f32, f32),
    Released,
}

impl Default for ButtonState {
    fn default() -> Self {
        ButtonState::Released
    }
}