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
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
137
138
139
140
141
142
143
144
145
146

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

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

pub(in crate::input) fn scroll(
    interface: &Arc<Interface>,
    hooks: &mut HashMap<InputHookID, Hook>,
    win_state: &mut HashMap<WindowID, WindowState>,
    win: WindowID,
    ss: bool,
    v: f32,
    h: f32,
) {
    let window_state = win_state
        .entry(win)
        .or_insert_with(|| WindowState::new(win));
    let [x, y] = window_state.cursor_pos();
    let inside_bin_ids = interface.get_bin_ids_atop(win, x, y);
    let focused_bin_id = window_state.focused_bin_id();

    let mut call_in_order: Vec<_> = hooks
        .iter_mut()
        .filter_map(|(hook_id, hook)| {
            if let HookState::Scroll {
                weight,
                top,
                focus,
                smooth,
                ..
            } = &mut hook.state
            {
                if ss != *smooth {
                    return None;
                }

                match &hook.target_id {
                    InputHookTargetID::Window(hook_win) => {
                        if *hook_win != win {
                            return None;
                        }

                        if *focus && !window_state.is_focused() {
                            return None;
                        }

                        Some((*weight, 0, *hook_id, hook))
                    },
                    InputHookTargetID::Bin(hook_bin) => {
                        if window_state.is_cursor_captured() {
                            return None;
                        }

                        let mut inside_i_op: Option<usize> = None;

                        for (i, inside_id) in inside_bin_ids.iter().enumerate() {
                            if *hook_bin == *inside_id {
                                inside_i_op = Some(i);
                                break;
                            }
                        }

                        let inside_i = match inside_i_op {
                            Some(some) => some,
                            None => return None,
                        };

                        if *top && inside_i != 0 {
                            return None;
                        }

                        if *focus && focused_bin_id == Some(*hook_bin) {
                            return None;
                        }

                        Some((*weight, inside_i + 1, *hook_id, hook))
                    },
                    _ => None,
                }
            } else {
                None
            }
        })
        .collect();

    call_in_order.sort_by_key(|(weight, z, ..)| (Reverse(*weight), *z));
    let mut remove_hooks = Vec::new();
    let mut last_weight_z_order = None;

    for (weight, z_order, hook_id, hook) in call_in_order {
        if let HookState::Scroll {
            method,
            upper_blocks,
            ..
        } = &mut hook.state
        {
            let hook_target = match hook.target_wk.upgrade() {
                Some(some) => some,
                None => {
                    remove_hooks.push(hook_id);
                    continue;
                },
            };

            // z_order of zero is a window
            if *upper_blocks && !z_order != 0 {
                if let Some((last_weight, last_z_order)) = &last_weight_z_order {
                    if *last_weight == weight && *last_z_order != 0 && *last_z_order < z_order {
                        continue;
                    }
                }
            }

            last_weight_z_order = Some((weight, z_order));

            match method(hook_target, window_state, v, h) {
                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);
    }
}