vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions 17 Packages Projects Releases Wiki Activity

inputd: Implement keymap

Browse Source
This commit is contained in:
Wildan M
2026-01-14 11:35:48 +07:00
parent 6091b46620
commit 3d04f523b4
14 changed files with 645 additions and 1302 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/input/ps2d/src/keymap.rs
-478
View File
@@ -1,478 +0,0 @@
pub mod us {
static US: [[char; 2]; 58] = [
['\0', '\0'],
['\x1B', '\x1B'],
['1', '!'],
['2', '@'],
['3', '#'],
['4', '$'],
['5', '%'],
['6', '^'],
['7', '&'],
['8', '*'],
['9', '('],
['0', ')'],
['-', '_'],
['=', '+'],
['\x7F', '\x7F'],
['\t', '\t'],
['q', 'Q'],
['w', 'W'],
['e', 'E'],
['r', 'R'],
['t', 'T'],
['y', 'Y'],
['u', 'U'],
['i', 'I'],
['o', 'O'],
['p', 'P'],
['[', '{'],
[']', '}'],
['\n', '\n'],
['\0', '\0'],
['a', 'A'],
['s', 'S'],
['d', 'D'],
['f', 'F'],
['g', 'G'],
['h', 'H'],
['j', 'J'],
['k', 'K'],
['l', 'L'],
[';', ':'],
['\'', '"'],
['`', '~'],
['\0', '\0'],
['\\', '|'],
['z', 'Z'],
['x', 'X'],
['c', 'C'],
['v', 'V'],
['b', 'B'],
['n', 'N'],
['m', 'M'],
[',', '<'],
['.', '>'],
['/', '?'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
[' ', ' '],
];
pub fn get_char(scancode: u8, shift: bool) -> char {
if let Some(c) = US.get(scancode as usize) {
if shift {
c[1]
} else {
c[0]
}
} else {
'\0'
}
}
}
pub mod gb {
static GB: [[char; 2]; 87] = [
['\0', '\0'],
['\x1B', '\x1B'],
['1', '!'],
['2', '"'],
['3', '£'],
['4', '$'],
['5', '%'],
['6', '^'],
['7', '&'],
['8', '*'],
['9', '('],
['0', ')'],
['-', '_'],
['=', '+'],
['\x7F', '\x7F'],
['\t', '\t'],
['q', 'Q'],
['w', 'W'],
['e', 'E'],
['r', 'R'],
['t', 'T'],
['y', 'Y'],
['u', 'U'],
['i', 'I'],
['o', 'O'],
['p', 'P'],
['[', '{'],
[']', '}'],
['\n', '\n'],
['\0', '\0'],
['a', 'A'],
['s', 'S'],
['d', 'D'],
['f', 'F'],
['g', 'G'],
['h', 'H'],
['j', 'J'],
['k', 'K'],
['l', 'L'],
[';', ':'],
['\'', '@'],
['`', '¬'],
['\0', '\0'],
['#', '~'],
['z', 'Z'],
['x', 'X'],
['c', 'C'],
['v', 'V'],
['b', 'B'],
['n', 'N'],
['m', 'M'],
[',', '<'],
['.', '>'],
['/', '?'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
[' ', ' '],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
['\\', '|'],
];
pub fn get_char(scancode: u8, shift: bool) -> char {
if let Some(c) = GB.get(scancode as usize) {
if shift {
c[1]
} else {
c[0]
}
} else {
'\0'
}
}
}
pub mod dvorak {
static DVORAK: [[char; 2]; 58] = [
['\0', '\0'],
['\x1B', '\x1B'],
['1', '!'],
['2', '@'],
['3', '#'],
['4', '$'],
['5', '%'],
['6', '^'],
['7', '&'],
['8', '*'],
['9', '('],
['0', ')'],
['[', '{'],
[']', '}'],
['\x7F', '\x7F'],
['\t', '\t'],
['\'', '"'],
[',', '<'],
['.', '>'],
['p', 'P'],
['y', 'Y'],
['f', 'F'],
['g', 'G'],
['c', 'C'],
['r', 'R'],
['l', 'L'],
['/', '?'],
['=', '+'],
['\n', '\n'],
['\0', '\0'],
['a', 'A'],
['o', 'O'],
['e', 'E'],
['u', 'U'],
['i', 'I'],
['d', 'D'],
['h', 'H'],
['t', 'T'],
['n', 'N'],
['s', 'S'],
['-', '_'],
['`', '~'],
['\0', '\0'],
['\\', '|'],
[';', ':'],
['q', 'Q'],
['j', 'J'],
['k', 'K'],
['x', 'X'],
['b', 'B'],
['m', 'M'],
['w', 'W'],
['v', 'V'],
['z', 'Z'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
[' ', ' '],
];
pub fn get_char(scancode: u8, shift: bool) -> char {
if let Some(c) = DVORAK.get(scancode as usize) {
if shift {
c[1]
} else {
c[0]
}
} else {
'\0'
}
}
}
pub mod azerty {
static AZERTY: [[char; 2]; 58] = [
['\0', '\0'],
['\x1B', '\x1B'],
['&', '1'],
['é', '2'],
['"', '3'],
['\'', '4'],
['(', '5'],
['|', '6'],
['è', '7'],
['_', '8'],
['ç', '9'],
['à', '0'],
[')', '°'],
['=', '+'],
['\x7F', '\x7F'],
['\t', '\t'],
['a', 'A'],
['z', 'Z'],
['e', 'E'],
['r', 'R'],
['t', 'T'],
['y', 'Y'],
['u', 'U'],
['i', 'I'],
['o', 'O'],
['p', 'P'],
['^', '¨'],
['$', '£'],
['\n', '\n'],
['\0', '\0'],
['q', 'Q'],
['s', 'S'],
['d', 'D'],
['f', 'F'],
['g', 'G'],
['h', 'H'],
['j', 'J'],
['k', 'K'],
['l', 'L'],
['m', 'M'],
['ù', '%'],
['*', 'µ'],
['\0', '\0'],
['ê', 'Ê'],
['w', 'W'],
['x', 'X'],
['c', 'C'],
['v', 'V'],
['b', 'B'],
['n', 'N'],
[',', '?'],
[';', '.'],
[':', '/'],
['!', '§'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
[' ', ' '],
];
pub fn get_char(scancode: u8, shift: bool) -> char {
if let Some(c) = AZERTY.get(scancode as usize) {
if shift {
c[1]
} else {
c[0]
}
} else {
'\0'
}
}
}
pub mod bepo {
static BEPO: [[char; 2]; 58] = [
['\0', '\0'],
['\x1B', '\x1B'],
['"', '1'],
['«', '2'],
['»', '3'],
['(', '4'],
[')', '5'],
['@', '6'],
['+', '7'],
['-', '8'],
['/', '9'],
['*', '0'],
['=', '°'],
['%', '`'],
['\x7F', '\x7F'],
['\t', '\t'],
['b', 'B'],
['é', 'É'],
['p', 'P'],
['o', 'O'],
['è', 'È'],
['^', '!'],
['v', 'V'],
['d', 'D'],
['l', 'L'],
['j', 'J'],
['z', 'Z'],
['w', 'W'],
['\n', '\n'],
['\0', '\0'],
['a', 'A'],
['u', 'U'],
['i', 'I'],
['e', 'E'],
[',', ';'],
['c', 'C'],
['t', 'T'],
['s', 'S'],
['r', 'R'],
['n', 'N'],
['m', 'M'],
['ç', 'Ç'],
['\0', '\0'],
['ê', 'Ê'],
['à', 'À'],
['y', 'Y'],
['x', 'X'],
['.', ':'],
['k', 'K'],
['\'', '?'],
['q', 'Q'],
['g', 'G'],
['h', 'H'],
['f', 'F'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
[' ', ' '],
];
pub fn get_char(scancode: u8, shift: bool) -> char {
if let Some(c) = BEPO.get(scancode as usize) {
if shift {
c[1]
} else {
c[0]
}
} else {
'\0'
}
}
}
pub mod it {
static IT: [[char; 2]; 58] = [
['\0', '\0'],
['\x1B', '\x1B'],
['1', '!'],
['2', '"'],
['3', '£'],
['4', '$'],
['5', '%'],
['6', '&'],
['7', '/'],
['8', '('],
['9', ')'],
['0', '='],
['?', '\''],
['ì', '^'],
['\x7F', '\x7F'],
['\t', '\t'],
['q', 'Q'],
['w', 'W'],
['e', 'E'],
['r', 'R'],
['t', 'T'],
['y', 'Y'],
['u', 'U'],
['i', 'I'],
['o', 'O'],
['p', 'P'],
['è', 'é'],
['+', '*'],
['\n', '\n'],
['\x20', '\x20'],
['a', 'A'],
['s', 'S'],
['d', 'D'],
['f', 'F'],
['g', 'G'],
['h', 'H'],
['j', 'J'],
['k', 'K'],
['l', 'L'],
['ò', 'ç'],
['à', '°'],
['ù', '§'],
['\0', '\0'],
['<', '>'],
['z', 'Z'],
['x', 'X'],
['c', 'C'],
['v', 'V'],
['b', 'B'],
['n', 'N'],
['m', 'M'],
[',', ';'],
['.', ':'],
['-', '_'],
['\0', '\0'],
['\0', '\0'],
['\0', '\0'],
[' ', ' '],
];
pub fn get_char(scancode: u8, shift: bool) -> char {
if let Some(c) = IT.get(scancode as usize) {
if shift {
c[1]
} else {
c[0]
}
} else {
'\0'
}
}
}
drivers/input/ps2d/src/main.rs
+1 -76
View File
@@ -12,16 +12,10 @@ use std::{env, process};
use common::acquire_port_io_rights;
use event::{user_data, EventQueue};
use inputd::ProducerHandle;
use log::info;
use redox_scheme::{RequestKind, SignalBehavior, Socket};
use syscall::{EAGAIN, EWOULDBLOCK};
use crate::scheme::Ps2Scheme;
use crate::state::Ps2d;
mod controller;
mod keymap;
mod scheme;
mod state;
mod vm;
@@ -36,21 +30,12 @@ fn daemon(daemon: daemon::Daemon) -> ! {
acquire_port_io_rights().expect("ps2d: failed to get I/O permission");
let (mut keymap, mut keymap_name): (fn(u8, bool) -> char, &str) =
match env::args().skip(1).next() {
Some(k) => get_keymap_from_str(&k),
None => (keymap::us::get_char, "us"),
};
info!("ps2d: using keymap '{}'", keymap_name);
let input = ProducerHandle::new().expect("ps2d: failed to open input producer");
user_data! {
enum Source {
Keyboard,
Mouse,
Scheme,
}
}
@@ -87,26 +72,11 @@ fn daemon(daemon: daemon::Daemon) -> ! {
)
.unwrap();
let scheme_file = Socket::nonblock("ps2").expect("ps2d: failed to create ps2 scheme");
let mut scheme_handle = Ps2Scheme::new(
keymap_name.to_owned(),
vec!["dvorak", "us", "gb", "azerty", "bepo", "it"],
);
event_queue
.subscribe(
scheme_file.inner().raw(),
Source::Scheme,
event::EventFlags::READ,
)
.unwrap();
libredox::call::setrens(0, 0).expect("ps2d: failed to enter null namespace");
daemon.ready();
let mut ps2d = Ps2d::new(input, keymap);
let mut ps2d = Ps2d::new(input);
let mut data = [0; 256];
for event in event_queue.map(|e| e.expect("ps2d: failed to get next event").user_data) {
@@ -122,39 +92,6 @@ fn daemon(daemon: daemon::Daemon) -> ! {
let (file, keyboard) = match event {
Source::Keyboard => (&mut key_file, true),
Source::Mouse => (&mut mouse_file, false),
Source::Scheme => {
loop {
let request = match scheme_file.next_request(SignalBehavior::Interrupt) {
Ok(Some(request)) => request,
Ok(None) => {
// Scheme likely got unmounted
std::process::exit(0);
}
Err(err) if err.errno == EWOULDBLOCK || err.errno == EAGAIN => break,
Err(err) => panic!("ps2: failed to read scheme: {:?}", err),
};
match request.kind() {
RequestKind::Call(call) => {
let response = call.handle_sync(&mut scheme_handle);
scheme_file
.write_response(response, SignalBehavior::Restart)
.expect("ps2: failed to write next scheme response");
}
RequestKind::OnClose { id: _ } => {}
_ => (),
}
}
if keymap_name != &scheme_handle.keymap {
(keymap, keymap_name) = get_keymap_from_str(&scheme_handle.keymap);
info!("ps2d: updating to new keymap '{:?}'", keymap_name);
ps2d.update_keymap(keymap);
}
continue;
}
};
loop {
@@ -172,18 +109,6 @@ fn daemon(daemon: daemon::Daemon) -> ! {
process::exit(0);
}
fn get_keymap_from_str(k: &str) -> (fn(u8, bool) -> char, &'static str) {
match k.to_lowercase().as_ref() {
"dvorak" => (keymap::dvorak::get_char, "dvorak"),
"us" => (keymap::us::get_char, "us"),
"gb" => (keymap::gb::get_char, "gb"),
"azerty" => (keymap::azerty::get_char, "azerty"),
"bepo" => (keymap::bepo::get_char, "bepo"),
"it" => (keymap::it::get_char, "it"),
&_ => (keymap::us::get_char, "us"),
}
}
fn main() {
daemon::Daemon::new(daemon);
}
drivers/input/ps2d/src/scheme.rs
-145
View File
@@ -1,145 +0,0 @@
use redox_scheme::scheme::SchemeSync;
use redox_scheme::{CallerCtx, OpenResult};
use std::convert::TryFrom;
use syscall::dirent::{DirEntry, DirentBuf, DirentKind};
use syscall::schemev2::NewFdFlags;
use syscall::{
Error, Result, EACCES, EINVAL, EMFILE, ENOENT, ENOTDIR, MODE_DIR, MODE_FILE, O_WRONLY,
};
pub struct Ps2Scheme {
pub keymap: String,
pub keymap_list: String,
}
impl Ps2Scheme {
pub fn new(keymap: String, keymap_list: Vec<&str>) -> Ps2Scheme {
let scheme = Ps2Scheme {
keymap,
keymap_list: keymap_list.join("\n"),
};
scheme
}
}
impl SchemeSync for Ps2Scheme {
fn open(&mut self, path_str: &str, flags: usize, ctx: &CallerCtx) -> Result<OpenResult> {
let path = path_str.trim_start_matches('/');
if flags & O_WRONLY != 0 {
if ctx.uid != 0 || ctx.gid != 0 {
return Err(Error::new(EACCES));
} else if path != "keymap" {
return Err(Error::new(EINVAL));
}
}
match path {
"" => Ok(OpenResult::ThisScheme {
number: 0,
flags: NewFdFlags::empty(),
}),
"keymap" => Ok(OpenResult::ThisScheme {
number: 1,
flags: NewFdFlags::POSITIONED,
}),
"keymap_list" => Ok(OpenResult::ThisScheme {
number: 2,
flags: NewFdFlags::POSITIONED,
}),
_ => Err(Error::new(ENOENT)),
}
}
fn getdents<'buf>(
&mut self,
id: usize,
mut buf: DirentBuf<&'buf mut [u8]>,
opaque_offset: u64,
) -> Result<DirentBuf<&'buf mut [u8]>> {
if id != 0 {
return Err(Error::new(ENOTDIR));
}
let Ok(offset) = usize::try_from(opaque_offset) else {
return Ok(buf);
};
for (this_idx, name) in ["keymap", "keymap_list"].iter().enumerate().skip(offset) {
buf.entry(DirEntry {
inode: this_idx as u64,
next_opaque_id: this_idx as u64 + 1,
kind: DirentKind::Regular,
name,
})?;
}
Ok(buf)
}
fn fstat(&mut self, id: usize, stat: &mut syscall::Stat, _ctx: &CallerCtx) -> Result<()> {
stat.st_size = 0;
stat.st_mode = match id {
0 => 0o555 | MODE_DIR,
1 => 0o644 | MODE_FILE,
2 => 0o444 | MODE_FILE,
_ => return Err(Error::new(ENOENT)),
};
Ok(())
}
fn fpath(&mut self, _id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> Result<usize> {
let path = b"/scheme/ps2";
let mut i = 0;
while i < buf.len() && i < path.len() {
buf[i] = path[i];
i += 1;
}
Ok(i)
}
fn fsync(&mut self, _id: usize, _ctx: &CallerCtx) -> Result<()> {
Ok(())
}
fn read(
&mut self,
id: usize,
buf: &mut [u8],
offset: u64,
_fcntl_flags: u32,
_ctx: &CallerCtx,
) -> Result<usize> {
if offset != 0 {
return Ok(0);
}
let value = match id {
1 => self.keymap.as_bytes(),
2 => self.keymap_list.as_bytes(),
_ => {
return Err(Error::new(ENOENT));
}
};
if buf.len() + 2 < value.len() {
return Err(Error::new(EMFILE));
}
buf[..value.len()].copy_from_slice(value);
buf[value.len()] = b'\n';
buf[value.len() + 1] = b'\0';
Ok(value.len() + 2)
}
fn write(
&mut self,
id: usize,
buf: &[u8],
offset: u64,
_fcntl_flags: u32,
_ctx: &CallerCtx,
) -> Result<usize> {
if offset != 0 || id != 1 {
return Ok(0);
}
let new_keymap = String::from_utf8(buf.to_vec()).map_err(|_| Error::new(EINVAL))?;
self.keymap = new_keymap.trim().to_string();
Ok(buf.len())
}
}
drivers/input/ps2d/src/state.rs
+28 -43
View File
@@ -18,14 +18,12 @@ bitflags! {
}
}
pub struct Ps2d<F: Fn(u8, bool) -> char> {
pub struct Ps2d {
ps2: Ps2,
vmmouse: bool,
vmmouse_relative: bool,
input: ProducerHandle,
extended: bool,
lshift: bool,
rshift: bool,
mouse_x: i32,
mouse_y: i32,
mouse_left: bool,
@@ -34,12 +32,10 @@ pub struct Ps2d<F: Fn(u8, bool) -> char> {
packets: [u8; 4],
packet_i: usize,
extra_packet: bool,
//Keymap function
get_char: F,
}
impl<F: Fn(u8, bool) -> char> Ps2d<F> {
pub fn new(input: ProducerHandle, keymap: F) -> Self {
impl Ps2d {
pub fn new(input: ProducerHandle) -> Self {
let mut ps2 = Ps2::new();
let extra_packet = ps2.init();
@@ -53,8 +49,6 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
vmmouse_relative,
input,
extended: false,
lshift: false,
rshift: false,
mouse_x: 0,
mouse_y: 0,
mouse_left: false,
@@ -63,14 +57,9 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
packets: [0; 4],
packet_i: 0,
extra_packet,
get_char: keymap,
}
}
pub fn update_keymap(&mut self, keymap: F) {
self.get_char = keymap;
}
pub fn irq(&mut self) {
while let Some((keyboard, data)) = self.ps2.next() {
self.handle(keyboard, data);
@@ -91,13 +80,16 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
let scancode = if self.extended {
self.extended = false;
match ps2_scancode {
//TODO: media keys
//TODO: 0x1C => orbclient::K_NUM_ENTER,
0x1D => orbclient::K_CTRL, //TODO: 0x1D => orbclient::K_RIGHT_CTRL,
0x20 => 0x80 + 0x20, //TODO: orbclient::K_VOLUME_MUTE,
0x2E => 0x80 + 0x2E, //TODO: orbclient::K_VOLUME_DOWN,
0x30 => 0x80 + 0x30, //TODO: orbclient::K_VOLUME_UP,
//TODO: 0x35 => orbclient::K_NUM_SLASH,
0x1C => orbclient::K_NUM_ENTER,
0x1D => orbclient::K_RIGHT_CTRL,
0x20 => orbclient::K_VOLUME_TOGGLE,
0x22 => orbclient::K_MEDIA_PLAY_PAUSE,
0x24 => orbclient::K_MEDIA_STOP,
0x10 => orbclient::K_MEDIA_REWIND,
0x19 => orbclient::K_MEDIA_FAST_FORWARD,
0x2E => orbclient::K_VOLUME_DOWN,
0x30 => orbclient::K_VOLUME_UP,
0x35 => orbclient::K_NUM_SLASH,
0x38 => orbclient::K_ALT_GR,
0x47 => orbclient::K_HOME,
0x48 => orbclient::K_UP,
@@ -107,12 +99,13 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
0x4F => orbclient::K_END,
0x50 => orbclient::K_DOWN,
0x51 => orbclient::K_PGDN,
//TODO: 0x52 => orbclient::K_INSERT,
0x52 => orbclient::K_INS,
0x53 => orbclient::K_DEL,
0x5B => 0x5B, //TODO: orbclient::K_LEFT_SUPER,
//TODO: 0x5C => orbclient::K_RIGHT_SUPER,
//TODO: 0x5D => orbclient::K_APP,
//TODO power keys
0x5B => orbclient::K_LEFT_SUPER,
0x5C => orbclient::K_RIGHT_SUPER,
0x5D => orbclient::K_APP,
0x5E => orbclient::K_POWER,
0x5F => orbclient::K_SLEEP,
/* 0x80 to 0xFF used for press/release detection */
_ => {
if pressed {
@@ -178,7 +171,7 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
0x34 => orbclient::K_PERIOD,
0x35 => orbclient::K_SLASH,
0x36 => orbclient::K_RIGHT_SHIFT,
//TODO: 0x37 => orbclient::K_NUM_ASTERISK,
0x37 => orbclient::K_NUM_ASTERISK,
0x38 => orbclient::K_ALT,
0x39 => orbclient::K_SPACE,
0x3A => orbclient::K_CAPS,
@@ -192,22 +185,23 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
0x42 => orbclient::K_F8,
0x43 => orbclient::K_F9,
0x44 => orbclient::K_F10,
//TODO: 0x45 => orbclient::K_NUM_LOCK,
//TODO: 0x46 => orbclient::K_SCROLL_LOCK,
0x45 => orbclient::K_NUM,
0x46 => orbclient::K_SCROLL,
0x47 => orbclient::K_NUM_7,
0x48 => orbclient::K_NUM_8,
0x49 => orbclient::K_NUM_9,
//TODO: 0x4A => orbclient::K_NUM_MINUS,
0x4A => orbclient::K_NUM_MINUS,
0x4B => orbclient::K_NUM_4,
0x4C => orbclient::K_NUM_5,
0x4D => orbclient::K_NUM_6,
//TODO: 0x4E => orbclient::K_NUM_PLUS,
0x4E => orbclient::K_NUM_PLUS,
0x4F => orbclient::K_NUM_1,
0x50 => orbclient::K_NUM_2,
0x51 => orbclient::K_NUM_3,
0x52 => orbclient::K_NUM_0,
//TODO: 0x53 => orbclient::K_NUM_PERIOD,
/* 0x54 to 0x56 unused */
0x53 => orbclient::K_NUM_PERIOD,
/* 0x54 to 0x55 unused */
0x56 => 0x56, // UK Backslash
0x57 => orbclient::K_F11,
0x58 => orbclient::K_F12,
/* 0x59 to 0x7F unused */
@@ -221,20 +215,11 @@ impl<F: Fn(u8, bool) -> char> Ps2d<F> {
}
};
if scancode == orbclient::K_LEFT_SHIFT {
self.lshift = pressed;
} else if scancode == orbclient::K_RIGHT_SHIFT {
self.rshift = pressed;
}
if scancode != 0 {
self.input
.write_event(
KeyEvent {
character: (self.get_char)(
ps2_scancode,
self.lshift || self.rshift,
),
character: '\0',
scancode,
pressed,
}