atmos/kernel/

keyboard.rs

#[derive(Debug, Clone, Copy)]
pub struct KeyEvent {
    pub keycode: u8,
    pub pressed: bool,
}

use core::sync::atomic::{AtomicU8, Ordering};

/// グローバル修飾キー状態。ビット 0=Shift, 1=Ctrl, 2=Alt, 3=Meta。
/// キーボードデコード時に更新され、JS の DOM イベント（MouseEvent/KeyboardEvent）が
/// shiftKey/ctrlKey/altKey/metaKey を読むために参照する。割り込み文脈からも触れるよう
/// ロックフリーの Atomic にしている。
static MODIFIER_STATE: AtomicU8 = AtomicU8::new(0);

pub const MOD_SHIFT: u8 = 1 << 0;
pub const MOD_CTRL: u8 = 1 << 1;
pub const MOD_ALT: u8 = 1 << 2;
pub const MOD_META: u8 = 1 << 3;

/// 現在の修飾キー状態ビットマスクを取得する。
pub fn modifier_state() -> u8 {
    MODIFIER_STATE.load(Ordering::Relaxed)
}

/// 個々の修飾キーが押されているか。
pub fn shift_down() -> bool {
    modifier_state() & MOD_SHIFT != 0
}
pub fn ctrl_down() -> bool {
    modifier_state() & MOD_CTRL != 0
}
pub fn alt_down() -> bool {
    modifier_state() & MOD_ALT != 0
}
pub fn meta_down() -> bool {
    modifier_state() & MOD_META != 0
}

/// 1つの修飾キーの押下状態を設定する（内部用）。
fn set_modifier(bit: u8, pressed: bool) {
    let cur = MODIFIER_STATE.load(Ordering::Relaxed);
    let next = if pressed { cur | bit } else { cur & !bit };
    MODIFIER_STATE.store(next, Ordering::Relaxed);
}

/// Ctrl+K (KillLine) 用の論理キーコード（センチネル）。
/// 実キーには割り当てられていない 0x5A を用い、Ctrl+K を OS 共通の
/// 「カーソル位置から行末まで削除」キーとして全テキスト入力へ届ける。
pub const KC_KILL_LINE: u8 = 0x5A;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyboardLayout {
    Us,
    Jis,
}

impl KeyboardLayout {
    pub const fn name(self) -> &'static str {
        match self {
            Self::Us => "US",
            Self::Jis => "JIS",
        }
    }

    pub fn parse(name: &str) -> Option<Self> {
        if name.eq_ignore_ascii_case("us") {
            Some(Self::Us)
        } else if name.eq_ignore_ascii_case("js")
            || name.eq_ignore_ascii_case("jis")
            || name.eq_ignore_ascii_case("jp")
        {
            Some(Self::Jis)
        } else {
            None
        }
    }
}

pub struct Keyboard {
    pub shift_pressed: bool,
    pub ctrl_pressed: bool,
    pub alt_pressed: bool,
    layout: KeyboardLayout,
    logical_map: [u8; 128],
}

impl Default for Keyboard {
    fn default() -> Self {
        Self::new()
    }
}

impl Keyboard {
    pub const fn new() -> Self {
        Self {
            shift_pressed: false,
            ctrl_pressed: false,
            alt_pressed: false,
            layout: KeyboardLayout::Jis,
            logical_map: [0; 128],
        }
    }

    pub fn set_layout(&mut self, layout: KeyboardLayout) {
        self.layout = layout;
    }

    pub const fn layout(&self) -> KeyboardLayout {
        self.layout
    }

