rktk-keymanager 0.2.0

Keymap/state manager for self-made keyboard firmware
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

mod action;
mod basic;
mod combo;
mod encoder;
mod keycode;
mod keymap;
mod layer;
mod mouse;

#[allow(unused_imports)]
mod prelude {
    use core::time::Duration;

    pub(super) use super::keymap::EMPTY_KEYMAP;
    use crate::interface::state::config::{
        ComboConfig, KeyResolverConfig, MouseConfig, StateConfig, TapDanceConfig, TapHoldConfig,
    };
    pub(super) use crate::{
        interface::state::input_event::InputEvent,
        keycode::{key::*, layer::*, media::*, modifier::*, mouse::*, special::*, utils::*, *},
        time::Instant,
    };
    pub use crate::{
        interface::state::input_event::KeyChangeEvent,
        keymap::{Keymap, TapDanceDefinition},
        state::{
            State,
            hid_report::{HidReportState, Report},
        },
    };
    pub use usbd_hid::descriptor::{KeyboardReport, MediaKeyboardReport, MouseReport};

    pub const fn time(ms: u32) -> Duration {
        Duration::from_millis(ms as u64)
    }

    pub const ROWS: usize = 5;
    pub const COLS: usize = 14;
    pub const LAYER_COUNT: usize = 5;
    pub const ENC_COUNT: usize = 1;

    /// All report is None. This means there is no report to send.
    pub const NONE_REPORT: Report = Report {
        keyboard_report: None,
        mouse_report: None,
        media_keyboard_report: None,
        highest_layer: 0,
    };
    pub const KEYBOARD_ONLY_REPORT: Report = Report {
        keyboard_report: Some(KeyboardReport {
            modifier: 0,
            reserved: 0,
            leds: 0,
            keycodes: [0, 0, 0, 0, 0, 0],
        }),
        mouse_report: None,
        media_keyboard_report: None,
        highest_layer: 0,
    };
    pub const MOUSE_ONLY_REPORT: Report = Report {
        keyboard_report: None,
        mouse_report: Some(MouseReport {
            buttons: 0,
            x: 0,
            y: 0,
            wheel: 0,
            pan: 0,
        }),
        media_keyboard_report: None,
        highest_layer: 0,
    };

    pub const fn report_with_keycodes(keycodes: [u8; 6]) -> Report {
        let mut report = KEYBOARD_ONLY_REPORT;
        report.keyboard_report.as_mut().unwrap().keycodes = keycodes;
        report
    }

    macro_rules! update {
        ($state:expr, $now:expr, ($row:expr, $col:expr, $pressed:expr)) => {
            $state.update(
                InputEvent::Key(KeyChangeEvent {
                    row: $row,
                    col: $col,
                    pressed: $pressed,
                }),
                $now,
            )
        };
        ($state:expr, $now:expr) => {
            $state.update(InputEvent::None, $now)
        };
    }

    pub fn new_state(
        keymap: Keymap<LAYER_COUNT, ROWS, COLS, ENC_COUNT, 2, 4, 2, 3>,
    ) -> HidReportState<LAYER_COUNT, ROWS, COLS, ENC_COUNT, 8, 5, 2, 4, 2, 3> {
        HidReportState::new(
            keymap,
            StateConfig {
                mouse: MouseConfig {
                    auto_mouse_layer: 1,
                    auto_mouse_duration: 500,
                    auto_mouse_threshold: 5,
                    scroll_divider_x: 20,
                    scroll_divider_y: -12,
                },
                key_resolver: KeyResolverConfig {
                    tap_hold: TapHoldConfig {
                        threshold: 300,
                        hold_on_other_key: true,
                    },
                    tap_dance: TapDanceConfig { threshold: 100 },
                    combo: ComboConfig { threshold: 20 },
                },
            },
        )
    }

    pub(crate) use update;
}