milestone: desktop path Phases 1-5
Phase 1 (Runtime Substrate): 4 check binaries, --probe, POSIX tests Phase 2 (Wayland Compositor): bounded scaffold, zero warnings Phase 3 (KWin Session): preflight checker (KWin stub, gated on Qt6Quick) Phase 4 (KDE Plasma): 18 KF6 enabled, preflight checker Phase 5 (Hardware GPU): DRM/firmware/Mesa preflight checker Build: zero warnings, all scripts syntax-clean. Oracle-verified.
This commit is contained in:
@@ -0,0 +1,21 @@
|
||||
[package]
|
||||
name = "inputd"
|
||||
description = "Input multiplexer daemon"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["Anhad Singh <andypython@protonmail.com>"]
|
||||
|
||||
[dependencies]
|
||||
anyhow.workspace = true
|
||||
log.workspace = true
|
||||
redox_syscall = { workspace = true, features = ["std"] }
|
||||
orbclient.workspace = true
|
||||
libredox.workspace = true
|
||||
|
||||
common = { path = "../common" }
|
||||
daemon = { path = "../../daemon" }
|
||||
redox-scheme.workspace = true
|
||||
scheme-utils = { path = "../../scheme-utils" }
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -0,0 +1,438 @@
|
||||
use std::collections::HashMap;
|
||||
use std::fmt::Display;
|
||||
use std::str::FromStr;
|
||||
|
||||
mod keymaps {
|
||||
pub static US: [(u8, [char; 2]); 53] = [
|
||||
(orbclient::K_ESC, ['\x1B', '\x1B']),
|
||||
(orbclient::K_1, ['1', '!']),
|
||||
(orbclient::K_2, ['2', '@']),
|
||||
(orbclient::K_3, ['3', '#']),
|
||||
(orbclient::K_4, ['4', '$']),
|
||||
(orbclient::K_5, ['5', '%']),
|
||||
(orbclient::K_6, ['6', '^']),
|
||||
(orbclient::K_7, ['7', '&']),
|
||||
(orbclient::K_8, ['8', '*']),
|
||||
(orbclient::K_9, ['9', '(']),
|
||||
(orbclient::K_0, ['0', ')']),
|
||||
(orbclient::K_MINUS, ['-', '_']),
|
||||
(orbclient::K_EQUALS, ['=', '+']),
|
||||
(orbclient::K_BKSP, ['\x7F', '\x7F']),
|
||||
(orbclient::K_TAB, ['\t', '\t']),
|
||||
(orbclient::K_Q, ['q', 'Q']),
|
||||
(orbclient::K_W, ['w', 'W']),
|
||||
(orbclient::K_E, ['e', 'E']),
|
||||
(orbclient::K_R, ['r', 'R']),
|
||||
(orbclient::K_T, ['t', 'T']),
|
||||
(orbclient::K_Y, ['y', 'Y']),
|
||||
(orbclient::K_U, ['u', 'U']),
|
||||
(orbclient::K_I, ['i', 'I']),
|
||||
(orbclient::K_O, ['o', 'O']),
|
||||
(orbclient::K_P, ['p', 'P']),
|
||||
(orbclient::K_BRACE_OPEN, ['[', '{']),
|
||||
(orbclient::K_BRACE_CLOSE, [']', '}']),
|
||||
(orbclient::K_ENTER, ['\n', '\n']),
|
||||
(orbclient::K_CTRL, ['\0', '\0']),
|
||||
(orbclient::K_A, ['a', 'A']),
|
||||
(orbclient::K_S, ['s', 'S']),
|
||||
(orbclient::K_D, ['d', 'D']),
|
||||
(orbclient::K_F, ['f', 'F']),
|
||||
(orbclient::K_G, ['g', 'G']),
|
||||
(orbclient::K_H, ['h', 'H']),
|
||||
(orbclient::K_J, ['j', 'J']),
|
||||
(orbclient::K_K, ['k', 'K']),
|
||||
(orbclient::K_L, ['l', 'L']),
|
||||
(orbclient::K_SEMICOLON, [';', ':']),
|
||||
(orbclient::K_QUOTE, ['\'', '"']),
|
||||
(orbclient::K_TICK, ['`', '~']),
|
||||
(orbclient::K_BACKSLASH, ['\\', '|']),
|
||||
(orbclient::K_Z, ['z', 'Z']),
|
||||
(orbclient::K_X, ['x', 'X']),
|
||||
(orbclient::K_C, ['c', 'C']),
|
||||
(orbclient::K_V, ['v', 'V']),
|
||||
(orbclient::K_B, ['b', 'B']),
|
||||
(orbclient::K_N, ['n', 'N']),
|
||||
(orbclient::K_M, ['m', 'M']),
|
||||
(orbclient::K_COMMA, [',', '<']),
|
||||
(orbclient::K_PERIOD, ['.', '>']),
|
||||
(orbclient::K_SLASH, ['/', '?']),
|
||||
(orbclient::K_SPACE, [' ', ' ']),
|
||||
];
|
||||
|
||||
pub static GB: [(u8, [char; 2]); 54] = [
|
||||
(orbclient::K_ESC, ['\x1B', '\x1B']),
|
||||
(orbclient::K_1, ['1', '!']),
|
||||
(orbclient::K_2, ['2', '"']),
|
||||
(orbclient::K_3, ['3', '£']),
|
||||
(orbclient::K_4, ['4', '$']),
|
||||
(orbclient::K_5, ['5', '%']),
|
||||
(orbclient::K_6, ['6', '^']),
|
||||
(orbclient::K_7, ['7', '&']),
|
||||
(orbclient::K_8, ['8', '*']),
|
||||
(orbclient::K_9, ['9', '(']),
|
||||
(orbclient::K_0, ['0', ')']),
|
||||
(orbclient::K_MINUS, ['-', '_']),
|
||||
(orbclient::K_EQUALS, ['=', '+']),
|
||||
(orbclient::K_BKSP, ['\x7F', '\x7F']),
|
||||
(orbclient::K_TAB, ['\t', '\t']),
|
||||
(orbclient::K_Q, ['q', 'Q']),
|
||||
(orbclient::K_W, ['w', 'W']),
|
||||
(orbclient::K_E, ['e', 'E']),
|
||||
(orbclient::K_R, ['r', 'R']),
|
||||
(orbclient::K_T, ['t', 'T']),
|
||||
(orbclient::K_Y, ['y', 'Y']),
|
||||
(orbclient::K_U, ['u', 'U']),
|
||||
(orbclient::K_I, ['i', 'I']),
|
||||
(orbclient::K_O, ['o', 'O']),
|
||||
(orbclient::K_P, ['p', 'P']),
|
||||
(orbclient::K_BRACE_OPEN, ['[', '{']),
|
||||
(orbclient::K_BRACE_CLOSE, [']', '}']),
|
||||
(orbclient::K_ENTER, ['\n', '\n']),
|
||||
(orbclient::K_CTRL, ['\0', '\0']),
|
||||
(orbclient::K_A, ['a', 'A']),
|
||||
(orbclient::K_S, ['s', 'S']),
|
||||
(orbclient::K_D, ['d', 'D']),
|
||||
(orbclient::K_F, ['f', 'F']),
|
||||
(orbclient::K_G, ['g', 'G']),
|
||||
(orbclient::K_H, ['h', 'H']),
|
||||
(orbclient::K_J, ['j', 'J']),
|
||||
(orbclient::K_K, ['k', 'K']),
|
||||
(orbclient::K_L, ['l', 'L']),
|
||||
(orbclient::K_SEMICOLON, [';', ':']),
|
||||
(orbclient::K_QUOTE, ['\'', '@']),
|
||||
(orbclient::K_TICK, ['`', '¬']),
|
||||
(orbclient::K_BACKSLASH, ['#', '~']),
|
||||
(orbclient::K_Z, ['z', 'Z']),
|
||||
(orbclient::K_X, ['x', 'X']),
|
||||
(orbclient::K_C, ['c', 'C']),
|
||||
(orbclient::K_V, ['v', 'V']),
|
||||
(orbclient::K_B, ['b', 'B']),
|
||||
(orbclient::K_N, ['n', 'N']),
|
||||
(orbclient::K_M, ['m', 'M']),
|
||||
(orbclient::K_COMMA, [',', '<']),
|
||||
(orbclient::K_PERIOD, ['.', '>']),
|
||||
(orbclient::K_SLASH, ['/', '?']),
|
||||
(orbclient::K_SPACE, [' ', ' ']),
|
||||
// UK Backslash, doesn't exist on US keyboard
|
||||
(0x56, ['\\', '|']),
|
||||
];
|
||||
|
||||
pub static DVORAK: [(u8, [char; 2]); 53] = [
|
||||
(orbclient::K_ESC, ['\x1B', '\x1B']),
|
||||
(orbclient::K_1, ['1', '!']),
|
||||
(orbclient::K_2, ['2', '@']),
|
||||
(orbclient::K_3, ['3', '#']),
|
||||
(orbclient::K_4, ['4', '$']),
|
||||
(orbclient::K_5, ['5', '%']),
|
||||
(orbclient::K_6, ['6', '^']),
|
||||
(orbclient::K_7, ['7', '&']),
|
||||
(orbclient::K_8, ['8', '*']),
|
||||
(orbclient::K_9, ['9', '(']),
|
||||
(orbclient::K_0, ['0', ')']),
|
||||
(orbclient::K_MINUS, ['[', '{']),
|
||||
(orbclient::K_EQUALS, [']', '}']),
|
||||
(orbclient::K_BKSP, ['\x7F', '\x7F']),
|
||||
(orbclient::K_TAB, ['\t', '\t']),
|
||||
(orbclient::K_Q, ['\'', '"']),
|
||||
(orbclient::K_W, [',', '<']),
|
||||
(orbclient::K_E, ['.', '>']),
|
||||
(orbclient::K_R, ['p', 'P']),
|
||||
(orbclient::K_T, ['y', 'Y']),
|
||||
(orbclient::K_Y, ['f', 'F']),
|
||||
(orbclient::K_U, ['g', 'G']),
|
||||
(orbclient::K_I, ['c', 'C']),
|
||||
(orbclient::K_O, ['r', 'R']),
|
||||
(orbclient::K_P, ['l', 'L']),
|
||||
(orbclient::K_BRACE_OPEN, ['/', '?']),
|
||||
(orbclient::K_BRACE_CLOSE, ['=', '+']),
|
||||
(orbclient::K_ENTER, ['\n', '\n']),
|
||||
(orbclient::K_CTRL, ['\0', '\0']),
|
||||
(orbclient::K_A, ['a', 'A']),
|
||||
(orbclient::K_S, ['o', 'O']),
|
||||
(orbclient::K_D, ['e', 'E']),
|
||||
(orbclient::K_F, ['u', 'U']),
|
||||
(orbclient::K_G, ['i', 'I']),
|
||||
(orbclient::K_H, ['d', 'D']),
|
||||
(orbclient::K_J, ['h', 'H']),
|
||||
(orbclient::K_K, ['t', 'T']),
|
||||
(orbclient::K_L, ['n', 'N']),
|
||||
(orbclient::K_SEMICOLON, ['s', 'S']),
|
||||
(orbclient::K_QUOTE, ['-', '_']),
|
||||
(orbclient::K_TICK, ['`', '~']),
|
||||
(orbclient::K_BACKSLASH, ['\\', '|']),
|
||||
(orbclient::K_Z, [';', ':']),
|
||||
(orbclient::K_X, ['q', 'Q']),
|
||||
(orbclient::K_C, ['j', 'J']),
|
||||
(orbclient::K_V, ['k', 'K']),
|
||||
(orbclient::K_B, ['x', 'X']),
|
||||
(orbclient::K_N, ['b', 'B']),
|
||||
(orbclient::K_M, ['m', 'M']),
|
||||
(orbclient::K_COMMA, ['w', 'W']),
|
||||
(orbclient::K_PERIOD, ['v', 'V']),
|
||||
(orbclient::K_SLASH, ['z', 'Z']),
|
||||
(orbclient::K_SPACE, [' ', ' ']),
|
||||
];
|
||||
|
||||
pub static AZERTY: [(u8, [char; 2]); 53] = [
|
||||
(orbclient::K_ESC, ['\x1B', '\x1B']),
|
||||
(orbclient::K_1, ['&', '1']),
|
||||
(orbclient::K_2, ['é', '2']),
|
||||
(orbclient::K_3, ['"', '3']),
|
||||
(orbclient::K_4, ['\'', '4']),
|
||||
(orbclient::K_5, ['(', '5']),
|
||||
(orbclient::K_6, ['|', '6']),
|
||||
(orbclient::K_7, ['è', '7']),
|
||||
(orbclient::K_8, ['_', '8']),
|
||||
(orbclient::K_9, ['ç', '9']),
|
||||
(orbclient::K_0, ['à', '0']),
|
||||
(orbclient::K_MINUS, [')', '°']),
|
||||
(orbclient::K_EQUALS, ['=', '+']),
|
||||
(orbclient::K_BKSP, ['\x7F', '\x7F']),
|
||||
(orbclient::K_TAB, ['\t', '\t']),
|
||||
(orbclient::K_Q, ['a', 'A']),
|
||||
(orbclient::K_W, ['z', 'Z']),
|
||||
(orbclient::K_E, ['e', 'E']),
|
||||
(orbclient::K_R, ['r', 'R']),
|
||||
(orbclient::K_T, ['t', 'T']),
|
||||
(orbclient::K_Y, ['y', 'Y']),
|
||||
(orbclient::K_U, ['u', 'U']),
|
||||
(orbclient::K_I, ['i', 'I']),
|
||||
(orbclient::K_O, ['o', 'O']),
|
||||
(orbclient::K_P, ['p', 'P']),
|
||||
(orbclient::K_BRACE_OPEN, ['^', '¨']),
|
||||
(orbclient::K_BRACE_CLOSE, ['$', '£']),
|
||||
(orbclient::K_ENTER, ['\n', '\n']),
|
||||
(orbclient::K_CTRL, ['\0', '\0']),
|
||||
(orbclient::K_A, ['q', 'Q']),
|
||||
(orbclient::K_S, ['s', 'S']),
|
||||
(orbclient::K_D, ['d', 'D']),
|
||||
(orbclient::K_F, ['f', 'F']),
|
||||
(orbclient::K_G, ['g', 'G']),
|
||||
(orbclient::K_H, ['h', 'H']),
|
||||
(orbclient::K_J, ['j', 'J']),
|
||||
(orbclient::K_K, ['k', 'K']),
|
||||
(orbclient::K_L, ['l', 'L']),
|
||||
(orbclient::K_SEMICOLON, ['m', 'M']),
|
||||
(orbclient::K_QUOTE, ['ù', '%']),
|
||||
(orbclient::K_TICK, ['*', 'µ']),
|
||||
(orbclient::K_BACKSLASH, ['ê', 'Ê']),
|
||||
(orbclient::K_Z, ['w', 'W']),
|
||||
(orbclient::K_X, ['x', 'X']),
|
||||
(orbclient::K_C, ['c', 'C']),
|
||||
(orbclient::K_V, ['v', 'V']),
|
||||
(orbclient::K_B, ['b', 'B']),
|
||||
(orbclient::K_N, ['n', 'N']),
|
||||
(orbclient::K_M, [',', '?']),
|
||||
(orbclient::K_COMMA, [';', '.']),
|
||||
(orbclient::K_PERIOD, [':', '/']),
|
||||
(orbclient::K_SLASH, ['!', '§']),
|
||||
(orbclient::K_SPACE, [' ', ' ']),
|
||||
];
|
||||
|
||||
pub static BEPO: [(u8, [char; 2]); 53] = [
|
||||
(orbclient::K_ESC, ['\x1B', '\x1B']),
|
||||
(orbclient::K_1, ['"', '1']),
|
||||
(orbclient::K_2, ['«', '2']),
|
||||
(orbclient::K_3, ['»', '3']),
|
||||
(orbclient::K_4, ['(', '4']),
|
||||
(orbclient::K_5, [')', '5']),
|
||||
(orbclient::K_6, ['@', '6']),
|
||||
(orbclient::K_7, ['+', '7']),
|
||||
(orbclient::K_8, ['-', '8']),
|
||||
(orbclient::K_9, ['/', '9']),
|
||||
(orbclient::K_0, ['*', '0']),
|
||||
(orbclient::K_MINUS, ['=', '°']),
|
||||
(orbclient::K_EQUALS, ['%', '`']),
|
||||
(orbclient::K_BKSP, ['\x7F', '\x7F']),
|
||||
(orbclient::K_TAB, ['\t', '\t']),
|
||||
(orbclient::K_Q, ['b', 'B']),
|
||||
(orbclient::K_W, ['é', 'É']),
|
||||
(orbclient::K_E, ['p', 'P']),
|
||||
(orbclient::K_R, ['o', 'O']),
|
||||
(orbclient::K_T, ['è', 'È']),
|
||||
(orbclient::K_Y, ['^', '!']),
|
||||
(orbclient::K_U, ['v', 'V']),
|
||||
(orbclient::K_I, ['d', 'D']),
|
||||
(orbclient::K_O, ['l', 'L']),
|
||||
(orbclient::K_P, ['j', 'J']),
|
||||
(orbclient::K_BRACE_OPEN, ['z', 'Z']),
|
||||
(orbclient::K_BRACE_CLOSE, ['w', 'W']),
|
||||
(orbclient::K_ENTER, ['\n', '\n']),
|
||||
(orbclient::K_CTRL, ['\0', '\0']),
|
||||
(orbclient::K_A, ['a', 'A']),
|
||||
(orbclient::K_S, ['u', 'U']),
|
||||
(orbclient::K_D, ['i', 'I']),
|
||||
(orbclient::K_F, ['e', 'E']),
|
||||
(orbclient::K_G, [',', ';']),
|
||||
(orbclient::K_H, ['c', 'C']),
|
||||
(orbclient::K_J, ['t', 'T']),
|
||||
(orbclient::K_K, ['s', 'S']),
|
||||
(orbclient::K_L, ['r', 'R']),
|
||||
(orbclient::K_SEMICOLON, ['n', 'N']),
|
||||
(orbclient::K_QUOTE, ['m', 'M']),
|
||||
(orbclient::K_TICK, ['ç', 'Ç']),
|
||||
(orbclient::K_BACKSLASH, ['ê', 'Ê']),
|
||||
(orbclient::K_Z, ['à', 'À']),
|
||||
(orbclient::K_X, ['y', 'Y']),
|
||||
(orbclient::K_C, ['x', 'X']),
|
||||
(orbclient::K_V, ['.', ':']),
|
||||
(orbclient::K_B, ['k', 'K']),
|
||||
(orbclient::K_N, ['\'', '?']),
|
||||
(orbclient::K_M, ['q', 'Q']),
|
||||
(orbclient::K_COMMA, ['g', 'G']),
|
||||
(orbclient::K_PERIOD, ['h', 'H']),
|
||||
(orbclient::K_SLASH, ['f', 'F']),
|
||||
(orbclient::K_SPACE, [' ', ' ']),
|
||||
];
|
||||
|
||||
pub static IT: [(u8, [char; 2]); 53] = [
|
||||
(orbclient::K_ESC, ['\x1B', '\x1B']),
|
||||
(orbclient::K_1, ['1', '!']),
|
||||
(orbclient::K_2, ['2', '"']),
|
||||
(orbclient::K_3, ['3', '£']),
|
||||
(orbclient::K_4, ['4', '$']),
|
||||
(orbclient::K_5, ['5', '%']),
|
||||
(orbclient::K_6, ['6', '&']),
|
||||
(orbclient::K_7, ['7', '/']),
|
||||
(orbclient::K_8, ['8', '(']),
|
||||
(orbclient::K_9, ['9', ')']),
|
||||
(orbclient::K_0, ['0', '=']),
|
||||
(orbclient::K_MINUS, ['?', '\'']),
|
||||
(orbclient::K_EQUALS, ['ì', '^']),
|
||||
(orbclient::K_BKSP, ['\x7F', '\x7F']),
|
||||
(orbclient::K_TAB, ['\t', '\t']),
|
||||
(orbclient::K_Q, ['q', 'Q']),
|
||||
(orbclient::K_W, ['w', 'W']),
|
||||
(orbclient::K_E, ['e', 'E']),
|
||||
(orbclient::K_R, ['r', 'R']),
|
||||
(orbclient::K_T, ['t', 'T']),
|
||||
(orbclient::K_Y, ['y', 'Y']),
|
||||
(orbclient::K_U, ['u', 'U']),
|
||||
(orbclient::K_I, ['i', 'I']),
|
||||
(orbclient::K_O, ['o', 'O']),
|
||||
(orbclient::K_P, ['p', 'P']),
|
||||
(orbclient::K_BRACE_OPEN, ['è', 'é']),
|
||||
(orbclient::K_BRACE_CLOSE, ['+', '*']),
|
||||
(orbclient::K_ENTER, ['\n', '\n']),
|
||||
(orbclient::K_CTRL, ['\x20', '\x20']),
|
||||
(orbclient::K_A, ['a', 'A']),
|
||||
(orbclient::K_S, ['s', 'S']),
|
||||
(orbclient::K_D, ['d', 'D']),
|
||||
(orbclient::K_F, ['f', 'F']),
|
||||
(orbclient::K_G, ['g', 'G']),
|
||||
(orbclient::K_H, ['h', 'H']),
|
||||
(orbclient::K_J, ['j', 'J']),
|
||||
(orbclient::K_K, ['k', 'K']),
|
||||
(orbclient::K_L, ['l', 'L']),
|
||||
(orbclient::K_SEMICOLON, ['ò', 'ç']),
|
||||
(orbclient::K_QUOTE, ['à', '°']),
|
||||
(orbclient::K_TICK, ['ù', '§']),
|
||||
(orbclient::K_BACKSLASH, ['<', '>']),
|
||||
(orbclient::K_Z, ['z', 'Z']),
|
||||
(orbclient::K_X, ['x', 'X']),
|
||||
(orbclient::K_C, ['c', 'C']),
|
||||
(orbclient::K_V, ['v', 'V']),
|
||||
(orbclient::K_B, ['b', 'B']),
|
||||
(orbclient::K_N, ['n', 'N']),
|
||||
(orbclient::K_M, ['m', 'M']),
|
||||
(orbclient::K_COMMA, [',', ';']),
|
||||
(orbclient::K_PERIOD, ['.', ':']),
|
||||
(orbclient::K_SLASH, ['-', '_']),
|
||||
(orbclient::K_SPACE, [' ', ' ']),
|
||||
];
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(usize)]
|
||||
pub enum KeymapKind {
|
||||
US = 0,
|
||||
GB,
|
||||
Dvorak,
|
||||
Azerty,
|
||||
Bepo,
|
||||
IT,
|
||||
}
|
||||
|
||||
impl From<usize> for KeymapKind {
|
||||
fn from(value: usize) -> Self {
|
||||
if value > (KeymapKind::IT as usize) {
|
||||
KeymapKind::US
|
||||
} else {
|
||||
// SAFETY: Checked above
|
||||
unsafe { std::mem::transmute(value) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(missing_copy_implementations)]
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct ParseKeymapError(());
|
||||
|
||||
impl FromStr for KeymapKind {
|
||||
type Err = ParseKeymapError;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
let keymap = match s {
|
||||
"dvorak" => KeymapKind::Dvorak,
|
||||
"us" => KeymapKind::US,
|
||||
"gb" => KeymapKind::GB,
|
||||
"azerty" => KeymapKind::Azerty,
|
||||
"bepo" => KeymapKind::Bepo,
|
||||
"it" => KeymapKind::IT,
|
||||
&_ => return Err(ParseKeymapError(())),
|
||||
};
|
||||
|
||||
Ok(keymap)
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for KeymapKind {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
let s = match *self {
|
||||
KeymapKind::US => "us",
|
||||
KeymapKind::GB => "gb",
|
||||
KeymapKind::Dvorak => "dvorak",
|
||||
KeymapKind::Azerty => "azerty",
|
||||
KeymapKind::Bepo => "bepo",
|
||||
KeymapKind::IT => "it",
|
||||
};
|
||||
f.write_str(s)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct KeymapData {
|
||||
pub keymap_hash: HashMap<u8, [char; 2]>,
|
||||
pub kind: KeymapKind,
|
||||
}
|
||||
|
||||
impl KeymapData {
|
||||
pub fn new(kind: KeymapKind) -> Self {
|
||||
let keymap_hash = match kind {
|
||||
KeymapKind::US => HashMap::from(keymaps::US),
|
||||
KeymapKind::GB => HashMap::from(keymaps::GB),
|
||||
KeymapKind::Dvorak => HashMap::from(keymaps::DVORAK),
|
||||
KeymapKind::Azerty => HashMap::from(keymaps::AZERTY),
|
||||
KeymapKind::Bepo => HashMap::from(keymaps::BEPO),
|
||||
KeymapKind::IT => HashMap::from(keymaps::IT),
|
||||
};
|
||||
|
||||
Self { keymap_hash, kind }
|
||||
}
|
||||
|
||||
pub fn get_kind(&self) -> KeymapKind {
|
||||
self.kind
|
||||
}
|
||||
|
||||
// TODO: AltGr, Numlock
|
||||
pub fn get_char(&self, scancode: u8, shift: bool) -> char {
|
||||
if let Some(c) = self.keymap_hash.get(&scancode) {
|
||||
if shift {
|
||||
c[1]
|
||||
} else {
|
||||
c[0]
|
||||
}
|
||||
} else {
|
||||
'\0'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
use std::fs::{File, OpenOptions};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::mem::size_of;
|
||||
use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, RawFd};
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
use std::path::PathBuf;
|
||||
use std::slice;
|
||||
|
||||
use libredox::flag::{O_CLOEXEC, O_NONBLOCK, O_RDWR};
|
||||
use orbclient::Event;
|
||||
use syscall::ESTALE;
|
||||
|
||||
fn read_to_slice<T: Copy>(
|
||||
file: BorrowedFd,
|
||||
buf: &mut [T],
|
||||
) -> Result<usize, libredox::error::Error> {
|
||||
unsafe {
|
||||
libredox::call::read(
|
||||
file.as_raw_fd() as usize,
|
||||
slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len() * size_of::<T>()),
|
||||
)
|
||||
.map(|count| count / size_of::<T>())
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn any_as_u8_slice<T: Sized>(p: &T) -> &[u8] {
|
||||
slice::from_raw_parts((p as *const T) as *const u8, size_of::<T>())
|
||||
}
|
||||
|
||||
unsafe fn any_as_u8_slice_mut<T: Sized>(p: &mut T) -> &mut [u8] {
|
||||
slice::from_raw_parts_mut((p as *mut T) as *mut u8, size_of::<T>())
|
||||
}
|
||||
|
||||
pub struct ConsumerHandle(File);
|
||||
|
||||
pub enum ConsumerHandleEvent<'a> {
|
||||
Events(&'a [Event]),
|
||||
Handoff,
|
||||
}
|
||||
|
||||
impl ConsumerHandle {
|
||||
pub fn new_vt() -> io::Result<Self> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(O_NONBLOCK as i32)
|
||||
.open(format!("/scheme/input/consumer"))?;
|
||||
Ok(Self(file))
|
||||
}
|
||||
|
||||
pub fn bootlog_vt() -> io::Result<Self> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(O_NONBLOCK as i32)
|
||||
.open(format!("/scheme/input/consumer_bootlog"))?;
|
||||
Ok(Self(file))
|
||||
}
|
||||
|
||||
pub fn event_handle(&self) -> BorrowedFd<'_> {
|
||||
self.0.as_fd()
|
||||
}
|
||||
|
||||
pub fn open_display_v2(&self) -> io::Result<File> {
|
||||
let mut buffer = [0; 1024];
|
||||
let fd = self.0.as_raw_fd();
|
||||
let written = libredox::call::fpath(fd as usize, &mut buffer)?;
|
||||
|
||||
assert!(written <= buffer.len());
|
||||
|
||||
let mut display_path = PathBuf::from(
|
||||
std::str::from_utf8(&buffer[..written])
|
||||
.expect("init: display path UTF-8 check failed")
|
||||
.to_owned(),
|
||||
);
|
||||
display_path.set_file_name(format!(
|
||||
"v2/{}",
|
||||
display_path.file_name().unwrap().to_str().unwrap()
|
||||
));
|
||||
let display_path = display_path.to_str().unwrap();
|
||||
|
||||
let display_file =
|
||||
libredox::call::open(display_path, (O_CLOEXEC | O_NONBLOCK | O_RDWR) as _, 0)
|
||||
.map(|socket| unsafe { File::from_raw_fd(socket as RawFd) })
|
||||
.unwrap_or_else(|err| {
|
||||
panic!("failed to open display {}: {}", display_path, err);
|
||||
});
|
||||
|
||||
Ok(display_file)
|
||||
}
|
||||
|
||||
pub fn read_events<'a>(&self, events: &'a mut [Event]) -> io::Result<ConsumerHandleEvent<'a>> {
|
||||
match read_to_slice(self.0.as_fd(), events) {
|
||||
Ok(count) => Ok(ConsumerHandleEvent::Events(&events[..count])),
|
||||
Err(err) if err.errno() == ESTALE => Ok(ConsumerHandleEvent::Handoff),
|
||||
Err(err) => Err(err.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct ControlEvent {
|
||||
pub kind: usize,
|
||||
pub data: usize,
|
||||
}
|
||||
|
||||
impl From<VtActivate> for ControlEvent {
|
||||
fn from(value: VtActivate) -> Self {
|
||||
ControlEvent {
|
||||
kind: 1,
|
||||
data: value.vt,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<KeymapActivate> for ControlEvent {
|
||||
fn from(value: KeymapActivate) -> Self {
|
||||
ControlEvent {
|
||||
kind: 2,
|
||||
data: value.keymap,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct VtActivate {
|
||||
pub vt: usize,
|
||||
}
|
||||
|
||||
pub struct KeymapActivate {
|
||||
pub keymap: usize,
|
||||
}
|
||||
|
||||
pub struct DisplayHandle(File);
|
||||
|
||||
impl DisplayHandle {
|
||||
pub fn new<S: Into<String>>(scheme_name: S) -> io::Result<Self> {
|
||||
let path = format!("/scheme/input/handle/{}", scheme_name.into());
|
||||
Ok(Self(File::open(path)?))
|
||||
}
|
||||
|
||||
pub fn new_early<S: Into<String>>(scheme_name: S) -> io::Result<Self> {
|
||||
let path = format!("/scheme/input/handle_early/{}", scheme_name.into());
|
||||
Ok(Self(File::open(path)?))
|
||||
}
|
||||
|
||||
pub fn read_vt_event(&mut self) -> io::Result<Option<VtEvent>> {
|
||||
let mut event = VtEvent {
|
||||
kind: VtEventKind::Activate,
|
||||
vt: usize::MAX,
|
||||
};
|
||||
|
||||
let nread = self.0.read(unsafe { any_as_u8_slice_mut(&mut event) })?;
|
||||
|
||||
if nread == 0 {
|
||||
Ok(None)
|
||||
} else {
|
||||
assert_eq!(nread, size_of::<VtEvent>());
|
||||
Ok(Some(event))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn inner(&self) -> BorrowedFd<'_> {
|
||||
self.0.as_fd()
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ControlHandle(File);
|
||||
|
||||
impl ControlHandle {
|
||||
pub fn new() -> io::Result<Self> {
|
||||
let path = format!("/scheme/input/control");
|
||||
Ok(Self(File::open(path)?))
|
||||
}
|
||||
|
||||
/// Sent to Handle::Display
|
||||
pub fn activate_vt(&mut self, vt: usize) -> io::Result<usize> {
|
||||
let cmd = ControlEvent::from(VtActivate { vt });
|
||||
self.0.write(unsafe { any_as_u8_slice(&cmd) })
|
||||
}
|
||||
|
||||
/// Sent to Handle::Producer
|
||||
pub fn activate_keymap(&mut self, keymap: usize) -> io::Result<usize> {
|
||||
let cmd = ControlEvent::from(KeymapActivate { keymap });
|
||||
self.0.write(unsafe { any_as_u8_slice(&cmd) })
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
#[repr(usize)]
|
||||
pub enum VtEventKind {
|
||||
Activate,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
#[repr(C)]
|
||||
pub struct VtEvent {
|
||||
pub kind: VtEventKind,
|
||||
pub vt: usize,
|
||||
}
|
||||
|
||||
pub struct ProducerHandle(File);
|
||||
|
||||
impl ProducerHandle {
|
||||
pub fn new() -> io::Result<Self> {
|
||||
File::open("/scheme/input/producer").map(ProducerHandle)
|
||||
}
|
||||
|
||||
pub fn write_event(&mut self, event: orbclient::Event) -> io::Result<()> {
|
||||
self.0.write(&event)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,663 @@
|
||||
//! `:input`
|
||||
//!
|
||||
//! A seperate scheme is required since all of the input from different input devices is required
|
||||
//! to be combined into a single stream which is later going to be processed by the "consumer"
|
||||
//! which usually is Orbital.
|
||||
//!
|
||||
//! ## Input Device ("producer")
|
||||
//! Write events to `input:producer`.
|
||||
//!
|
||||
//! ## Input Consumer ("consumer")
|
||||
//! Read events from `input:consumer`. Optionally, set the `EVENT_READ` flag to be notified when
|
||||
//! events are available.
|
||||
|
||||
use core::mem::size_of;
|
||||
use std::borrow::Cow;
|
||||
use std::collections::BTreeSet;
|
||||
use std::mem::transmute;
|
||||
use std::ops::ControlFlow;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use inputd::{ControlEvent, VtEvent, VtEventKind};
|
||||
|
||||
use libredox::errno::ESTALE;
|
||||
use redox_scheme::scheme::SchemeSync;
|
||||
use redox_scheme::{CallerCtx, OpenResult, Response, SignalBehavior, Socket};
|
||||
|
||||
use orbclient::{Event, EventOption};
|
||||
use scheme_utils::{Blocking, FpathWriter, HandleMap};
|
||||
use syscall::schemev2::NewFdFlags;
|
||||
use syscall::{Error as SysError, EventFlags, EACCES, EBADF, EEXIST, EINVAL};
|
||||
|
||||
pub mod keymap;
|
||||
|
||||
use keymap::KeymapKind;
|
||||
|
||||
use crate::keymap::KeymapData;
|
||||
|
||||
enum Handle {
|
||||
Producer,
|
||||
Consumer {
|
||||
events: EventFlags,
|
||||
pending: Vec<u8>,
|
||||
/// We return an ESTALE error once to indicate that a handoff to a different graphics driver
|
||||
/// is necessary.
|
||||
needs_handoff: bool,
|
||||
notified: bool,
|
||||
vt: usize,
|
||||
},
|
||||
Display {
|
||||
events: EventFlags,
|
||||
pending: Vec<VtEvent>,
|
||||
notified: bool,
|
||||
device: String,
|
||||
/// Control of all VT's gets handed over from earlyfb devices to the first non-earlyfb device.
|
||||
is_earlyfb: bool,
|
||||
},
|
||||
Control,
|
||||
SchemeRoot,
|
||||
}
|
||||
|
||||
struct InputScheme {
|
||||
handles: HandleMap<Handle>,
|
||||
|
||||
next_vt_id: AtomicUsize,
|
||||
|
||||
display: Option<String>,
|
||||
vts: BTreeSet<usize>,
|
||||
super_key: bool,
|
||||
active_vt: Option<usize>,
|
||||
active_keymap: KeymapData,
|
||||
lshift: bool,
|
||||
rshift: bool,
|
||||
|
||||
has_new_events: bool,
|
||||
}
|
||||
|
||||
impl InputScheme {
|
||||
fn new() -> Self {
|
||||
Self {
|
||||
handles: HandleMap::new(),
|
||||
|
||||
next_vt_id: AtomicUsize::new(2), // VT 1 is reserved for the bootlog
|
||||
|
||||
display: None,
|
||||
vts: BTreeSet::new(),
|
||||
super_key: false,
|
||||
active_vt: None,
|
||||
// TODO: configurable init?
|
||||
active_keymap: KeymapData::new(KeymapKind::US),
|
||||
lshift: false,
|
||||
rshift: false,
|
||||
has_new_events: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn switch_vt(&mut self, new_active: usize) {
|
||||
if let Some(active_vt) = self.active_vt {
|
||||
if new_active == active_vt {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if !self.vts.contains(&new_active) {
|
||||
log::warn!("switch to non-existent VT #{new_active} was requested");
|
||||
return;
|
||||
}
|
||||
|
||||
log::debug!(
|
||||
"switching from VT #{} to VT #{new_active}",
|
||||
self.active_vt.unwrap_or(0)
|
||||
);
|
||||
|
||||
for handle in self.handles.values_mut() {
|
||||
match handle {
|
||||
Handle::Display {
|
||||
pending,
|
||||
notified,
|
||||
device,
|
||||
..
|
||||
} => {
|
||||
if self.display.as_deref() == Some(&*device) {
|
||||
pending.push(VtEvent {
|
||||
kind: VtEventKind::Activate,
|
||||
vt: new_active,
|
||||
});
|
||||
*notified = false;
|
||||
}
|
||||
}
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
|
||||
self.active_vt = Some(new_active);
|
||||
}
|
||||
|
||||
fn switch_keymap(&mut self, new_active: usize) {
|
||||
if new_active == self.active_keymap.get_kind() as usize {
|
||||
return;
|
||||
}
|
||||
|
||||
log::debug!(
|
||||
"switching from keymap #{} to keymap #{}",
|
||||
self.active_keymap.get_kind(),
|
||||
KeymapKind::from(new_active),
|
||||
);
|
||||
|
||||
self.active_keymap = KeymapData::new(new_active.into());
|
||||
}
|
||||
}
|
||||
|
||||
impl SchemeSync for InputScheme {
|
||||
fn scheme_root(&mut self) -> syscall::Result<usize> {
|
||||
Ok(self.handles.insert(Handle::SchemeRoot))
|
||||
}
|
||||
|
||||
fn openat(
|
||||
&mut self,
|
||||
dirfd: usize,
|
||||
path: &str,
|
||||
_flags: usize,
|
||||
_fcntl_flags: u32,
|
||||
_ctx: &CallerCtx,
|
||||
) -> syscall::Result<OpenResult> {
|
||||
if !matches!(self.handles.get(dirfd)?, Handle::SchemeRoot) {
|
||||
return Err(SysError::new(EACCES));
|
||||
}
|
||||
|
||||
let mut path_parts = path.split('/');
|
||||
|
||||
let command = path_parts.next().ok_or(SysError::new(EINVAL))?;
|
||||
|
||||
let handle_ty = match command {
|
||||
"producer" => Handle::Producer,
|
||||
"consumer" => {
|
||||
let vt = self.next_vt_id.fetch_add(1, Ordering::Relaxed);
|
||||
self.vts.insert(vt);
|
||||
|
||||
if self.active_vt.is_none() {
|
||||
self.switch_vt(vt);
|
||||
}
|
||||
Handle::Consumer {
|
||||
events: EventFlags::empty(),
|
||||
pending: Vec::new(),
|
||||
needs_handoff: false,
|
||||
notified: false,
|
||||
vt,
|
||||
}
|
||||
}
|
||||
"consumer_bootlog" => {
|
||||
if !self.vts.insert(1) {
|
||||
return Err(SysError::new(EEXIST));
|
||||
}
|
||||
|
||||
self.switch_vt(1);
|
||||
Handle::Consumer {
|
||||
events: EventFlags::empty(),
|
||||
pending: Vec::new(),
|
||||
needs_handoff: false,
|
||||
notified: false,
|
||||
vt: 1,
|
||||
}
|
||||
}
|
||||
"handle" | "handle_early" => {
|
||||
let display = path_parts.next().ok_or(SysError::new(EINVAL))?;
|
||||
|
||||
let needs_handoff = match command {
|
||||
"handle_early" => self.display.is_none(),
|
||||
"handle" => self.handles.values().all(|handle| {
|
||||
!matches!(
|
||||
handle,
|
||||
Handle::Display {
|
||||
is_earlyfb: false,
|
||||
..
|
||||
}
|
||||
)
|
||||
}),
|
||||
_ => unreachable!(),
|
||||
};
|
||||
|
||||
if needs_handoff {
|
||||
self.has_new_events = true;
|
||||
self.display = Some(display.to_owned());
|
||||
|
||||
for handle in self.handles.values_mut() {
|
||||
match handle {
|
||||
Handle::Consumer {
|
||||
needs_handoff,
|
||||
notified,
|
||||
..
|
||||
} => {
|
||||
*needs_handoff = true;
|
||||
*notified = false;
|
||||
}
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Handle::Display {
|
||||
events: EventFlags::empty(),
|
||||
pending: if let Some(active_vt) = self.active_vt {
|
||||
vec![VtEvent {
|
||||
kind: VtEventKind::Activate,
|
||||
vt: active_vt,
|
||||
}]
|
||||
} else {
|
||||
vec![]
|
||||
},
|
||||
notified: false,
|
||||
device: display.to_owned(),
|
||||
is_earlyfb: command == "handle_early",
|
||||
}
|
||||
}
|
||||
"control" => Handle::Control,
|
||||
|
||||
_ => {
|
||||
log::error!("invalid path '{path}'");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
};
|
||||
|
||||
log::debug!("{path} channel has been opened");
|
||||
|
||||
let fd = self.handles.insert(handle_ty);
|
||||
Ok(OpenResult::ThisScheme {
|
||||
number: fd,
|
||||
flags: NewFdFlags::empty(),
|
||||
})
|
||||
}
|
||||
|
||||
fn fpath(&mut self, id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> syscall::Result<usize> {
|
||||
let display = self.display.as_ref().ok_or(SysError::new(EINVAL))?;
|
||||
FpathWriter::with(buf, display, |w| {
|
||||
let handle = self.handles.get(id)?;
|
||||
|
||||
if let Handle::Consumer { vt, .. } = handle {
|
||||
write!(w, "{vt}").unwrap();
|
||||
Ok(())
|
||||
} else {
|
||||
Err(SysError::new(EINVAL))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn read(
|
||||
&mut self,
|
||||
id: usize,
|
||||
buf: &mut [u8],
|
||||
_offset: u64,
|
||||
_fcntl_flags: u32,
|
||||
_ctx: &CallerCtx,
|
||||
) -> syscall::Result<usize> {
|
||||
let handle = self.handles.get_mut(id)?;
|
||||
|
||||
match handle {
|
||||
Handle::Consumer {
|
||||
pending,
|
||||
needs_handoff,
|
||||
..
|
||||
} => {
|
||||
if *needs_handoff {
|
||||
*needs_handoff = false;
|
||||
// Indicates that handoff to a new graphics driver is necessary.
|
||||
return Err(SysError::new(ESTALE));
|
||||
}
|
||||
|
||||
let copy = core::cmp::min(pending.len(), buf.len());
|
||||
|
||||
for (i, byte) in pending.drain(..copy).enumerate() {
|
||||
buf[i] = byte;
|
||||
}
|
||||
|
||||
Ok(copy)
|
||||
}
|
||||
|
||||
Handle::Display { pending, .. } => {
|
||||
if buf.len() % size_of::<VtEvent>() == 0 {
|
||||
let copy = core::cmp::min(pending.len(), buf.len() / size_of::<VtEvent>());
|
||||
|
||||
for (i, event) in pending.drain(..copy).enumerate() {
|
||||
buf[i * size_of::<VtEvent>()..(i + 1) * size_of::<VtEvent>()]
|
||||
.copy_from_slice(&unsafe {
|
||||
transmute::<VtEvent, [u8; size_of::<VtEvent>()]>(event)
|
||||
});
|
||||
}
|
||||
Ok(copy * size_of::<VtEvent>())
|
||||
} else {
|
||||
log::error!("display tried to read incorrectly sized event");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
}
|
||||
|
||||
Handle::Producer => {
|
||||
log::error!("producer tried to read");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
Handle::Control => {
|
||||
log::error!("control tried to read");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
Handle::SchemeRoot => return Err(SysError::new(EBADF)),
|
||||
}
|
||||
}
|
||||
|
||||
fn write(
|
||||
&mut self,
|
||||
id: usize,
|
||||
buf: &[u8],
|
||||
_offset: u64,
|
||||
_fcntl_flags: u32,
|
||||
_ctx: &CallerCtx,
|
||||
) -> syscall::Result<usize> {
|
||||
self.has_new_events = true;
|
||||
|
||||
let handle = self.handles.get_mut(id)?;
|
||||
|
||||
match handle {
|
||||
Handle::Control => {
|
||||
if buf.len() != size_of::<ControlEvent>() {
|
||||
log::error!("control tried to write incorrectly sized command");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
|
||||
// SAFETY: We have verified the size of the buffer above.
|
||||
let cmd = unsafe { &*buf.as_ptr().cast::<ControlEvent>() };
|
||||
|
||||
match cmd.kind {
|
||||
1 => self.switch_vt(cmd.data),
|
||||
2 => self.switch_keymap(cmd.data),
|
||||
k => {
|
||||
log::warn!("unknown control {}", k);
|
||||
}
|
||||
}
|
||||
|
||||
return Ok(buf.len());
|
||||
}
|
||||
|
||||
Handle::Consumer { .. } => {
|
||||
log::error!("consumer tried to write");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
Handle::Display { .. } => {
|
||||
log::error!("display tried to write");
|
||||
return Err(SysError::new(EINVAL));
|
||||
}
|
||||
Handle::Producer => {}
|
||||
Handle::SchemeRoot => return Err(SysError::new(EBADF)),
|
||||
}
|
||||
|
||||
if buf.len() == 1 && buf[0] > 0xf4 {
|
||||
return Ok(1);
|
||||
}
|
||||
|
||||
let mut events = Cow::from(unsafe {
|
||||
core::slice::from_raw_parts(
|
||||
buf.as_ptr() as *const Event,
|
||||
buf.len() / size_of::<Event>(),
|
||||
)
|
||||
});
|
||||
|
||||
for i in 0..events.len() {
|
||||
let mut new_active_opt = None;
|
||||
match events[i].to_option() {
|
||||
EventOption::Key(mut key_event) => match key_event.scancode {
|
||||
f @ orbclient::K_F1..=orbclient::K_F10 if self.super_key => {
|
||||
new_active_opt = Some((f - 0x3A) as usize);
|
||||
}
|
||||
orbclient::K_F11 if self.super_key => {
|
||||
new_active_opt = Some(11);
|
||||
}
|
||||
orbclient::K_F12 if self.super_key => {
|
||||
new_active_opt = Some(12);
|
||||
}
|
||||
orbclient::K_SUPER => {
|
||||
self.super_key = key_event.pressed;
|
||||
}
|
||||
orbclient::K_LEFT_SHIFT => {
|
||||
self.lshift = key_event.pressed;
|
||||
}
|
||||
orbclient::K_RIGHT_SHIFT => {
|
||||
self.rshift = key_event.pressed;
|
||||
}
|
||||
|
||||
key => {
|
||||
let shift = self.lshift | self.rshift;
|
||||
let ev = self.active_keymap.get_char(key, shift);
|
||||
key_event.character = ev;
|
||||
events.to_mut()[i] = key_event.to_event();
|
||||
}
|
||||
},
|
||||
|
||||
_ => continue,
|
||||
}
|
||||
|
||||
if let Some(new_active) = new_active_opt {
|
||||
self.switch_vt(new_active);
|
||||
}
|
||||
}
|
||||
|
||||
let handle = self.handles.get_mut(id)?;
|
||||
assert!(matches!(handle, Handle::Producer));
|
||||
|
||||
let buf = unsafe {
|
||||
core::slice::from_raw_parts(
|
||||
(events.as_ptr()) as *const u8,
|
||||
events.len() * size_of::<Event>(),
|
||||
)
|
||||
};
|
||||
|
||||
if let Some(active_vt) = self.active_vt {
|
||||
for handle in self.handles.values_mut() {
|
||||
match handle {
|
||||
Handle::Consumer {
|
||||
pending,
|
||||
notified,
|
||||
vt,
|
||||
..
|
||||
} => {
|
||||
if *vt != active_vt {
|
||||
continue;
|
||||
}
|
||||
|
||||
pending.extend_from_slice(buf);
|
||||
*notified = false;
|
||||
}
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
fn fevent(
|
||||
&mut self,
|
||||
id: usize,
|
||||
flags: syscall::EventFlags,
|
||||
_ctx: &CallerCtx,
|
||||
) -> syscall::Result<syscall::EventFlags> {
|
||||
match self.handles.get_mut(id)? {
|
||||
Handle::Consumer {
|
||||
ref mut events,
|
||||
ref mut notified,
|
||||
..
|
||||
} => {
|
||||
*events = flags;
|
||||
*notified = false;
|
||||
Ok(EventFlags::empty())
|
||||
}
|
||||
Handle::Display {
|
||||
ref mut events,
|
||||
ref mut notified,
|
||||
..
|
||||
} => {
|
||||
*events = flags;
|
||||
*notified = false;
|
||||
Ok(EventFlags::empty())
|
||||
}
|
||||
Handle::Producer | Handle::Control => {
|
||||
log::error!("producer or control tried to use an event queue");
|
||||
Err(SysError::new(EINVAL))
|
||||
}
|
||||
Handle::SchemeRoot => Err(SysError::new(EBADF)),
|
||||
}
|
||||
}
|
||||
|
||||
fn on_close(&mut self, id: usize) {
|
||||
match self.handles.remove(id).unwrap() {
|
||||
Handle::Consumer { vt, .. } => {
|
||||
self.vts.remove(&vt);
|
||||
if self.active_vt == Some(vt) {
|
||||
if let Some(&new_vt) = self.vts.last() {
|
||||
self.switch_vt(new_vt);
|
||||
} else {
|
||||
self.active_vt = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn daemon(daemon: daemon::SchemeDaemon) -> anyhow::Result<()> {
|
||||
// Create the ":input" scheme.
|
||||
let socket_file = Socket::create()?;
|
||||
let mut scheme = InputScheme::new();
|
||||
let mut handler = Blocking::new(&socket_file, 16);
|
||||
|
||||
let _ = daemon.ready_sync_scheme(&socket_file, &mut scheme);
|
||||
|
||||
loop {
|
||||
scheme.has_new_events = false;
|
||||
match handler.process_requests_nonblocking(&mut scheme)? {
|
||||
ControlFlow::Continue(()) => {}
|
||||
ControlFlow::Break(()) => unreachable!("scheme should be non-blocking"),
|
||||
}
|
||||
|
||||
if !scheme.has_new_events {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (id, handle) in scheme.handles.iter_mut() {
|
||||
match handle {
|
||||
Handle::Consumer {
|
||||
events,
|
||||
pending,
|
||||
needs_handoff,
|
||||
ref mut notified,
|
||||
..
|
||||
} => {
|
||||
if (!*needs_handoff && pending.is_empty())
|
||||
|| *notified
|
||||
|| !events.contains(EventFlags::EVENT_READ)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// Notify the consumer that we have some events to read. Yum yum.
|
||||
socket_file.write_response(
|
||||
Response::post_fevent(*id, EventFlags::EVENT_READ.bits()),
|
||||
SignalBehavior::Restart,
|
||||
)?;
|
||||
|
||||
*notified = true;
|
||||
}
|
||||
Handle::Display {
|
||||
events,
|
||||
pending,
|
||||
ref mut notified,
|
||||
..
|
||||
} => {
|
||||
if pending.is_empty() || *notified || !events.contains(EventFlags::EVENT_READ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Notify the consumer that we have some events to read. Yum yum.
|
||||
socket_file.write_response(
|
||||
Response::post_fevent(*id, EventFlags::EVENT_READ.bits()),
|
||||
SignalBehavior::Restart,
|
||||
)?;
|
||||
|
||||
*notified = true;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn daemon_runner(redox_daemon: daemon::SchemeDaemon) -> ! {
|
||||
daemon(redox_daemon).unwrap();
|
||||
unreachable!();
|
||||
}
|
||||
|
||||
const HELP: &str = r#"
|
||||
inputd [-K keymap|-A vt|--keymaps]
|
||||
-A vt : set current virtual display
|
||||
-K keymap : set keyboard mapping
|
||||
--keymaps : list available keyboard mappings
|
||||
"#;
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
|
||||
if let Some(val) = args.next() {
|
||||
// TODO: Get current VT or keymap
|
||||
match val.as_ref() {
|
||||
// Activates a VT.
|
||||
"-A" => {
|
||||
let vt = args.next().unwrap().parse::<usize>().unwrap();
|
||||
|
||||
let mut handle =
|
||||
inputd::ControlHandle::new().expect("inputd: failed to open control handle");
|
||||
handle
|
||||
.activate_vt(vt)
|
||||
.expect("inputd: failed to activate VT");
|
||||
}
|
||||
// Activates a keymap.
|
||||
"-K" => {
|
||||
let arg = if let Some(a) = args.next() {
|
||||
a
|
||||
} else {
|
||||
eprintln!("Error: Option -K requires a layout argument.");
|
||||
std::process::exit(1);
|
||||
};
|
||||
|
||||
let vt: KeymapKind = arg.to_ascii_lowercase().parse().unwrap_or_else(|_| {
|
||||
eprintln!("inputd: unrecognized keymap code (see: inputd --keymaps)");
|
||||
std::process::exit(1);
|
||||
});
|
||||
|
||||
let mut handle =
|
||||
inputd::ControlHandle::new().expect("inputd: failed to open control handle");
|
||||
handle
|
||||
.activate_keymap(vt as usize)
|
||||
.expect("inputd: failed to activate keymap");
|
||||
}
|
||||
// List available keymaps
|
||||
"--keymaps" => {
|
||||
// TODO: configurable KeymapKind using files
|
||||
for key in vec!["dvorak", "us", "gb", "azerty", "bepo", "it"] {
|
||||
println!("{}", key);
|
||||
}
|
||||
}
|
||||
"--help" => {
|
||||
println!("{}", HELP);
|
||||
}
|
||||
|
||||
_ => panic!("inputd: invalid argument: {}", val),
|
||||
}
|
||||
} else {
|
||||
common::setup_logging(
|
||||
"input",
|
||||
"inputd",
|
||||
"inputd",
|
||||
common::output_level(),
|
||||
common::file_level(),
|
||||
);
|
||||
|
||||
daemon::SchemeDaemon::new(daemon_runner);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user