    /// スキャンコード（Make/Break）をデコードしてキーイベントを生成します
    pub fn decode(&mut self, code: u8) -> Option<KeyEvent> {
        // 最上位ビットが0ならMake (押下)、1ならBreak (離鍵)
        let pressed = (code & 0x80) == 0;
        let phys_keycode = code & 0x7F;

        if phys_keycode >= 128 {
            return None;
        }

        let mut keycode = phys_keycode;

        if pressed {
            // CapsLock ➔ Ctrl 置換の適用 (CapsLock=0x3A ➔ LCtrl=0x1D)
            if keycode == 0x3A && crate::kernel::config::get_config().swap_caps_ctrl {
                keycode = 0x1D;
            }

            // Ctrl + 各種キーの Emacs ライクな変換 (Ctrl + H ➔ Backspace などのショートカットを網羅)
            if self.ctrl_pressed {
                if let Some(c) = alpha_char(keycode, self.shift_pressed) {
                    match c.to_ascii_lowercase() {
                        'p' => keycode = 0x48,         // Up
                        'n' => keycode = 0x50,         // Down
                        'b' => keycode = 0x4B,         // Left
                        'f' => keycode = 0x4D,         // Right
                        'a' => keycode = 0x47,         // Home
                        'e' => keycode = 0x4F,         // End
                        'h' => keycode = 0x0E,         // Backspace
                        'd' => keycode = 0x53,         // Delete
                        'k' => keycode = KC_KILL_LINE, // KillLine (行末まで削除)
                        _ => {}
                    }
                }
            }

            // Make 時の論理キーコードを保存
            self.logical_map[phys_keycode as usize] = keycode;
        } else {
            // Break 時は Make 時と同一の論理キーコードを復元
            let mapped = self.logical_map[phys_keycode as usize];
            if mapped != 0 {
                keycode = mapped;
                self.logical_map[phys_keycode as usize] = 0;
            } else {
                if keycode == 0x3A && crate::kernel::config::get_config().swap_caps_ctrl {
                    keycode = 0x1D;
                }
            }
        }

        // 特殊キー（Shift, Ctrl, Alt）の状態管理
        match keycode {
            0x2A | 0x36 => {
                // LShift, RShiftのスキャンコード
                self.shift_pressed = pressed;
                set_modifier(MOD_SHIFT, pressed);
            }
            0x1D => {
                // LCtrlのスキャンコード
                self.ctrl_pressed = pressed;
                set_modifier(MOD_CTRL, pressed);
            }
            0x38 => {
                // LAltのスキャンコード
                self.alt_pressed = pressed;
                set_modifier(MOD_ALT, pressed);
            }
            _ => {}
        }

        Some(KeyEvent { keycode, pressed })
    }

    /// キーコードに対応する文字（ASCII）を取得します（Shift対応）
    pub fn get_ascii(&self, keycode: u8) -> Option<char> {
        if let Some(letter) = alpha_char(keycode, self.shift_pressed) {
            return Some(letter);
        }

        let layout = crate::kernel::config::get_config().keyboard_layout;
        match layout {
            KeyboardLayout::Us => us_ascii(keycode, self.shift_pressed),
            KeyboardLayout::Jis => jis_ascii(keycode, self.shift_pressed),
        }
    }
}

/// シリアルコンソール用: ASCII 文字を物理スキャンコードと Shift 要否へ逆変換する。
///
/// `alpha_char` とレイアウトの ascii テーブルを総当たりで照合するため、
/// `get_ascii` の定義と**常に一致**する (テーブルを二重管理しない)。
/// 戻り値 `(make_scancode, needs_shift)`。対応キーが無ければ `None`。
pub fn ascii_to_scancode(c: char, layout: KeyboardLayout) -> Option<(u8, bool)> {
    // 制御文字は直接対応キーへ
    match c {
        '\n' | '\r' => return Some((0x1C, false)),     // Enter
        '\x08' | '\x7f' => return Some((0x0E, false)), // Backspace
        '\t' => return Some((0x0F, false)),
        // 【2026-07-31】ESC が変換表から漏れていた。
        // シリアルコンソールから ESC を送っても捨てられるため、
        // ブラウザ起動後に抜ける手段（`main.rs` の keycode 0x01 判定）が
        // 使えず、ターミナルへコマンドを送れなくなっていた。
        '' => return Some((0x01, false)),
        _ => {}
    }
    for kc in 0u8..0x80 {
        for &shift in &[false, true] {
            if alpha_char(kc, shift) == Some(c) {
                return Some((kc, shift));
            }
            let mapped = match layout {
                KeyboardLayout::Us => us_ascii(kc, shift),
                KeyboardLayout::Jis => jis_ascii(kc, shift),
            };
            if mapped == Some(c) {
                return Some((kc, shift));
            }
        }
    }
    None
}

