A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.
Rust agentagent-orchestrationaiai-agentsclaude-codecodexcoding-agentlinuxmacosmultiplayermultiplexerrustterminalterminal-emulatorterminal-multiplexertmuxtuiweztermwindows
#![cfg_attr(not(feature = "std"), no_std)]
#[cfg(feature = "serde")]
use ::serde::*;
use alloc::sync::Arc;
use bitflags::*;
use core::convert::TryFrom;
use core::fmt::Write;
use core::sync::atomic::AtomicBool;
#[cfg(feature = "std")]
use std::sync::LazyLock;
use wezterm_dynamic::{FromDynamic, ToDynamic};
extern crate alloc;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use alloc::{format, vec};
#[cfg(feature = "std")]
use std::collections::HashMap;
pub struct PixelUnit;
pub struct ScreenPixelUnit;
pub type Point = euclid::Point2D<isize, PixelUnit>;
pub type PointF = euclid::Point2D<f32, PixelUnit>;
pub type ScreenPoint = euclid::Point2D<isize, ScreenPixelUnit>;
/// Which key is pressed. Not all of these are probable to appear
/// on most systems. A lot of this list is @wez trawling docs and
/// making an entry for things that might be possible in this first pass.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, FromDynamic, ToDynamic)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum KeyCode {
/// The decoded unicode character
Char(char),
Composed(String),
RawCode(u32),
Physical(PhysKeyCode),
Hyper,
Super,
Meta,
/// Ctrl-break on windows
Cancel,
// There is no `Backspace`; use `Char('\u{8}') instead
// There is no `Tab`; use `Char('\t')` instead
Clear,
// There is no `Enter`; use `Char('\r')` instead
Shift,
// There is no `Escape`; use `Char('\u{1b}') instead
LeftShift,
RightShift,
Control,
LeftControl,
RightControl,
Alt,
LeftAlt,
RightAlt,
Pause,
CapsLock,
VoidSymbol,
PageUp,
PageDown,
End,
Home,
LeftArrow,
RightArrow,
UpArrow,
DownArrow,
Select,
Print,
Execute,
PrintScreen,
Insert,
// There is no `Delete`; use `Char('\u{7f}')` instead
Help,
LeftWindows,
RightWindows,
Applications,
Sleep,
/// Numeric keypad digits 0-9
Numpad(u8),
Multiply,
Add,
Separator,
Subtract,
Decimal,
Divide,
/// F1-F24 are possible
Function(u8),
NumLock,
ScrollLock,
Copy,
Cut,
Paste,
BrowserBack,
BrowserForward,
BrowserRefresh,
BrowserStop,
BrowserSearch,
BrowserFavorites,
BrowserHome,
VolumeMute,
VolumeDown,
VolumeUp,
MediaNextTrack,
MediaPrevTrack,
MediaStop,
MediaPlayPause,
ApplicationLeftArrow,
ApplicationRightArrow,
ApplicationUpArrow,
ApplicationDownArrow,
KeyPadHome,
KeyPadEnd,
KeyPadPageUp,
KeyPadPageDown,
KeyPadBegin,
}
impl KeyCode {
/// Return true if the key represents a modifier key.
pub fn is_modifier(&self) -> bool {
match self {
Self::Hyper
| Self::CapsLock
| Self::Super
| Self::Meta
| Self::Shift
| Self::LeftShift
| Self::RightShift
| Self::Control
| Self::LeftControl
| Self::RightControl
| Self::Alt
| Self::LeftAlt
| Self::RightAlt
| Self::LeftWindows
| Self::RightWindows => true,
_ => false,
}
}
pub fn normalize_shift(&self, modifiers: Modifiers) -> (KeyCode, Modifiers) {
normalize_shift(self.clone(), modifiers)
}
pub fn composed(s: &str) -> Self {
// Prefer to send along a single Char when the string
// is just a single char, as the keymapping layer cannot
// bind to composed key sequences
let mut iter = s.chars();
let first_char = iter.next();
let next_char = iter.next();
match (first_char, next_char) {
(Some(c), None) => Self::Char(c),
_ => Self::Composed(s.to_string()),
}
}
/// Convert to a PhysKeyCode.
/// Note that by the nature of PhysKeyCode being defined in terms
/// of a US ANSI standard layout, essentially "latinizes" the keycode,
/// so the results may not make as much sense for non-latin keyboards.
/// It also loses the shifted state of alphabetical characters.
pub fn to_phys(&self) -> Option<PhysKeyCode> {
Some(match self {
Self::Char('a') | Self::Char('A') => PhysKeyCode::A,
Self::Char('b') | Self::Char('B') => PhysKeyCode::B,
Self::Char('c') | Self::Char('C') => PhysKeyCode::C,
Self::Char('d') | Self::Char('D') => PhysKeyCode::D,
Self::Char('e') | Self::Char('E') => PhysKeyCode::E,
Self::Char('f') | Self::Char('F') => PhysKeyCode::F,
Self::Char('g') | Self::Char('G') => PhysKeyCode::G,
Self::Char('h') | Self::Char('H') => PhysKeyCode::H,
Self::Char('i') | Self::Char('I') => PhysKeyCode::I,
Self::Char('j') | Self::Char('J') => PhysKeyCode::J,
Self::Char('k') | Self::Char('K') => PhysKeyCode::K,
Self::Char('l') | Self::Char('L') => PhysKeyCode::L,
Self::Char('m') | Self::Char('M') => PhysKeyCode::M,
Self::Char('n') | Self::Char('N') => PhysKeyCode::N,
Self::Char('o') | Self::Char('O') => PhysKeyCode::O,
Self::Char('p') | Self::Char('P') => PhysKeyCode::P,
Self::Char('q') | Self::Char('Q') => PhysKeyCode::Q,
Self::Char('r') | Self::Char('R') => PhysKeyCode::R,
Self::Char('s') | Self::Char('S') => PhysKeyCode::S,
Self::Char('t') | Self::Char('T') => PhysKeyCode::T,
Self::Char('u') | Self::Char('U') => PhysKeyCode::U,
Self::Char('v') | Self::Char('V') => PhysKeyCode::V,
Self::Char('w') | Self::Char('W') => PhysKeyCode::W,
Self::Char('x') | Self::Char('X') => PhysKeyCode::X,
Self::Char('y') | Self::Char('Y') => PhysKeyCode::Y,
Self::Char('z') | Self::Char('Z') => PhysKeyCode::Z,
Self::Char('0') => PhysKeyCode::K0,
Self::Char('1') => PhysKeyCode::K1,
Self::Char('2') => PhysKeyCode::K2,
Self::Char('3') => PhysKeyCode::K3,
Self::Char('4') => PhysKeyCode::K4,
Self::Char('5') => PhysKeyCode::K5,
Self::Char('6') => PhysKeyCode::K6,
Self::Char('7') => PhysKeyCode::K7,
Self::Char('8') => PhysKeyCode::K8,
Self::Char('9') => PhysKeyCode::K9,
Self::Char('\\') => PhysKeyCode::Backslash,
Self::Char(',') => PhysKeyCode::Comma,
Self::Char('\u{8}') => PhysKeyCode::Backspace,
Self::Char('\u{7f}') => PhysKeyCode::Delete,
Self::Char('=') => PhysKeyCode::Equal,
Self::Char('\u{1b}') => PhysKeyCode::Escape,
Self::Char('`') => PhysKeyCode::Grave,
Self::Char('\r') => PhysKeyCode::Return,
Self::Char('[') => PhysKeyCode::LeftBracket,
Self::Char(']') => PhysKeyCode::RightBracket,
Self::Char('-') => PhysKeyCode::Minus,
Self::Char('.') => PhysKeyCode::Period,
Self::Char('\'') => PhysKeyCode::Quote,
Self::Char(';') => PhysKeyCode::Semicolon,
Self::Char('/') => PhysKeyCode::Slash,
Self::Char(' ') => PhysKeyCode::Space,
Self::Char('\t') => PhysKeyCode::Tab,
Self::Numpad(0) => PhysKeyCode::Keypad0,
Self::Numpad(1) => PhysKeyCode::Keypad1,
Self::Numpad(2) => PhysKeyCode::Keypad2,
Self::Numpad(3) => PhysKeyCode::Keypad3,
Self::Numpad(4) => PhysKeyCode::Keypad4,
Self::Numpad(5) => PhysKeyCode::Keypad5,
Self::Numpad(6) => PhysKeyCode::Keypad6,
Self::Numpad(7) => PhysKeyCode::Keypad7,
Self::Numpad(8) => PhysKeyCode::Keypad8,
Self::Numpad(9) => PhysKeyCode::Keypad9,
Self::Function(1) => PhysKeyCode::F1,
Self::Function(2) => PhysKeyCode::F2,
Self::Function(3) => PhysKeyCode::F3,
Self::Function(4) => PhysKeyCode::F4,
Self::Function(5) => PhysKeyCode::F5,
Self::Function(6) => PhysKeyCode::F6,
Self::Function(7) => PhysKeyCode::F7,
Self::Function(8) => PhysKeyCode::F8,
Self::Function(9) => PhysKeyCode::F9,
Self::Function(10) => PhysKeyCode::F10,
Self::Function(11) => PhysKeyCode::F11,
Self::Function(12) => PhysKeyCode::F12,
Self::Function(13) => PhysKeyCode::F13,
Self::Function(14) => PhysKeyCode::F14,
Self::Function(15) => PhysKeyCode::F15,
Self::Function(16) => PhysKeyCode::F16,
Self::Function(17) => PhysKeyCode::F17,
Self::Function(18) => PhysKeyCode::F18,
Self::Function(19) => PhysKeyCode::F19,
Self::Function(20) => PhysKeyCode::F20,
Self::Physical(p) => *p,
Self::Shift | Self::LeftShift => PhysKeyCode::LeftShift,
Self::RightShift => PhysKeyCode::RightShift,
Self::Alt | Self::LeftAlt => PhysKeyCode::LeftAlt,
Self::RightAlt => PhysKeyCode::RightAlt,
Self::LeftWindows => PhysKeyCode::LeftWindows,
Self::RightWindows => PhysKeyCode::RightWindows,
Self::Control | Self::LeftControl => PhysKeyCode::LeftControl,
Self::RightControl => PhysKeyCode::RightControl,
Self::CapsLock => PhysKeyCode::CapsLock,
Self::PageUp => PhysKeyCode::PageUp,
Self::PageDown => PhysKeyCode::PageDown,
Self::Home => PhysKeyCode::Home,
Self::End => PhysKeyCode::End,
Self::LeftArrow => PhysKeyCode::LeftArrow,
Self::RightArrow => PhysKeyCode::RightArrow,
Self::UpArrow => PhysKeyCode::UpArrow,
Self::DownArrow => PhysKeyCode::DownArrow,
Self::Insert => PhysKeyCode::Insert,
Self::Help => PhysKeyCode::Help,
Self::Multiply => PhysKeyCode::KeypadMultiply,
Self::Clear => PhysKeyCode::KeypadClear,
Self::Decimal => PhysKeyCode::KeypadDecimal,
Self::Divide => PhysKeyCode::KeypadDivide,
Self::Add => PhysKeyCode::KeypadAdd,
Self::Subtract => PhysKeyCode::KeypadSubtract,
Self::NumLock => PhysKeyCode::NumLock,
Self::VolumeUp => PhysKeyCode::VolumeUp,
Self::VolumeDown => PhysKeyCode::VolumeDown,
Self::VolumeMute => PhysKeyCode::VolumeMute,
Self::ApplicationLeftArrow
| Self::ApplicationRightArrow
| Self::ApplicationUpArrow
| Self::ApplicationDownArrow
| Self::KeyPadHome
| Self::KeyPadEnd
| Self::KeyPadPageUp
| Self::KeyPadPageDown
| Self::KeyPadBegin
| Self::MediaNextTrack
| Self::MediaPrevTrack
| Self::MediaStop
| Self::MediaPlayPause
| Self::Copy
| Self::Cut
| Self::Paste
| Self::BrowserBack
| Self::BrowserForward
| Self::BrowserRefresh
| Self::BrowserStop
| Self::BrowserSearch
| Self::BrowserFavorites
| Self::BrowserHome
| Self::ScrollLock
| Self::Separator
| Self::Sleep
| Self::Applications
| Self::Execute
| Self::PrintScreen
| Self::Print
| Self::Select
| Self::VoidSymbol
| Self::Pause
| Self::Cancel
| Self::Hyper
| Self::Super
| Self::Meta
| Self::Composed(_)
| Self::RawCode(_)
| Self::Char(_)
| Self::Numpad(_)
| Self::Function(_) => return None,
})
}
}
impl TryFrom<&str> for KeyCode {
type Error = String;
fn try_from(s: &str) -> core::result::Result<Self, String> {
macro_rules! m {
($($val:ident),* $(,)?) => {
match s {
$(
core::stringify!($val) => return Ok(Self::$val),
)*
_ => {}
}
}
}
m!(
Hyper,
Super,
Meta,
Cancel,
Clear,
Shift,
LeftShift,
RightShift,
Control,
LeftControl,
RightControl,
Alt,
LeftAlt,
RightAlt,
Pause,
CapsLock,
VoidSymbol,
PageUp,
PageDown,
End,
Home,
LeftArrow,
RightArrow,
UpArrow,
DownArrow,
Select,
Print,
Execute,
PrintScreen,
Insert,
Help,
LeftWindows,
RightWindows,
Applications,
Sleep,
Multiply,
Add,
Separator,
Subtract,
Decimal,
Divide,
NumLock,
ScrollLock,
Copy,
Cut,
Paste,
BrowserBack,
BrowserForward,
BrowserRefresh,
BrowserStop,
BrowserSearch,
BrowserFavorites,
BrowserHome,
VolumeMute,
VolumeDown,
VolumeUp,
MediaNextTrack,
MediaPrevTrack,
MediaStop,
MediaPlayPause,
ApplicationLeftArrow,
ApplicationRightArrow,
ApplicationUpArrow,
ApplicationDownArrow,
KeyPadHome,
KeyPadEnd,
KeyPadPageUp,
KeyPadPageDown,
KeyPadBegin,
);
match s {
"Backspace" => return Ok(KeyCode::Char('\u{8}')),
"Tab" => return Ok(KeyCode::Char('\t')),
"Return" | "Enter" => return Ok(KeyCode::Char('\r')),
"Escape" => return Ok(KeyCode::Char('\u{1b}')),
"Delete" => return Ok(KeyCode::Char('\u{7f}')),
_ => {}
};
if let Some(n) = s.strip_prefix("Numpad") {
let n: u8 = n
.parse()
.map_err(|err| format!("parsing Numpad<NUMBER>: {:#}", err))?;
if n > 9 {
return Err("Numpad numbers must be in range 0-9".to_string());
}
return Ok(KeyCode::Numpad(n));
}
// Don't consider "F" to be an invalid F key!
if s.len() > 1 {
if let Some(n) = s.strip_prefix("F") {
let n: u8 = n
.parse()
.map_err(|err| format!("parsing F<NUMBER>: {:#}", err))?;
if n == 0 || n > 24 {
return Err("Function key numbers must be in range 1-24".to_string());
}
return Ok(KeyCode::Function(n));
}
}
let chars: Vec<char> = s.chars().collect();
if chars.len() == 1 {
let k = KeyCode::Char(chars[0]);
Ok(k)
} else {
Err(format!("invalid KeyCode string {}", s))
}
}
}
impl ToString for KeyCode {
fn to_string(&self) -> String {
match self {
Self::RawCode(n) => format!("raw:{}", n),
Self::Char(c) => format!("mapped:{}", c),
Self::Physical(phys) => phys.to_string(),
Self::Composed(s) => s.to_string(),
Self::Numpad(n) => format!("Numpad{}", n),
Self::Function(n) => format!("F{}", n),
other => format!("{:?}", other),
}
}
}
bitflags! {
#[derive(Default, FromDynamic, ToDynamic)]
pub struct KeyboardLedStatus: u8 {
const CAPS_LOCK = 1<<1;
const NUM_LOCK = 1<<2;
}
}
impl ToString for KeyboardLedStatus {
fn to_string(&self) -> String {
let mut s = String::new();
if self.contains(Self::CAPS_LOCK) {
s.push_str("CAPS_LOCK");
}
if self.contains(Self::NUM_LOCK) {
if !s.is_empty() {
s.push('|');
}
s.push_str("NUM_LOCK");
}
s
}
}
bitflags! {
#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
#[derive(Default, FromDynamic, ToDynamic)]
#[dynamic(into="String", try_from="String")]
pub struct Modifiers: u16 {
const NONE = 0;
const SHIFT = 1<<1;
const ALT = 1<<2;
const CTRL = 1<<3;
const SUPER = 1<<4;
const LEFT_ALT = 1<<5;
const RIGHT_ALT = 1<<6;
/// This is a virtual modifier used by wezterm
const LEADER = 1<<7;
const LEFT_CTRL = 1<<8;
const RIGHT_CTRL = 1<<9;
const LEFT_SHIFT = 1<<10;
const RIGHT_SHIFT = 1<<11;
const ENHANCED_KEY = 1<<12;
}
}
impl TryFrom<String> for Modifiers {
type Error = String;
fn try_from(s: String) -> Result<Modifiers, String> {
let mut mods = Modifiers::NONE;
for ele in s.split('|') {
// Allow for whitespace; debug printing Modifiers includes spaces
// around the `|` so it is desirable to be able to reverse that
// encoding here.
let ele = ele.trim();
if ele == "SHIFT" {
mods |= Modifiers::SHIFT;
} else if ele == "ALT" || ele == "OPT" || ele == "META" {
mods |= Modifiers::ALT;
} else if ele == "CTRL" {
mods |= Modifiers::CTRL;
} else if ele == "SUPER" || ele == "CMD" || ele == "WIN" {
mods |= Modifiers::SUPER;
} else if ele == "LEADER" {
mods |= Modifiers::LEADER;
} else if ele == "NONE" || ele == "" {
mods |= Modifiers::NONE;
} else {
return Err(format!("invalid modifier name {} in {}", ele, s));
}
}
Ok(mods)
}
}
impl From<&Modifiers> for String {
fn from(val: &Modifiers) -> Self {
val.to_string()
}
}
pub struct ModifierToStringArgs<'a> {
/// How to join two modifier keys. Can be empty.
pub separator: &'a str,
/// Whether to output NONE when no modifiers are present
pub want_none: bool,
/// How to render the keycaps for the UI
pub ui_key_cap_rendering: Option<UIKeyCapRendering>,
}
impl Modifiers {
pub fn encode_xterm(self) -> u8 {
let mut number = 0;
if self.contains(Self::SHIFT) {
number |= 1;
}
if self.contains(Self::ALT) {
number |= 2;
}
if self.contains(Self::CTRL) {
number |= 4;
}
number
}
#[allow(non_upper_case_globals)]
pub fn to_string_with_separator(&self, args: ModifierToStringArgs) -> String {
let mut s = String::new();
if args.want_none && *self == Self::NONE {
s.push_str("NONE");
}
// The unicode escapes here are nerdfont symbols; we use those because
// we're guaranteed to have them available, and the symbols are
// very legible
const md_apple_keyboard_command: &str = "\u{f0633}"; //
const md_apple_keyboard_control: &str = "\u{f0634}"; //
const md_apple_keyboard_option: &str = "\u{f0635}"; //
const md_apple_keyboard_shift: &str = "\u{f0636}"; //
const md_microsoft_windows: &str = "\u{f05b3}"; //
for (value, label, unix, emacs, apple, windows, win_sym) in [
(
Self::SHIFT,
"SHIFT",
"Shift",
"S",
md_apple_keyboard_shift,
"Shift",
"Shift",
),
(
Self::ALT,
"ALT",
"Alt",
"M",
md_apple_keyboard_option,
"Alt",
"Alt",
),
(
Self::CTRL,
"CTRL",
"Ctrl",
"C",
md_apple_keyboard_control,
"Ctrl",
"Ctrl",
),
(
Self::SUPER,
"SUPER",
"Super",
"Super",
md_apple_keyboard_command,
"Win",
md_microsoft_windows,
),
(
Self::LEFT_ALT,
"LEFT_ALT",
"Alt",
"M",
md_apple_keyboard_option,
"Alt",
"Alt",
),
(
Self::RIGHT_ALT,
"RIGHT_ALT",
"Alt",
"M",
md_apple_keyboard_option,
"Alt",
"Alt",
),
(
Self::LEADER,
"LEADER",
"Leader",
"Leader",
"Leader",
"Leader",
"Leader",
),
(
Self::LEFT_CTRL,
"LEFT_CTRL",
"Ctrl",
"C",
md_apple_keyboard_control,
"Ctrl",
"Ctrl",
),
(
Self::RIGHT_CTRL,
"RIGHT_CTRL",
"Ctrl",
"C",
md_apple_keyboard_control,
"Ctrl",
"Ctrl",
),
(
Self::LEFT_SHIFT,
"LEFT_SHIFT",
"Shift",
"S",
md_apple_keyboard_shift,
"Shift",
"Shift",
),
(
Self::RIGHT_SHIFT,
"RIGHT_SHIFT",
"Shift",
"S",
md_apple_keyboard_shift,
"Shift",
"Shift",
),
(
Self::ENHANCED_KEY,
"ENHANCED_KEY",
"ENHANCED_KEY",
"ENHANCED_KEY",
"ENHANCED_KEY",
"ENHANCED_KEY",
"ENHANCED_KEY",
),
] {
if !self.contains(value) {
continue;
}
if !s.is_empty() {
s.push_str(args.separator);
}
s.push_str(match args.ui_key_cap_rendering {
Some(UIKeyCapRendering::UnixLong) => unix,
Some(UIKeyCapRendering::Emacs) => emacs,
Some(UIKeyCapRendering::AppleSymbols) => apple,
Some(UIKeyCapRendering::WindowsLong) => windows,
Some(UIKeyCapRendering::WindowsSymbols) => win_sym,
None => label,
});
}
s
}
}
impl ToString for Modifiers {
fn to_string(&self) -> String {
self.to_string_with_separator(ModifierToStringArgs {
separator: "|",
want_none: true,
ui_key_cap_rendering: None,
})
}
}
impl Modifiers {
/// Remove positional and other "supplemental" bits that
/// are used to carry around implementation details, but that
/// are not bits that should be matched when matching key
/// assignments.
pub fn remove_positional_mods(self) -> Self {
self - (Self::LEFT_ALT
| Self::RIGHT_ALT
| Self::LEFT_CTRL
| Self::RIGHT_CTRL
| Self::LEFT_SHIFT
| Self::RIGHT_SHIFT
| Self::ENHANCED_KEY)
}
}
/// These keycodes identify keys based on their physical
/// position on an ANSI-standard US keyboard.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Copy, Ord, PartialOrd, FromDynamic, ToDynamic)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum PhysKeyCode {
A,
B,
Backslash,
C,
CapsLock,
Comma,
D,
Backspace,
DownArrow,
E,
End,
Equal,
Escape,
F,
F1,
F10,
F11,
F12,
F13,
F14,
F15,
F16,
F17,
F18,
F19,
F2,
F20,
F21,
F22,
F23,
F24,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
Delete,
Function,
G,
Grave,
H,
Help,
Home,
I,
Insert,
J,
K,
K0,
K1,
K2,
K3,
K4,
K5,
K6,
K7,
K8,
K9,
Keypad0,
Keypad1,
Keypad2,
Keypad3,
Keypad4,
Keypad5,
Keypad6,
Keypad7,
Keypad8,
Keypad9,
KeypadClear,
KeypadDecimal,
KeypadDelete,
KeypadDivide,
KeypadEnter,
KeypadEquals,
KeypadSubtract,
KeypadMultiply,
KeypadAdd,
L,
LeftAlt,
LeftArrow,
LeftBracket,
LeftControl,
LeftShift,
LeftWindows,
M,
Minus,
VolumeMute,
N,
NumLock,
O,
P,
PageDown,
PageUp,
Period,
Q,
Quote,
R,
Return,
RightAlt,
RightArrow,
RightBracket,
RightControl,
RightShift,
RightWindows,
S,
Semicolon,
Slash,
Space,
T,
Tab,
U,
UpArrow,
V,
VolumeDown,
VolumeUp,
W,
X,
Y,
Z,
}
impl PhysKeyCode {
pub fn is_modifier(&self) -> bool {
match self {
Self::LeftShift
| Self::LeftControl
| Self::LeftWindows
| Self::LeftAlt
| Self::RightShift
| Self::RightControl
| Self::RightWindows
| Self::RightAlt => true,
_ => false,
}
}
pub fn to_key_code(self) -> KeyCode {
match self {
Self::LeftShift => KeyCode::LeftShift,
Self::LeftControl => KeyCode::LeftControl,
Self::LeftWindows => KeyCode::LeftWindows,
Self::LeftAlt => KeyCode::LeftAlt,
Self::RightShift => KeyCode::RightShift,
Self::RightControl => KeyCode::RightControl,
Self::RightWindows => KeyCode::RightWindows,
Self::RightAlt => KeyCode::RightAlt,
Self::LeftArrow => KeyCode::LeftArrow,
Self::RightArrow => KeyCode::RightArrow,
Self::UpArrow => KeyCode::UpArrow,
Self::DownArrow => KeyCode::DownArrow,
Self::CapsLock => KeyCode::CapsLock,
Self::F1 => KeyCode::Function(1),
Self::F2 => KeyCode::Function(2),
Self::F3 => KeyCode::Function(3),
Self::F4 => KeyCode::Function(4),
Self::F5 => KeyCode::Function(5),
Self::F6 => KeyCode::Function(6),
Self::F7 => KeyCode::Function(7),
Self::F8 => KeyCode::Function(8),
Self::F9 => KeyCode::Function(9),
Self::F10 => KeyCode::Function(10),
Self::F11 => KeyCode::Function(11),
Self::F12 => KeyCode::Function(12),
Self::F13 => KeyCode::Function(13),
Self::F14 => KeyCode::Function(14),
Self::F15 => KeyCode::Function(15),
Self::F16 => KeyCode::Function(16),
Self::F17 => KeyCode::Function(17),
Self::F18 => KeyCode::Function(18),
Self::F19 => KeyCode::Function(19),
Self::F20 => KeyCode::Function(20),
Self::F21 => KeyCode::Function(21),
Self::F22 => KeyCode::Function(22),
Self::F23 => KeyCode::Function(23),
Self::F24 => KeyCode::Function(24),
Self::Keypad0 => KeyCode::Numpad(0),
Self::Keypad1 => KeyCode::Numpad(1),
Self::Keypad2 => KeyCode::Numpad(2),
Self::Keypad3 => KeyCode::Numpad(3),
Self::Keypad4 => KeyCode::Numpad(4),
Self::Keypad5 => KeyCode::Numpad(5),
Self::Keypad6 => KeyCode::Numpad(6),
Self::Keypad7 => KeyCode::Numpad(7),
Self::Keypad8 => KeyCode::Numpad(8),
Self::Keypad9 => KeyCode::Numpad(9),
Self::KeypadClear => KeyCode::Clear,
Self::KeypadMultiply => KeyCode::Multiply,
Self::KeypadDecimal => KeyCode::Decimal,
Self::KeypadDivide => KeyCode::Divide,
Self::KeypadAdd => KeyCode::Add,
Self::KeypadSubtract => KeyCode::Subtract,
Self::A => KeyCode::Char('a'),
Self::B => KeyCode::Char('b'),
Self::C => KeyCode::Char('c'),
Self::D => KeyCode::Char('d'),
Self::E => KeyCode::Char('e'),
Self::F => KeyCode::Char('f'),
Self::G => KeyCode::Char('g'),
Self::H => KeyCode::Char('h'),
Self::I => KeyCode::Char('i'),
Self::J => KeyCode::Char('j'),
Self::K => KeyCode::Char('k'),
Self::L => KeyCode::Char('l'),
Self::M => KeyCode::Char('m'),
Self::N => KeyCode::Char('n'),
Self::O => KeyCode::Char('o'),
Self::P => KeyCode::Char('p'),
Self::Q => KeyCode::Char('q'),
Self::R => KeyCode::Char('r'),
Self::S => KeyCode::Char('s'),
Self::T => KeyCode::Char('t'),
Self::U => KeyCode::Char('u'),
Self::V => KeyCode::Char('v'),
Self::W => KeyCode::Char('w'),
Self::X => KeyCode::Char('x'),
Self::Y => KeyCode::Char('y'),
Self::Z => KeyCode::Char('z'),
Self::Backslash => KeyCode::Char('\\'),
Self::Comma => KeyCode::Char(','),
Self::Backspace => KeyCode::Char('\u{8}'),
Self::KeypadDelete | Self::Delete => KeyCode::Char('\u{7f}'),
Self::End => KeyCode::End,
Self::Home => KeyCode::Home,
Self::KeypadEquals | Self::Equal => KeyCode::Char('='),
Self::Escape => KeyCode::Char('\u{1b}'),
Self::Function => KeyCode::Physical(self),
Self::Grave => KeyCode::Char('`'),
Self::Help => KeyCode::Help,
Self::Insert => KeyCode::Insert,
Self::K0 => KeyCode::Char('0'),
Self::K1 => KeyCode::Char('1'),
Self::K2 => KeyCode::Char('2'),
Self::K3 => KeyCode::Char('3'),
Self::K4 => KeyCode::Char('4'),
Self::K5 => KeyCode::Char('5'),
Self::K6 => KeyCode::Char('6'),
Self::K7 => KeyCode::Char('7'),
Self::K8 => KeyCode::Char('8'),
Self::K9 => KeyCode::Char('9'),
Self::Return | Self::KeypadEnter => KeyCode::Char('\r'),
Self::LeftBracket => KeyCode::Char('['),
Self::RightBracket => KeyCode::Char(']'),
Self::Minus => KeyCode::Char('-'),
Self::VolumeMute => KeyCode::VolumeMute,
Self::VolumeUp => KeyCode::VolumeUp,
Self::VolumeDown => KeyCode::VolumeDown,
Self::NumLock => KeyCode::NumLock,
Self::PageUp => KeyCode::PageUp,
Self::PageDown => KeyCode::PageDown,
Self::Period => KeyCode::Char('.'),
Self::Quote => KeyCode::Char('\''),
Self::Semicolon => KeyCode::Char(';'),
Self::Slash => KeyCode::Char('/'),
Self::Space => KeyCode::Char(' '),
Self::Tab => KeyCode::Char('\t'),
}
}
fn for_each_code(mut func: impl FnMut(&str, Self) -> bool) {
macro_rules! m {
($($val:ident),* $(,)?) => {
$(
let key = stringify!($val);
if key.len() == 1 {
if (func)(&key.to_ascii_lowercase(), PhysKeyCode::$val) {
return;
}
}
if (func)(key, PhysKeyCode::$val) {
return;
}
)*
}
}
m!(
A,
B,
Backslash,
C,
CapsLock,
Comma,
D,
Backspace,
DownArrow,
E,
End,
Equal,
Escape,
F,
F1,
F10,
F11,
F12,
F13,
F14,
F15,
F16,
F17,
F18,
F19,
F2,
F20,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
Delete,
Function,
G,
Grave,
H,
Help,
Home,
I,
Insert,
J,
K,
Keypad0,
Keypad1,
Keypad2,
Keypad3,
Keypad4,
Keypad5,
Keypad6,
Keypad7,
Keypad8,
Keypad9,
KeypadClear,
KeypadDecimal,
KeypadDelete,
KeypadDivide,
KeypadEnter,
KeypadEquals,
KeypadSubtract,
KeypadMultiply,
KeypadAdd,
L,
LeftAlt,
LeftArrow,
LeftBracket,
LeftControl,
LeftShift,
LeftWindows,
M,
Minus,
VolumeMute,
N,
NumLock,
O,
P,
PageDown,
PageUp,
Period,
Q,
Quote,
R,
Return,
RightAlt,
RightArrow,
RightBracket,
RightControl,
RightShift,
RightWindows,
S,
Semicolon,
Slash,
Space,
T,
Tab,
U,
UpArrow,
V,
VolumeDown,
VolumeUp,
W,
X,
Y,
Z,
);
for (label, value) in [
("0", PhysKeyCode::K0),
("1", PhysKeyCode::K1),
("2", PhysKeyCode::K2),
("3", PhysKeyCode::K3),
("4", PhysKeyCode::K4),
("5", PhysKeyCode::K5),
("6", PhysKeyCode::K6),
("7", PhysKeyCode::K7),
("8", PhysKeyCode::K8),
("9", PhysKeyCode::K9),
] {
if (func)(label, value) {
return;
}
}
}
#[cfg(feature = "std")]
fn make_map() -> HashMap<String, Self> {
let mut map = HashMap::new();
Self::for_each_code(|label, code| {
map.insert(label.to_string(), code);
false
});
map
}
#[cfg(feature = "std")]
fn make_inv_map() -> HashMap<Self, String> {
let mut map = HashMap::new();
for (k, v) in PHYSKEYCODE_MAP.iter() {
map.insert(*v, k.clone());
}
map
}
fn name_to_code(name: &str) -> Option<Self> {
#[cfg(feature = "std")]
{
return PHYSKEYCODE_MAP.get(name).copied();
}
#[cfg(not(feature = "std"))]
{
let mut result = None;
Self::for_each_code(|label, code| {
if label == name {
result.replace(code);
true
} else {
false
}
});
result
}
}
fn to_name(&self) -> Option<String> {
#[cfg(feature = "std")]
{
return INV_PHYSKEYCODE_MAP.get(self).cloned();
}
#[cfg(not(feature = "std"))]
{
let mut result = None;
Self::for_each_code(|label, code| {
if code == *self {
result.replace(label.to_string());
true
} else {
false
}
});
result
}
}
}
#[cfg(feature = "std")]
static PHYSKEYCODE_MAP: LazyLock<HashMap<String, PhysKeyCode>> =
LazyLock::new(PhysKeyCode::make_map);
#[cfg(feature = "std")]
static INV_PHYSKEYCODE_MAP: LazyLock<HashMap<PhysKeyCode, String>> =
LazyLock::new(PhysKeyCode::make_inv_map);
impl TryFrom<&str> for PhysKeyCode {
type Error = String;
fn try_from(s: &str) -> core::result::Result<PhysKeyCode, String> {
if let Some(code) = Self::name_to_code(s) {
Ok(code)
} else {
Err(format!("invalid PhysKeyCode '{}'", s))
}
}
}
impl ToString for PhysKeyCode {
fn to_string(&self) -> String {
if let Some(s) = self.to_name() {
s.to_string()
} else {
format!("{:?}", self)
}
}
}
bitflags! {
#[derive(Default)]
pub struct MouseButtons: u8 {
const NONE = 0;
#[allow(clippy::identity_op)]
const LEFT = 1<<0;
const RIGHT = 1<<1;
const MIDDLE = 1<<2;
const X1 = 1<<3;
const X2 = 1<<4;
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum MousePress {
Left,
Right,
Middle,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MouseEventKind {
Move,
Press(MousePress),
Release(MousePress),
VertWheel(i16),
HorzWheel(i16),
}
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct PreciseScrollDelta {
pub x: f32,
pub y: f32,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ScrollPhase {
Began,
Stationary,
Changed,
Ended,
Cancelled,
MayBegin,
}
#[derive(Debug, Clone, PartialEq)]
pub struct MouseEvent {
pub kind: MouseEventKind,
/// Coordinates of the mouse relative to the top left of the window
pub coords: Point,
/// The mouse position in screen coordinates
pub screen_coords: crate::ScreenPoint,
pub mouse_buttons: MouseButtons,
pub modifiers: Modifiers,
/// Pixel-precise wheel delta from native scroll devices when available.
///
/// Traditional `VertWheel`/`HorzWheel` values are line/discrete oriented;
/// this preserves high-resolution trackpad scrolling for UI chrome.
pub precise_scroll_delta: Option<PreciseScrollDelta>,
/// Native scroll gesture phase when available.
pub scroll_phase: Option<ScrollPhase>,
/// Native momentum scroll phase when available.
pub momentum_phase: Option<ScrollPhase>,
/// Wheel travel in lines (columns, for `HorzWheel`) with the fraction
/// kept, for devices that report finer steps than a line (a precision
/// touchpad on Windows) without a pixel-precise delta. Same sign as the
/// wheel amount it comes with. The terminal grid and the sidebars read
/// it; the rest of the chrome keeps using the integer kind.
pub precise_wheel_lines: Option<f32>,
}
#[derive(Debug, Clone)]
pub struct Handled(Arc<AtomicBool>);
impl Handled {
pub fn new() -> Self {
Self(Arc::new(AtomicBool::new(false)))
}
pub fn set_handled(&self) {
self.0.store(true, core::sync::atomic::Ordering::Relaxed);
}
pub fn is_handled(&self) -> bool {
self.0.load(core::sync::atomic::Ordering::Relaxed)
}
}
impl PartialEq for Handled {
fn eq(&self, _: &Self) -> bool {
true
}
}
impl Eq for Handled {}
/// A key event prior to any dead key or IME composition
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct RawKeyEvent {
pub key: KeyCode,
pub modifiers: Modifiers,
pub leds: KeyboardLedStatus,
/// The physical location of the key on an ANSI-Standard US layout
pub phys_code: Option<PhysKeyCode>,
/// The OS and hardware dependent key code for the key
pub raw_code: u32,
/// The *other* OS and hardware dependent key code for the key
#[cfg(windows)]
pub scan_code: u32,
/// How many times this key repeats
pub repeat_count: u16,
/// If true, this is a key down rather than a key up event
pub key_is_down: bool,
pub handled: Handled,
}
impl RawKeyEvent {
/// Mark the event as handled, in order to prevent additional
/// processing.
pub fn set_handled(&self) {
self.handled.set_handled();
}
/// <https://sw.kovidgoyal.net/kitty/keyboard-protocol/#functional-key-definitions>
#[deny(warnings)]
fn kitty_function_code(&self) -> Option<u32> {
use KeyCode::*;
Some(match self.key {
// Tab => 9,
// Backspace => 127,
// CapsLock => 57358,
// ScrollLock => 57359,
// NumLock => 57360,
// PrintScreen => 57361,
// Pause => 57362,
// Menu => 57363,
Function(n) if n >= 13 && n <= 35 => 57376 + n as u32 - 13,
Numpad(n) => n as u32 + 57399,
Decimal => 57409,
Divide => 57410,
Multiply => 57411,
Subtract => 57412,
Add => 57413,
// KeypadEnter => 57414,
// KeypadEquals => 57415,
Separator => 57416,
ApplicationLeftArrow => 57417,
ApplicationRightArrow => 57418,
ApplicationUpArrow => 57419,
ApplicationDownArrow => 57420,
KeyPadHome => 57423,
KeyPadEnd => 57424,
KeyPadBegin => 57427,
KeyPadPageUp => 57421,
KeyPadPageDown => 57422,
Insert => 57425,
// KeypadDelete => 57426,
MediaPlayPause => 57430,
MediaStop => 57432,
MediaNextTrack => 57435,
MediaPrevTrack => 57436,
VolumeDown => 57436,
VolumeUp => 57439,
VolumeMute => 57440,
LeftShift => 57441,
LeftControl => 57442,
LeftAlt => 57443,
LeftWindows => 57444,
RightShift => 57447,
RightControl => 57448,
RightAlt => 57449,
RightWindows => 57450,
_ => match &self.phys_code {
Some(phys) => {
use PhysKeyCode::*;
match *phys {
Escape => 27,
Return => 13,
Tab => 9,
Backspace => 127,
CapsLock => 57358,
// ScrollLock => 57359,
NumLock => 57360,
// PrintScreen => 57361,
// Pause => 57362,
// Menu => 57363,
F13 => 57376,
F14 => 57377,
F15 => 57378,
F16 => 57379,
F17 => 57380,
F18 => 57381,
F19 => 57382,
F20 => 57383,
F21 => 57384,
F22 => 57385,
F23 => 57386,
F24 => 57387,
/*
F25 => 57388,
F26 => 57389,
F27 => 57390,
F28 => 57391,
F29 => 57392,
F30 => 57393,
F31 => 57394,
F32 => 57395,
F33 => 57396,
F34 => 57397,
*/
Keypad0 => 57399,
Keypad1 => 57400,
Keypad2 => 57401,
Keypad3 => 57402,
Keypad4 => 57403,
Keypad5 => 57404,
Keypad6 => 57405,
Keypad7 => 57406,
Keypad8 => 57407,
Keypad9 => 57408,
KeypadDecimal => 57409,
KeypadDivide => 57410,
KeypadMultiply => 57411,
KeypadSubtract => 57412,
KeypadAdd => 57413,
KeypadEnter => 57414,
KeypadEquals => 57415,
// KeypadSeparator => 57416,
// ApplicationLeftArrow => 57417,
// ApplicationRightArrow => 57418,
// ApplicationUpArrow => 57419,
// ApplicationDownArrow => 57420,
// KeyPadHome => 57423,
// KeyPadEnd => 57424,
// KeyPadBegin => 57427,
// KeyPadPageUp => 57421,
// KeyPadPageDown => 57422,
Insert => 57425,
// KeypadDelete => 57426,
// MediaPlayPause => 57430,
// MediaStop => 57432,
// MediaNextTrack => 57435,
// MediaPrevTrack => 57436,
VolumeDown => 57436,
VolumeUp => 57439,
VolumeMute => 57440,
LeftShift => 57441,
LeftControl => 57442,
LeftAlt => 57443,
LeftWindows => 57444,
RightShift => 57447,
RightControl => 57448,
RightAlt => 57449,
RightWindows => 57450,
_ => return None,
}
}
_ => return None,
},
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct KeyEvent {
/// Which key was pressed.
/// This is the potentially processed/composed version
/// of the input.
pub key: KeyCode,
/// Which modifiers are down
pub modifiers: Modifiers,
pub leds: KeyboardLedStatus,
/// How many times this key repeats
pub repeat_count: u16,
/// If true, this is a key down rather than a key up event
pub key_is_down: bool,
/// If triggered from a raw key event, here it is.
pub raw: Option<RawKeyEvent>,
#[cfg(windows)]
pub win32_uni_char: Option<char>,
}
fn normalize_shift(key: KeyCode, modifiers: Modifiers) -> (KeyCode, Modifiers) {
if modifiers.contains(Modifiers::SHIFT) {
match key {
KeyCode::Char(c) if c.is_ascii_uppercase() => (key, modifiers - Modifiers::SHIFT),
KeyCode::Char(c) if c.is_ascii_lowercase() => (
KeyCode::Char(c.to_ascii_uppercase()),
modifiers - Modifiers::SHIFT,
),
_ => (key, modifiers),
}
} else {
(key, modifiers)
}
}
pub fn is_ascii_control(c: char) -> Option<char> {
let c = c as u32;
if c < 0x20 {
let de_ctrl = ((c as u8) | 0x40) as char;
Some(de_ctrl.to_ascii_lowercase())
} else {
None
}
}
fn normalize_ctrl(key: KeyCode, modifiers: Modifiers) -> (KeyCode, Modifiers) {
if modifiers.contains(Modifiers::CTRL) {
if let KeyCode::Char(c) = key {
if (c as u32) < 0x20 {
let de_ctrl = ((c as u8) | 0x40) as char;
return (KeyCode::Char(de_ctrl.to_ascii_lowercase()), modifiers);
}
}
}
(key, modifiers)
}
impl KeyEvent {
/// if SHIFT is held and we have KeyCode::Char('c') we want to normalize
/// that keycode to KeyCode::Char('C'); that is what this function does.
pub fn normalize_shift(mut self) -> Self {
let (key, modifiers) = normalize_shift(self.key, self.modifiers);
self.key = key;
self.modifiers = modifiers;
self
}
/// If the key code is a modifier key (Control, Alt, Shift), check
/// the underlying raw event to see if we had a positional version
/// of that key.
/// If so, switch to the positional version.
pub fn resurface_positional_modifier_key(mut self) -> Self {
match self.key {
KeyCode::Control
if matches!(
self.raw,
Some(RawKeyEvent {
key: KeyCode::LeftControl | KeyCode::Physical(PhysKeyCode::LeftControl),
..
})
) =>
{
self.key = KeyCode::LeftControl;
}
KeyCode::Control
if matches!(
self.raw,
Some(RawKeyEvent {
key: KeyCode::RightControl | KeyCode::Physical(PhysKeyCode::RightControl),
..
})
) =>
{
self.key = KeyCode::RightControl;
}
KeyCode::Alt
if matches!(
self.raw,
Some(RawKeyEvent {
key: KeyCode::LeftAlt | KeyCode::Physical(PhysKeyCode::LeftAlt),
..
})
) =>
{
self.key = KeyCode::LeftAlt;
}
KeyCode::Alt
if matches!(
self.raw,
Some(RawKeyEvent {
key: KeyCode::RightAlt | KeyCode::Physical(PhysKeyCode::RightAlt),
..
})
) =>
{
self.key = KeyCode::RightAlt;
}
KeyCode::Shift
if matches!(
self.raw,
Some(RawKeyEvent {
key: KeyCode::LeftShift | KeyCode::Physical(PhysKeyCode::LeftShift),
..
})
) =>
{
self.key = KeyCode::LeftShift;
}
KeyCode::Shift
if matches!(
self.raw,
Some(RawKeyEvent {
key: KeyCode::RightShift | KeyCode::Physical(PhysKeyCode::RightShift),
..
})
) =>
{
self.key = KeyCode::RightShift;
}
_ => {}
}
self
}
/// If CTRL is held down and we have KeyCode::Char(_) with the
/// ASCII control value encoded, decode it back to the ASCII
/// alpha keycode instead.
pub fn normalize_ctrl(mut self) -> Self {
let (key, modifiers) = normalize_ctrl(self.key, self.modifiers);
self.key = key;
self.modifiers = modifiers;
self
}
#[cfg(not(windows))]
pub fn encode_win32_input_mode(&self) -> Option<String> {
None
}
/// <https://github.com/microsoft/terminal/blob/main/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md>
#[cfg(windows)]
pub fn encode_win32_input_mode(&self) -> Option<String> {
let phys = self.raw.as_ref()?;
let vkey = phys.raw_code;
let scan_code = phys.scan_code;
// <https://docs.microsoft.com/en-us/windows/console/key-event-record-str>
// defines the dwControlKeyState values
let mut control_key_state = 0;
const SHIFT_PRESSED: usize = 0x10;
const ENHANCED_KEY: usize = 0x100;
const RIGHT_ALT_PRESSED: usize = 0x01;
const LEFT_ALT_PRESSED: usize = 0x02;
const LEFT_CTRL_PRESSED: usize = 0x08;
const RIGHT_CTRL_PRESSED: usize = 0x04;
if self
.modifiers
.intersects(Modifiers::SHIFT | Modifiers::LEFT_SHIFT | Modifiers::RIGHT_SHIFT)
{
control_key_state |= SHIFT_PRESSED;
}
if self.modifiers.contains(Modifiers::RIGHT_ALT) {
control_key_state |= RIGHT_ALT_PRESSED;
} else if self.modifiers.contains(Modifiers::ALT) {
control_key_state |= LEFT_ALT_PRESSED;
}
if self.modifiers.contains(Modifiers::LEFT_ALT) {
control_key_state |= LEFT_ALT_PRESSED;
}
if self.modifiers.contains(Modifiers::RIGHT_CTRL) {
control_key_state |= RIGHT_CTRL_PRESSED;
} else if self.modifiers.contains(Modifiers::CTRL) {
control_key_state |= LEFT_CTRL_PRESSED;
}
if self.modifiers.contains(Modifiers::LEFT_CTRL) {
control_key_state |= LEFT_CTRL_PRESSED;
}
if self.modifiers.contains(Modifiers::ENHANCED_KEY) {
control_key_state |= ENHANCED_KEY;
}
let key_down = if self.key_is_down { 1 } else { 0 };
match &self.key {
KeyCode::Composed(_) => None,
KeyCode::Char(c) => {
let uni = self.win32_uni_char.unwrap_or(*c) as u32;
Some(format!(
"\u{1b}[{};{};{};{};{};{}_",
vkey, scan_code, uni, key_down, control_key_state, self.repeat_count
))
}
_ => {
let uni = 0;
Some(format!(
"\u{1b}[{};{};{};{};{};{}_",
vkey, scan_code, uni, key_down, control_key_state, self.repeat_count
))
}
}
}
pub fn encode_kitty(&self, flags: KittyKeyboardFlags) -> String {
use KeyCode::*;
if !flags.contains(KittyKeyboardFlags::REPORT_EVENT_TYPES) && !self.key_is_down {
return String::new();
}
if self.modifiers.is_empty()
&& !flags.contains(KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES)
&& self.key_is_down
{
// Check for simple text generating keys
match &self.key {
Char('\x08') => return '\x7f'.to_string(),
Char('\x7f') => return '\x08'.to_string(),
Char(c) => return c.to_string(),
_ => {}
}
}
let raw_modifiers = self
.raw
.as_ref()
.map(|raw| raw.modifiers)
.unwrap_or(self.modifiers);
let mut modifiers = 0;
if raw_modifiers.contains(Modifiers::SHIFT) {
modifiers |= 1;
}
if raw_modifiers.contains(Modifiers::ALT) {
modifiers |= 2;
}
if raw_modifiers.contains(Modifiers::CTRL) {
modifiers |= 4;
}
if raw_modifiers.contains(Modifiers::SUPER) {
modifiers |= 8;
}
// TODO: Hyper and Meta are not handled yet.
// We should somehow detect this?
// See: https://github.com/wezterm/wezterm/pull/4605#issuecomment-1823604708
if self.leds.contains(KeyboardLedStatus::CAPS_LOCK) {
modifiers |= 64;
}
if self.leds.contains(KeyboardLedStatus::NUM_LOCK) {
modifiers |= 128;
}
modifiers += 1;
let event_type =
if flags.contains(KittyKeyboardFlags::REPORT_EVENT_TYPES) && !self.key_is_down {
":3"
} else {
""
};
let is_legacy_key = match &self.key {
Char(c) => c.is_ascii_alphanumeric() || c.is_ascii_punctuation(),
_ => false,
};
let generated_text =
if self.key_is_down && flags.contains(KittyKeyboardFlags::REPORT_ASSOCIATED_TEXT) {
match &self.key {
Char(c) => format!(";{}", *c as u32),
KeyCode::Numpad(n) => format!(";{}", '0' as u32 + *n as u32),
Composed(s) => {
let mut codepoints = ";".to_string();
for c in s.chars() {
if codepoints.len() > 1 {
codepoints.push(':');
}
write!(&mut codepoints, "{}", c as u32).ok();
}
codepoints
}
_ => String::new(),
}
} else {
String::new()
};
let guess_phys = self
.raw
.as_ref()
.and_then(|raw| raw.phys_code)
.or_else(|| self.key.to_phys());
let is_numpad = guess_phys.and_then(|phys| match phys {
PhysKeyCode::Keypad0
| PhysKeyCode::Keypad1
| PhysKeyCode::Keypad2
| PhysKeyCode::Keypad3
| PhysKeyCode::Keypad4
| PhysKeyCode::Keypad5
| PhysKeyCode::Keypad6
| PhysKeyCode::Keypad7
| PhysKeyCode::Keypad8
| PhysKeyCode::Keypad9
// | PhysKeyCode::KeypadClear not a physical numpad key?
| PhysKeyCode::KeypadDecimal
| PhysKeyCode::KeypadDelete
| PhysKeyCode::KeypadDivide
| PhysKeyCode::KeypadEnter
| PhysKeyCode::KeypadEquals
| PhysKeyCode::KeypadSubtract
| PhysKeyCode::KeypadMultiply
| PhysKeyCode::KeypadAdd
=> Some(phys),
_ => None,
});
if let Some(numpad) = is_numpad {
let code = match (numpad, self.leds.contains(KeyboardLedStatus::NUM_LOCK)) {
(PhysKeyCode::Keypad0, true) => 57399,
(PhysKeyCode::Keypad0, false) => 57425,
(PhysKeyCode::Keypad1, true) => 57400,
(PhysKeyCode::Keypad1, false) => 57424,
(PhysKeyCode::Keypad2, true) => 57401,
(PhysKeyCode::Keypad2, false) => 57420,
(PhysKeyCode::Keypad3, true) => 57402,
(PhysKeyCode::Keypad3, false) => 57422,
(PhysKeyCode::Keypad4, true) => 57403,
(PhysKeyCode::Keypad4, false) => 57417,
(PhysKeyCode::Keypad5, true) => 57404,
(PhysKeyCode::Keypad5, false) => {
let xt_mods = self.modifiers.encode_xterm();
return if xt_mods == 0 && self.key_is_down {
"\x1b[E".to_string()
} else {
format!("\x1b[1;{}{event_type}E", 1 + xt_mods)
};
}
(PhysKeyCode::Keypad6, true) => 57405,
(PhysKeyCode::Keypad6, false) => 57418,
(PhysKeyCode::Keypad7, true) => 57406,
(PhysKeyCode::Keypad7, false) => 57423,
(PhysKeyCode::Keypad8, true) => 57407,
(PhysKeyCode::Keypad8, false) => 57419,
(PhysKeyCode::Keypad9, true) => 57408,
(PhysKeyCode::Keypad9, false) => 57421,
(PhysKeyCode::KeypadDecimal, _) => 57409,
(PhysKeyCode::KeypadDelete, _) => 57426,
(PhysKeyCode::KeypadDivide, _) => 57410,
(PhysKeyCode::KeypadEnter, _) => 57414,
(PhysKeyCode::KeypadEquals, _) => 57415,
(PhysKeyCode::KeypadSubtract, _) => 57412,
(PhysKeyCode::KeypadMultiply, _) => 57411,
(PhysKeyCode::KeypadAdd, _) => 57413,
_ => unreachable!(),
};
return format!("\x1b[{code};{modifiers}{event_type}{generated_text}u");
}
match &self.key {
PageUp | PageDown | Insert | Char('\x7f') => {
let c = match &self.key {
Insert => 2,
Char('\x7f') => 3, // Delete
PageUp => 5,
PageDown => 6,
_ => unreachable!(),
};
format!("\x1b[{c};{modifiers}{event_type}~")
}
Char(shifted_key) => {
let shifted_key = if *shifted_key == '\x08' {
// Backspace is really VERASE -> ASCII DEL
'\x7f'
} else {
*shifted_key
};
let use_legacy = !flags.contains(KittyKeyboardFlags::REPORT_ALTERNATE_KEYS)
&& event_type.is_empty()
&& is_legacy_key
&& !(flags.contains(KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES)
&& (self.modifiers.contains(Modifiers::CTRL)
|| self.modifiers.contains(Modifiers::ALT)))
&& !self.modifiers.intersects(
Modifiers::SUPER, /* TODO: Hyper and Meta should be added here. */
);
if use_legacy {
// Legacy text key
// https://sw.kovidgoyal.net/kitty/keyboard-protocol/#legacy-text-keys
let mut output = String::new();
if self.modifiers.contains(Modifiers::ALT) {
output.push('\x1b');
}
if self.modifiers.contains(Modifiers::CTRL) {
csi_u_encode(
&mut output,
shifted_key.to_ascii_uppercase(),
self.modifiers,
);
} else {
output.push(shifted_key);
}
return output;
}
// FIXME: ideally we'd get the correct unshifted key from
// the OS based on the current keyboard layout. That needs
// more plumbing, so for now, we're assuming the US layout.
let c = us_layout_unshift(shifted_key);
let base_layout = self
.raw
.as_ref()
.and_then(|raw| raw.phys_code.as_ref())
.and_then(|phys| match phys.to_key_code() {
KeyCode::Char(base) if base != c => Some(base),
_ => None,
});
let mut key_code = format!("{}", (c as u32));
if flags.contains(KittyKeyboardFlags::REPORT_ALTERNATE_KEYS)
&& (c != shifted_key || base_layout.is_some())
{
key_code.push(':');
if c != shifted_key {
key_code.push_str(&format!("{}", (shifted_key as u32)));
}
if let Some(base) = base_layout {
key_code.push_str(&format!(":{}", (base as u32)));
}
}
format!("\x1b[{key_code};{modifiers}{event_type}{generated_text}u")
}
LeftArrow | RightArrow | UpArrow | DownArrow | Home | End => {
let c = match &self.key {
UpArrow => 'A',
DownArrow => 'B',
RightArrow => 'C',
LeftArrow => 'D',
Home => 'H',
End => 'F',
_ => unreachable!(),
};
format!("\x1b[1;{modifiers}{event_type}{c}")
}
Function(n) if *n < 25 => {
// The spec says that kitty prefers an SS3 form for F1-F4,
// but then has some variance in the encoding and cites a
// compatibility issue with a cursor position report.
// Since it allows reporting these all unambiguously with
// the same general scheme, that is what we're using here.
let intro = match *n {
1 => "\x1b[11",
2 => "\x1b[12",
3 => "\x1b[13",
4 => "\x1b[14",
5 => "\x1b[15",
6 => "\x1b[17",
7 => "\x1b[18",
8 => "\x1b[19",
9 => "\x1b[20",
10 => "\x1b[21",
11 => "\x1b[23",
12 => "\x1b[24",
13 => "\x1b[57376",
14 => "\x1b[57377",
15 => "\x1b[57378",
16 => "\x1b[57379",
17 => "\x1b[57380",
18 => "\x1b[57381",
19 => "\x1b[57382",
20 => "\x1b[57383",
21 => "\x1b[57384",
22 => "\x1b[57385",
23 => "\x1b[57386",
24 => "\x1b[57387",
_ => unreachable!(),
};
// for F1-F12 the spec says we should terminate with ~
// for F13 and up the spec says we should terminate with u
let end_char = if *n < 13 { '~' } else { 'u' };
format!("{intro};{modifiers}{event_type}{end_char}")
}
_ => {
let code = self.raw.as_ref().and_then(|raw| raw.kitty_function_code());
match (
code,
flags.contains(KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES),
) {
(Some(code), true) => {
format!("\x1b[{code};{modifiers}{event_type}{generated_text}u")
}
_ => String::new(),
}
}
}
}
}
fn csi_u_encode(buf: &mut String, c: char, mods: Modifiers) {
let c = if mods.contains(Modifiers::CTRL) && ctrl_mapping(c).is_some() {
ctrl_mapping(c).unwrap()
} else {
c
};
if mods.contains(Modifiers::ALT) {
buf.push(0x1b as char);
}
write!(buf, "{}", c).ok();
}
bitflags::bitflags! {
pub struct KittyKeyboardFlags: u16 {
const NONE = 0;
const DISAMBIGUATE_ESCAPE_CODES = 1;
const REPORT_EVENT_TYPES = 2;
const REPORT_ALTERNATE_KEYS = 4;
const REPORT_ALL_KEYS_AS_ESCAPE_CODES = 8;
const REPORT_ASSOCIATED_TEXT = 16;
}
}
bitflags! {
#[derive(FromDynamic, ToDynamic)]
#[cfg_attr(feature="serde", derive(Serialize, Deserialize), serde(try_from = "String"))]
#[dynamic(try_from = "String", into = "String")]
pub struct WindowDecorations: u8 {
const TITLE = 1;
const RESIZE = 2;
const NONE = 0;
// Reserve two bits for this enable/disable shadow,
// so that we effective have Option<bool>
const MACOS_FORCE_DISABLE_SHADOW = 4;
const MACOS_FORCE_ENABLE_SHADOW = 4|8;
const INTEGRATED_BUTTONS = 16;
const MACOS_FORCE_SQUARE_CORNERS = 32;
const MACOS_USE_BACKGROUND_COLOR_AS_TITLEBAR_COLOR = 64;
}
}
impl Into<String> for &WindowDecorations {
fn into(self) -> String {
let mut s = vec![];
if self.contains(WindowDecorations::TITLE) {
s.push("TITLE");
}
if self.contains(WindowDecorations::RESIZE) {
s.push("RESIZE");
}
if self.contains(WindowDecorations::INTEGRATED_BUTTONS) {
s.push("INTEGRATED_BUTTONS");
}
if self.contains(WindowDecorations::MACOS_USE_BACKGROUND_COLOR_AS_TITLEBAR_COLOR) {
s.push("MACOS_USE_BACKGROUND_COLOR_AS_TITLEBAR_COLOR")
}
if self.contains(WindowDecorations::MACOS_FORCE_ENABLE_SHADOW) {
s.push("MACOS_FORCE_ENABLE_SHADOW");
} else if self.contains(WindowDecorations::MACOS_FORCE_DISABLE_SHADOW) {
s.push("MACOS_FORCE_DISABLE_SHADOW");
} else if self.contains(WindowDecorations::MACOS_FORCE_SQUARE_CORNERS) {
s.push("MACOS_FORCE_SQUARE_CORNERS");
}
if s.is_empty() {
"NONE".to_string()
} else {
s.join("|")
}
}
}
impl TryFrom<String> for WindowDecorations {
type Error = String;
fn try_from(s: String) -> core::result::Result<WindowDecorations, String> {
let mut flags = Self::NONE;
for ele in s.split('|') {
let ele = ele.trim();
if ele == "TITLE" {
flags |= Self::TITLE;
} else if ele == "NONE" || ele == "None" {
flags = Self::NONE;
} else if ele == "RESIZE" {
flags |= Self::RESIZE;
} else if ele == "MACOS_USE_BACKGROUND_COLOR_AS_TITLEBAR_COLOR" {
flags |= Self::MACOS_USE_BACKGROUND_COLOR_AS_TITLEBAR_COLOR;
} else if ele == "MACOS_FORCE_DISABLE_SHADOW" {
flags |= Self::MACOS_FORCE_DISABLE_SHADOW;
} else if ele == "MACOS_FORCE_ENABLE_SHADOW" {
flags |= Self::MACOS_FORCE_ENABLE_SHADOW;
} else if ele == "MACOS_FORCE_SQUARE_CORNERS" {
flags |= Self::MACOS_FORCE_SQUARE_CORNERS;
} else if ele == "INTEGRATED_BUTTONS" {
flags |= Self::INTEGRATED_BUTTONS;
} else {
return Err(format!("invalid WindowDecoration name {} in {}", ele, s));
}
}
Ok(flags)
}
}
impl Default for WindowDecorations {
fn default() -> Self {
if cfg!(target_os = "macos") {
WindowDecorations::TITLE | WindowDecorations::RESIZE
} else {
WindowDecorations::RESIZE | WindowDecorations::INTEGRATED_BUTTONS
}
}
}
impl WindowDecorations {
/// Whether the platform should render a title bar separate from the
/// application-provided integrated title buttons.
///
/// Treat integrated buttons as authoritative when both flags are present
/// so that an imported or legacy configuration cannot produce two title
/// bars.
pub fn shows_separate_title_bar(self) -> bool {
self.contains(Self::TITLE) && !self.contains(Self::INTEGRATED_BUTTONS)
}
}
#[derive(Debug, FromDynamic, ToDynamic, PartialEq, Eq, Clone, Copy)]
pub enum IntegratedTitleButton {
Hide,
Maximize,
Close,
}
#[derive(Debug, Default, FromDynamic, ToDynamic, PartialEq, Eq, Clone, Copy)]
pub enum IntegratedTitleButtonAlignment {
#[default]
Right,
Left,
}
#[derive(Debug, ToDynamic, PartialEq, Eq, Clone, Copy)]
pub enum IntegratedTitleButtonStyle {
Windows,
Gnome,
MacOsNative,
}
impl Default for IntegratedTitleButtonStyle {
fn default() -> Self {
if cfg!(target_os = "macos") {
Self::MacOsNative
} else {
Self::Windows
}
}
}
impl FromDynamic for IntegratedTitleButtonStyle {
fn from_dynamic(
value: &wezterm_dynamic::Value,
_options: wezterm_dynamic::FromDynamicOptions,
) -> Result<Self, wezterm_dynamic::Error>
where
Self: Sized,
{
let type_name = "integrated_title_button_style";
if let wezterm_dynamic::Value::String(string) = value {
let style = match string.as_str() {
"Windows" => Self::Windows,
"Gnome" => Self::Gnome,
"MacOsNative" if cfg!(target_os = "macos") => Self::MacOsNative,
_ => {
return Err(wezterm_dynamic::Error::InvalidVariantForType {
variant_name: string.to_string(),
type_name,
possible: &["Windows", "Gnome", "MacOsNative"],
});
}
};
Ok(style)
} else {
Err(wezterm_dynamic::Error::InvalidVariantForType {
variant_name: value.variant_name().to_string(),
type_name,
possible: &["String"],
})
}
}
}
/// Kitty wants us to report the un-shifted version of a key.
/// It's a PITA to obtain that from the OS-dependent keyboard
/// layout stuff. For the moment, we'll do the slightly gross
/// thing and make an assumption that a US ANSI layout is in
/// use; this function encodes that mapping.
fn us_layout_unshift(c: char) -> char {
match c {
'!' => '1',
'@' => '2',
'#' => '3',
'$' => '4',
'%' => '5',
'^' => '6',
'&' => '7',
'*' => '8',
'(' => '9',
')' => '0',
'_' => '-',
'+' => '=',
'~' => '`',
'{' => '[',
'}' => ']',
'|' => '\\',
':' => ';',
'"' => '\'',
'<' => ',',
'>' => '.',
'?' => '/',
c => {
let s: Vec<char> = c.to_lowercase().collect();
if s.len() == 1 {
s[0]
} else {
c
}
}
}
}
/// Map c to its Ctrl equivalent.
/// In theory, this mapping is simply translating alpha characters
/// to upper case and then masking them by 0x1f, but xterm inherits
/// some built-in translation from legacy X11 so that are some
/// aliased mappings and a couple that might be technically tied
/// to US keyboard layout (particularly the punctuation characters
/// produced in combination with SHIFT) that may not be 100%
/// the right thing to do here for users with non-US layouts.
pub fn ctrl_mapping(c: char) -> Option<char> {
Some(match c {
'@' | '`' | ' ' | '2' => '\x00',
'A' | 'a' => '\x01',
'B' | 'b' => '\x02',
'C' | 'c' => '\x03',
'D' | 'd' => '\x04',
'E' | 'e' => '\x05',
'F' | 'f' => '\x06',
'G' | 'g' => '\x07',
'H' | 'h' => '\x08',
'I' | 'i' => '\x09',
'J' | 'j' => '\x0a',
'K' | 'k' => '\x0b',
'L' | 'l' => '\x0c',
'M' | 'm' => '\x0d',
'N' | 'n' => '\x0e',
'O' | 'o' => '\x0f',
'P' | 'p' => '\x10',
'Q' | 'q' => '\x11',
'R' | 'r' => '\x12',
'S' | 's' => '\x13',
'T' | 't' => '\x14',
'U' | 'u' => '\x15',
'V' | 'v' => '\x16',
'W' | 'w' => '\x17',
'X' | 'x' => '\x18',
'Y' | 'y' => '\x19',
'Z' | 'z' => '\x1a',
'[' | '3' | '{' => '\x1b',
'\\' | '4' | '|' => '\x1c',
']' | '5' | '}' => '\x1d',
'^' | '6' | '~' => '\x1e',
'_' | '7' | '/' => '\x1f',
'8' | '?' => '\x7f', // `Delete`
_ => return None,
})
}
#[derive(Debug, FromDynamic, ToDynamic, Clone, Copy, PartialEq, Eq)]
pub enum UIKeyCapRendering {
/// Super, Meta, Ctrl, Shift
UnixLong,
/// Super, M, C, S
Emacs,
/// Apple macOS style symbols
AppleSymbols,
/// Win, Alt, Ctrl, Shift
WindowsLong,
/// Like WindowsLong, but using a logo for the Win key
WindowsSymbols,
}
impl Default for UIKeyCapRendering {
fn default() -> Self {
if cfg!(target_os = "macos") {
Self::AppleSymbols
} else if cfg!(windows) {
Self::WindowsSymbols
} else {
Self::UnixLong
}
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn integrated_window_buttons_suppress_a_separate_title_bar() {
assert!((WindowDecorations::TITLE | WindowDecorations::RESIZE).shows_separate_title_bar());
assert!(
!(WindowDecorations::RESIZE | WindowDecorations::INTEGRATED_BUTTONS)
.shows_separate_title_bar()
);
assert!(!(WindowDecorations::TITLE
| WindowDecorations::RESIZE
| WindowDecorations::INTEGRATED_BUTTONS)
.shows_separate_title_bar());
}
#[test]
fn encode_issue_3220() {
let flags =
KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES | KittyKeyboardFlags::REPORT_EVENT_TYPES;
assert_eq!(
KeyEvent {
key: KeyCode::Char('o'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"o".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('o'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[111;1:3u".to_string()
);
}
#[test]
fn encode_issue_3473() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES;
assert_eq!(
KeyEvent {
key: KeyCode::Function(1),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[11;1~".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Function(1),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[11;1:3~".to_string()
);
}
#[test]
fn encode_issue_2546() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES;
assert_eq!(
KeyEvent {
key: KeyCode::Char('i'),
modifiers: Modifiers::ALT | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;4u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('I'),
modifiers: Modifiers::ALT | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;4u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('1'),
modifiers: Modifiers::ALT | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[49;4u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Char('!'),
modifiers: Modifiers::ALT | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::K1)
)
.encode_kitty(flags),
"\x1b[49;4u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('i'),
modifiers: Modifiers::SHIFT | Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;6u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('I'),
modifiers: Modifiers::SHIFT | Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;6u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('I'),
modifiers: Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: Some(RawKeyEvent {
key: KeyCode::Char('I'),
modifiers: Modifiers::SHIFT | Modifiers::CTRL,
handled: Handled::new(),
key_is_down: true,
raw_code: 0,
leds: KeyboardLedStatus::empty(),
phys_code: Some(PhysKeyCode::I),
#[cfg(windows)]
scan_code: 0,
repeat_count: 1,
}),
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;6u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('i'),
modifiers: Modifiers::ALT | Modifiers::SHIFT | Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;8u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('I'),
modifiers: Modifiers::ALT | Modifiers::SHIFT | Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[105;8u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('\x08'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x7f".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('\x08'),
modifiers: Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\x1b[127;5u".to_string()
);
}
#[test]
fn encode_issue_3474() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES;
assert_eq!(
KeyEvent {
key: KeyCode::Char('A'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\u{1b}[97:65;1u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('A'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\u{1b}[97:65;1:3u".to_string()
);
}
fn make_event_with_raw(mut event: KeyEvent, phys: Option<PhysKeyCode>) -> KeyEvent {
let phys = match phys {
Some(phys) => Some(phys),
None => event.key.to_phys(),
};
event.raw = Some(RawKeyEvent {
key: event.key.clone(),
modifiers: event.modifiers,
leds: KeyboardLedStatus::empty(),
phys_code: phys,
raw_code: 0,
#[cfg(windows)]
scan_code: 0,
repeat_count: 1,
key_is_down: event.key_is_down,
handled: Handled::new(),
});
event
}
#[test]
fn encode_issue_3476() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES;
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::LeftShift,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57441;1u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::LeftShift,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57441;1:3u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::LeftControl,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57442;1u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::LeftControl,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57442;1:3u".to_string()
);
}
#[test]
fn encode_issue_3478() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES;
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(0),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57425;1u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(0),
modifiers: Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57425;2u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(1),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57424;1u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(1),
modifiers: Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
None
)
.encode_kitty(flags),
"\u{1b}[57424;2u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(0),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::NUM_LOCK,
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad0)
)
.encode_kitty(flags),
"\u{1b}[57399;129u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(0),
modifiers: Modifiers::SHIFT,
leds: KeyboardLedStatus::NUM_LOCK,
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad0)
)
.encode_kitty(flags),
"\u{1b}[57399;130u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(5),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::NUM_LOCK,
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad5)
)
.encode_kitty(flags),
"\u{1b}[57404;129u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(5),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad5)
)
.encode_kitty(flags),
"\u{1b}[E".to_string()
);
}
#[test]
fn encode_issue_3478_extra() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_ASSOCIATED_TEXT;
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(5),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::NUM_LOCK,
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad5)
)
.encode_kitty(flags),
"\u{1b}[57404;129;53u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(5),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::NUM_LOCK,
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad5)
)
.encode_kitty(flags),
"\u{1b}[57404;129:3u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(5),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad5)
)
.encode_kitty(flags),
"\u{1b}[E".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Numpad(5),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: false,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::Keypad5)
)
.encode_kitty(flags),
"\u{1b}[1;1:3E".to_string()
);
}
#[test]
fn encode_issue_3315() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES;
assert_eq!(
KeyEvent {
key: KeyCode::Char('"'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\"".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('"'),
modifiers: Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\"".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('!'),
modifiers: Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"!".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::LeftShift,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"".to_string()
);
}
#[test]
fn encode_issue_3479() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES;
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Char('ф'),
modifiers: Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::A)
)
.encode_kitty(flags),
"\x1b[1092::97;5u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Char('Ф'),
modifiers: Modifiers::CTRL | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::A)
)
.encode_kitty(flags),
"\x1b[1092:1060:97;6u".to_string()
);
}
#[test]
fn encode_issue_3484() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_EVENT_TYPES
| KittyKeyboardFlags::REPORT_ALTERNATE_KEYS
| KittyKeyboardFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
| KittyKeyboardFlags::REPORT_ASSOCIATED_TEXT;
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Char('ф'),
modifiers: Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::A)
)
.encode_kitty(flags),
"\x1b[1092::97;5;1092u".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::Char('Ф'),
modifiers: Modifiers::CTRL | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::A)
)
.encode_kitty(flags),
"\x1b[1092:1060:97;6;1060u".to_string()
);
}
#[test]
fn encode_issue_3526() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES;
assert_eq!(
KeyEvent {
key: KeyCode::Char(' '),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::NUM_LOCK,
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
" ".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char(' '),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::CAPS_LOCK,
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
" ".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::NumLock,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::NumLock)
)
.encode_kitty(flags),
"".to_string()
);
assert_eq!(
make_event_with_raw(
KeyEvent {
key: KeyCode::CapsLock,
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
},
Some(PhysKeyCode::CapsLock)
)
.encode_kitty(flags),
"".to_string()
);
}
#[test]
fn encode_issue_4436() {
let flags = KittyKeyboardFlags::DISAMBIGUATE_ESCAPE_CODES;
assert_eq!(
KeyEvent {
key: KeyCode::Char('q'),
modifiers: Modifiers::NONE,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"q".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('f'),
modifiers: Modifiers::SUPER,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\u{1b}[102;9u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('f'),
modifiers: Modifiers::SUPER | Modifiers::SHIFT,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\u{1b}[102;10u".to_string()
);
assert_eq!(
KeyEvent {
key: KeyCode::Char('f'),
modifiers: Modifiers::SUPER | Modifiers::SHIFT | Modifiers::CTRL,
leds: KeyboardLedStatus::empty(),
repeat_count: 1,
key_is_down: true,
raw: None,
#[cfg(windows)]
win32_uni_char: None,
}
.encode_kitty(flags),
"\u{1b}[102;14u".to_string()
);
}
}