basalt 0.21.0

A window/ui framework built upon vulkan.
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

use std::cmp::Reverse;
use std::collections::HashMap;

use crate::input::state::{HookState, WindowState};
use crate::input::{Hook, InputHookCtrl, InputHookID, NO_HOOK_WEIGHT};
use crate::window::WindowID;

macro_rules! call_hook_varient {
    ($hooks:ident, $window_state:ident, $varient:ident) => {
        let mut remove_hooks = Vec::new();

        let mut call_on: Vec<_> = $hooks
            .iter_mut()
            .filter_map(|(hook_id, hook)| {
                if hook.is_for_window_id($window_state.window_id()) {
                    if let HookState::$varient {
                        weight, ..
                    } = &hook.state
                    {
                        Some((*weight, hook_id, hook))
                    } else {
                        None
                    }
                } else {
                    None
                }
            })
            .collect();

        call_on.sort_by_key(|(weight, ..)| Reverse(*weight));

        for (weight, hook_id, hook) in call_on {
            let hook_target = match hook.target_wk.upgrade() {
                Some(some) => some,
                None => {
                    remove_hooks.push(*hook_id);
                    continue;
                },
            };

            if let HookState::$varient {
                method, ..
            } = &mut hook.state
            {
                match method(hook_target, $window_state) {
                    InputHookCtrl::Retain => (),
                    InputHookCtrl::RetainNoPass => {
                        if weight != NO_HOOK_WEIGHT {
                            break;
                        }
                    },
                    InputHookCtrl::Remove => {
                        remove_hooks.push(*hook_id);
                    },
                    InputHookCtrl::RemoveNoPass => {
                        remove_hooks.push(*hook_id);

                        if weight != NO_HOOK_WEIGHT {
                            break;
                        }
                    },
                }
            } else {
                unreachable!()
            }
        }

        for hook_id in remove_hooks {
            $hooks.remove(&hook_id);
        }
    };
}

pub(in crate::input) fn window_focus(
    hooks: &mut HashMap<InputHookID, Hook>,
    win_state: &mut HashMap<WindowID, WindowState>,
    win: WindowID,
    focused: bool,
) {
    let window_state = win_state
        .entry(win)
        .or_insert_with(|| WindowState::new(win));

    if window_state.update_focus(focused) {
        if focused {
            call_hook_varient!(hooks, window_state, Focus);
        } else {
            call_hook_varient!(hooks, window_state, FocusLost);
        }
    }
}

pub(in crate::input) fn window_cursor_inside(
    hooks: &mut HashMap<InputHookID, Hook>,
    win_state: &mut HashMap<WindowID, WindowState>,
    win: WindowID,
    inside: bool,
) {
    let window_state = win_state
        .entry(win)
        .or_insert_with(|| WindowState::new(win));

    if window_state.update_cursor_inside(inside) {
        if inside {
            call_hook_varient!(hooks, window_state, Enter);
        } else {
            call_hook_varient!(hooks, window_state, Leave);
        }
    }
}