fn alpha_char(keycode: u8, shift_pressed: bool) -> Option<char> {
    let c = match keycode {
        0x1E => {
            if shift_pressed {
                'A'
            } else {
                'a'
            }
        }
        0x30 => {
            if shift_pressed {
                'B'
            } else {
                'b'
            }
        }
        0x2E => {
            if shift_pressed {
                'C'
            } else {
                'c'
            }
        }
        0x20 => {
            if shift_pressed {
                'D'
            } else {
                'd'
            }
        }
        0x12 => {
            if shift_pressed {
                'E'
            } else {
                'e'
            }
        }
        0x21 => {
            if shift_pressed {
                'F'
            } else {
                'f'
            }
        }
        0x22 => {
            if shift_pressed {
                'G'
            } else {
                'g'
            }
        }
        0x23 => {
            if shift_pressed {
                'H'
            } else {
                'h'
            }
        }
        0x17 => {
            if shift_pressed {
                'I'
            } else {
                'i'
            }
        }
        0x24 => {
            if shift_pressed {
                'J'
            } else {
                'j'
            }
        }
        0x25 => {
            if shift_pressed {
                'K'
            } else {
                'k'
            }
        }
        0x26 => {
            if shift_pressed {
                'L'
            } else {
                'l'
            }
        }
        0x32 => {
            if shift_pressed {
                'M'
            } else {
                'm'
            }
        }
        0x31 => {
            if shift_pressed {
                'N'
            } else {
                'n'
            }
        }
        0x18 => {
            if shift_pressed {
                'O'
            } else {
                'o'
            }
        }
        0x19 => {
            if shift_pressed {
                'P'
            } else {
                'p'
            }
        }
        0x10 => {
            if shift_pressed {
                'Q'
            } else {
                'q'
            }
        }
        0x13 => {
            if shift_pressed {
                'R'
            } else {
                'r'
            }
        }
        0x1F => {
            if shift_pressed {
                'S'
            } else {
                's'
            }
        }
        0x14 => {
            if shift_pressed {
                'T'
            } else {
                't'
            }
        }
        0x16 => {
            if shift_pressed {
                'U'
            } else {
                'u'
            }
        }
        0x2F => {
            if shift_pressed {
                'V'
            } else {
                'v'
            }
        }
        0x11 => {
            if shift_pressed {
                'W'
            } else {
                'w'
            }
        }
        0x2D => {
            if shift_pressed {
                'X'
            } else {
                'x'
            }
        }
        0x15 => {
            if shift_pressed {
                'Y'
            } else {
                'y'
            }
        }
        0x2C => {
            if shift_pressed {
                'Z'
            } else {
                'z'
            }
        }
        _ => return None,
    };
    Some(c)
}

