kael 0.2.0

GPU-accelerated native UI framework for Rust — build desktop apps with Metal, DirectX, and Vulkan rendering
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

use crate::Keystroke;
use objc2::runtime::AnyObject;
use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventType};
use std::collections::HashMap;

pub(crate) fn keystroke_matches_event(keystroke: &Keystroke, event: *mut AnyObject) -> bool {
    let event: &NSEvent = unsafe { &*(event as *const NSEvent) };
    if event.r#type() != NSEventType::KeyDown {
        return false;
    }
    matches_modifiers_and_key(keystroke, event)
}

pub(crate) fn is_hotkey_released(keystroke: &Keystroke, event: *mut AnyObject) -> bool {
    let event: &NSEvent = unsafe { &*(event as *const NSEvent) };
    match event.r#type() {
        NSEventType::KeyUp => key_matches_ignoring_modifiers(keystroke, event),
        NSEventType::FlagsChanged => required_modifier_released(keystroke, event),
        _ => false,
    }
}

fn key_matches_ignoring_modifiers(keystroke: &Keystroke, event: &NSEvent) -> bool {
    let Some(chars_ignoring) = event.charactersIgnoringModifiers() else {
        return false;
    };
    let chars_str = chars_ignoring.UTF8String();
    if chars_str.is_null() {
        return false;
    }
    let chars = unsafe { std::ffi::CStr::from_ptr(chars_str) }
        .to_str()
        .unwrap_or("");
    let event_key = chars.to_lowercase();
    let target_key = keystroke.key.to_lowercase();
    event_key == target_key || normalize_key_name(&event_key) == target_key
}

fn required_modifier_released(keystroke: &Keystroke, event: &NSEvent) -> bool {
    let modifiers = event.modifierFlags();
    let has_cmd = modifiers.contains(NSEventModifierFlags::Command);
    let has_ctrl = modifiers.contains(NSEventModifierFlags::Control);
    let has_alt = modifiers.contains(NSEventModifierFlags::Option);
    let has_shift = modifiers.contains(NSEventModifierFlags::Shift);

    (keystroke.modifiers.platform && !has_cmd)
        || (keystroke.modifiers.control && !has_ctrl)
        || (keystroke.modifiers.alt && !has_alt)
        || (keystroke.modifiers.shift && !has_shift)
}

fn matches_modifiers_and_key(keystroke: &Keystroke, event: &NSEvent) -> bool {
    let modifiers = event.modifierFlags();
    let event_cmd = modifiers.contains(NSEventModifierFlags::Command);
    let event_ctrl = modifiers.contains(NSEventModifierFlags::Control);
    let event_alt = modifiers.contains(NSEventModifierFlags::Option);
    let event_shift = modifiers.contains(NSEventModifierFlags::Shift);

    if keystroke.modifiers.platform != event_cmd
        || keystroke.modifiers.control != event_ctrl
        || keystroke.modifiers.alt != event_alt
        || keystroke.modifiers.shift != event_shift
    {
        return false;
    }

    let Some(chars_ignoring) = event.charactersIgnoringModifiers() else {
        return false;
    };
    let chars_str = chars_ignoring.UTF8String();
    if chars_str.is_null() {
        return false;
    }
    let chars = unsafe { std::ffi::CStr::from_ptr(chars_str) }
        .to_str()
        .unwrap_or("");

    let event_key = chars.to_lowercase();
    let target_key = keystroke.key.to_lowercase();

    event_key == target_key || normalize_key_name(&event_key) == target_key
}

fn normalize_key_name(char_key: &str) -> &str {
    match char_key {
        " " => "space",
        "\t" => "tab",
        "\r" | "\n" => "enter",
        "\u{1b}" => "escape",
        "\u{7f}" => "backspace",
        "\u{f700}" => "up",
        "\u{f701}" => "down",
        "\u{f702}" => "left",
        "\u{f703}" => "right",
        "\u{f728}" => "delete",
        "\u{f729}" => "home",
        "\u{f72b}" => "end",
        "\u{f72c}" => "pageup",
        "\u{f72d}" => "pagedown",
        other => other,
    }
}

pub(crate) fn find_matching_hotkey(
    registrations: &HashMap<u32, Keystroke>,
    event: *mut AnyObject,
) -> Option<u32> {
    for (id, keystroke) in registrations {
        if keystroke_matches_event(keystroke, event) {
            return Some(*id);
        }
    }
    None
}

pub(crate) fn find_matching_hotkey_released(
    active_hotkey: Option<u32>,
    registrations: &HashMap<u32, Keystroke>,
    event: *mut AnyObject,
) -> Option<u32> {
    let active_id = active_hotkey?;
    let keystroke = registrations.get(&active_id)?;
    if is_hotkey_released(keystroke, event) {
        Some(active_id)
    } else {
        None
    }
}