narui_core 0.1.2

unwrapped core crate of the narui gui framework
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
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

use crate::{
    eval::layout::{LayoutTree, Layouter},
    geom::{Rect, Vec2},
    CallbackContext,
    Key,
    RenderObject,
};
use freelist::Idx;
use hashbrown::HashMap;
use winit::event::{ElementState, MouseButton, WindowEvent};

#[derive(Default)]
pub struct InputState {
    clicked: bool,
    hover: bool,
}

#[derive(Default)]
pub struct InputHandler {
    cursor_position: Vec2,
    cursor_moved: bool,

    cursor_pressed: bool,
    cursor_released: bool,

    input_states: HashMap<Key, InputState, ahash::RandomState>,
}
impl InputHandler {
    pub fn new() -> Self { Default::default() }
    pub fn enqueue_input(&mut self, event: WindowEvent) -> bool {
        match event {
            WindowEvent::CursorMoved { position, .. } => {
                self.cursor_position = position.into();
                self.cursor_moved = true;
                true
            }
            WindowEvent::MouseInput {
                state: ElementState::Pressed,
                button: MouseButton::Left,
                ..
            } => {
                self.cursor_pressed = true;
                true
            }
            WindowEvent::MouseInput {
                state: ElementState::Released,
                button: MouseButton::Left,
                ..
            } => {
                self.cursor_released = true;
                true
            }
            _ => false,
        }
    }
    pub fn handle_input(
        &mut self,
        input_render_object: &[(Idx, Option<Rect>)],
        layouter: &Layouter,
        context: CallbackContext,
    ) -> bool {
        if !self.cursor_moved && !self.cursor_pressed && !self.cursor_released {
            return false;
        }

        let mut updated = false;
        for (key, clipping_rect) in input_render_object {
            let (rect, obj) = layouter.get_positioned(*key);
            let rect = if let Some(clipping_rect) = clipping_rect {
                rect.clip(*clipping_rect)
            } else {
                rect
            };
            if let Some(RenderObject::Input { key, on_hover, on_move, on_click }) = obj {
                let input_state = self.input_states.entry(*key).or_insert(Default::default());
                if self.cursor_moved {
                    let is_hover = rect.contains(self.cursor_position);
                    if input_state.hover != is_hover {
                        on_hover(
                            &context,
                            is_hover,
                            self.cursor_position - rect.pos,
                            self.cursor_position,
                        );
                        input_state.hover = is_hover;
                        updated = true;
                    }
                    if input_state.clicked || is_hover {
                        on_move(&context, self.cursor_position - rect.pos, self.cursor_position);
                        updated = true;
                    }
                }
                if self.cursor_pressed && rect.contains(self.cursor_position) {
                    input_state.clicked = true;
                    on_click(&context, true, self.cursor_position - rect.pos, self.cursor_position);
                    updated = true;
                }
                if self.cursor_released
                    && (input_state.clicked || rect.contains(self.cursor_position))
                {
                    input_state.clicked = false;
                    on_click(
                        &context,
                        false,
                        self.cursor_position - rect.pos,
                        self.cursor_position,
                    );
                    updated = true;
                }
            }
        }

        self.cursor_moved = false;
        self.cursor_pressed = false;
        self.cursor_released = false;

        updated
    }
}