fn us_ascii(keycode: u8, shift_pressed: bool) -> Option<char> {
    let c = match keycode {
        0x02 => {
            if shift_pressed {
                '!'
            } else {
                '1'
            }
        }
        0x03 => {
            if shift_pressed {
                '@'
            } else {
                '2'
            }
        }
        0x04 => {
            if shift_pressed {
                '#'
            } else {
                '3'
            }
        }
        0x05 => {
            if shift_pressed {
                '$'
            } else {
                '4'
            }
        }
        0x06 => {
            if shift_pressed {
                '%'
            } else {
                '5'
            }
        }
        0x07 => {
            if shift_pressed {
                '^'
            } else {
                '6'
            }
        }
        0x08 => {
            if shift_pressed {
                '&'
            } else {
                '7'
            }
        }
        0x09 => {
            if shift_pressed {
                '*'
            } else {
                '8'
            }
        }
        0x0A => {
            if shift_pressed {
                '('
            } else {
                '9'
            }
        }
        0x0B => {
            if shift_pressed {
                ')'
            } else {
                '0'
            }
        }
        0x0C => {
            if shift_pressed {
                '_'
            } else {
                '-'
            }
        }
        0x0D => {
            if shift_pressed {
                '+'
            } else {
                '='
            }
        }
        0x0E => '\x08',
        0x0F => '\t',
        0x1A => {
            if shift_pressed {
                '{'
            } else {
                '['
            }
        }
        0x1B => {
            if shift_pressed {
                '}'
            } else {
                ']'
            }
        }
        0x27 => {
            if shift_pressed {
                ':'
            } else {
                ';'
            }
        }
        0x28 => {
            if shift_pressed {
                '"'
            } else {
                '\''
            }
        }
        0x29 => {
            if shift_pressed {
                '~'
            } else {
                '`'
            }
        }
        0x2B => {
            if shift_pressed {
                '|'
            } else {
                '\\'
            }
        }
        0x33 => {
            if shift_pressed {
                '<'
            } else {
                ','
            }
        }
        0x34 => {
            if shift_pressed {
                '>'
            } else {
                '.'
            }
        }
        0x35 => {
            if shift_pressed {
                '?'
            } else {
                '/'
            }
        }
        0x39 => ' ',
        0x1C => '\n',
        _ => return None,
    };
    Some(c)
}

fn jis_ascii(keycode: u8, shift_pressed: bool) -> Option<char> {
    let c = match keycode {
        0x02 => {
            if shift_pressed {
                '!'
            } else {
                '1'
            }
        }
        0x03 => {
            if shift_pressed {
                '"'
            } else {
                '2'
            }
        }
        0x04 => {
            if shift_pressed {
                '#'
            } else {
                '3'
            }
        }
        0x05 => {
            if shift_pressed {
                '$'
            } else {
                '4'
            }
        }
        0x06 => {
            if shift_pressed {
                '%'
            } else {
                '5'
            }
        }
        0x07 => {
            if shift_pressed {
                '&'
            } else {
                '6'
            }
        }
        0x08 => {
            if shift_pressed {
                '\''
            } else {
                '7'
            }
        }
        0x09 => {
            if shift_pressed {
                '('
            } else {
                '8'
            }
        }
        0x0A => {
            if shift_pressed {
                ')'
            } else {
                '9'
            }
        }
        // JIS配列の0キー。ここがNoneだと0が入力できない。
        0x0B => {
            if shift_pressed {
                ')'
            } else {
                '0'
            }
        }
        0x0C => {
            if shift_pressed {
                '='
            } else {
                '-'
            }
        }
        0x0D => {
            if shift_pressed {
                '~'
            } else {
                '^'
            }
        }
        0x0E => '\x08',
        0x0F => '\t',
        0x1A => {
            if shift_pressed {
                '`'
            } else {
                '@'
            }
        }
        0x1B => {
            if shift_pressed {
                '{'
            } else {
                '['
            }
        }
        0x27 => {
            if shift_pressed {
                '+'
            } else {
                ';'
            }
        }
        0x28 => {
            if shift_pressed {
                '*'
            } else {
                ':'
            }
        }
        0x29 => return None,
        0x2B => {
            if shift_pressed {
                '}'
            } else {
                ']'
            }
        }
        0x33 => {
            if shift_pressed {
                '<'
            } else {
                ','
            }
        }
        0x34 => {
            if shift_pressed {
                '>'
            } else {
                '.'
            }
        }
        0x35 => {
            if shift_pressed {
                '?'
            } else {
                '/'
            }
        }
        0x39 => ' ',
        0x1C => '\n',
        0x73 => {
            if shift_pressed {
                '_'
            } else {
                '\\'
            }
        }
        0x7D => {
            if shift_pressed {
                '|'
            } else {
                '\\'
            }
        }
        _ => return None,
    };
    Some(c)
}