me/unfettered-keyboard
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

core: layout: add text property to key parts

Browse source 
Some keys may have no XKB key symbol, but still have the ability to emit
text. Examples include the "‹" (U+2039) and "›" (U+203A) characters. Add
the text property to key parts so they can emit text even with no key
symbol.

Also, for keys that were not modified by the Function key because they
had no XKB key symbol name, modify them.
This commit is contained in:
Richard Acayan 2024-07-26 19:54:28 -04:00
parent 57c9d39293
commit 5aaaedb887
1 changed files with 173 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

277
src/core/layout.rs
View file

@ -56,11 +56,21 @@ pub const MOD_ALT: usize = 3;
pub const MOD_FN: usize = 4; pub const MOD_FN: usize = 4;
pub const MODIFIERS_MAX: usize = 4; pub const MODIFIERS_MAX: usize = 4;
pub struct Part { #[derive(Clone)]
orig_sym: Keysym, struct KeyValue(Keysym, String);
sym: Keysym,
impl KeyValue {
fn from(key: Keysym, text: &str) -> KeyValue
{
KeyValue(key, String::from(text))
}
}
pub struct Part {
orig: KeyValue,
val: KeyValue,
// TODO: use accessors here
presses: u32, presses: u32,
} }
@ -103,79 +113,130 @@ impl Part {
} }
} }
fn modify_fn(orig_sym: Keysym) -> Keysym fn modify_fn(orig_sym: &KeyValue) -> KeyValue
{ {
match orig_sym { match orig_sym {
Keysym::Up => Keysym::Prior, // Page Up KeyValue(Keysym::Up, _)
Keysym::Down => Keysym::Next, // Page Down => KeyValue::from(Keysym::Prior, "⇑"), // Page Up
Keysym::Left => Keysym::Home, KeyValue(Keysym::Down, _)
Keysym::Right => Keysym::End, => KeyValue::from(Keysym::Next, "⇓"), // Page Down
Keysym::Escape => Keysym::Insert, KeyValue(Keysym::Left, _)
=> KeyValue::from(Keysym::Home, "⇤"),
KeyValue(Keysym::Right, _)
=> KeyValue::from(Keysym::End, "⇥"),
KeyValue(Keysym::Escape, _)
=> KeyValue::from(Keysym::Insert, "Ins"),
Keysym::_1 => Keysym::F1, KeyValue(Keysym::_1, _)
Keysym::_2 => Keysym::F2, => KeyValue::from(Keysym::F1, "F1"),
Keysym::_3 => Keysym::F3, KeyValue(Keysym::_2, _)
Keysym::_4 => Keysym::F4, => KeyValue::from(Keysym::F2, "F2"),
Keysym::_5 => Keysym::F5, KeyValue(Keysym::_3, _)
Keysym::_6 => Keysym::F6, => KeyValue::from(Keysym::F3, "F3"),
Keysym::_7 => Keysym::F7, KeyValue(Keysym::_4, _)
Keysym::_8 => Keysym::F8, => KeyValue::from(Keysym::F4, "F4"),
Keysym::_9 => Keysym::F9, KeyValue(Keysym::_5, _)
Keysym::_0 => Keysym::F10, => KeyValue::from(Keysym::F5, "F5"),
KeyValue(Keysym::_6, _)
=> KeyValue::from(Keysym::F6, "F6"),
KeyValue(Keysym::_7, _)
=> KeyValue::from(Keysym::F7, "F7"),
KeyValue(Keysym::_8, _)
=> KeyValue::from(Keysym::F8, "F8"),
KeyValue(Keysym::_9, _)
=> KeyValue::from(Keysym::F9, "F9"),
KeyValue(Keysym::_0, _)
=> KeyValue::from(Keysym::F10, "F10"),
Keysym::less => Keysym::guillemetleft, KeyValue(Keysym::less, _)
Keysym::greater => Keysym::guillemetright, => KeyValue::from(Keysym::guillemetleft, "«"),
// Keysym::braceleft => Keysym::from_char('\u{2039}'), KeyValue(Keysym::greater, _)
// Keysym::braceright => Keysym::from_char('\u{203A}'), => KeyValue::from(Keysym::guillemetright, "»"),
Keysym::bracketleft => Keysym::leftsinglequotemark, KeyValue(Keysym::braceleft, _)
Keysym::bracketright => Keysym::rightsinglequotemark, => KeyValue::from(Keysym::NoSymbol, "‹"),
Keysym::parenleft => Keysym::leftdoublequotemark, KeyValue(Keysym::braceright, _)
Keysym::parenright => Keysym::rightdoublequotemark, => KeyValue::from(Keysym::NoSymbol, "›"),
Keysym::apostrophe => Keysym::singlelowquotemark, KeyValue(Keysym::bracketleft, _)
Keysym::quotedbl => Keysym::doublelowquotemark, => KeyValue::from(Keysym::leftsinglequotemark, "‘"),
Keysym::minus => Keysym::endash, KeyValue(Keysym::bracketright, _)
Keysym::underscore => Keysym::emdash, => KeyValue::from(Keysym::rightsinglequotemark, "’"),
Keysym::asciicircum => Keysym::notsign, KeyValue(Keysym::parenleft, _)
Keysym::percent => Keysym::permille, => KeyValue::from(Keysym::leftdoublequotemark, "“"),
Keysym::equal => Keysym::approxeq, KeyValue(Keysym::parenright, _)
Keysym::u => Keysym::mu, => KeyValue::from(Keysym::rightdoublequotemark, "”"),
Keysym::a => Keysym::ae, KeyValue(Keysym::apostrophe, _)
Keysym::o => Keysym::oe, => KeyValue::from(Keysym::singlelowquotemark, "‚"),
Keysym::asterisk => Keysym::degree, KeyValue(Keysym::quotedbl, _)
Keysym::period => Keysym::ellipsis, => KeyValue::from(Keysym::doublelowquotemark, "„"),
Keysym::comma => Keysym::periodcentered, KeyValue(Keysym::minus, _)
Keysym::exclam => Keysym::exclamdown, => KeyValue::from(Keysym::endash, "–"),
Keysym::question => Keysym::questiondown, KeyValue(Keysym::underscore, _)
Keysym::bar => Keysym::brokenbar, => KeyValue::from(Keysym::emdash, "—"),
KeyValue(Keysym::asciicircum, _)
=> KeyValue::from(Keysym::notsign, "¬"),
KeyValue(Keysym::percent, _)
=> KeyValue::from(Keysym::permille, "‰"),
KeyValue(Keysym::equal, _)
=> KeyValue::from(Keysym::approxeq, "≈"),
KeyValue(Keysym::u, _)
=> KeyValue::from(Keysym::mu, "µ"),
KeyValue(Keysym::a, _)
=> KeyValue::from(Keysym::ae, "æ"),
KeyValue(Keysym::o, _)
=> KeyValue::from(Keysym::oe, "œ"),
KeyValue(Keysym::asterisk, _)
=> KeyValue::from(Keysym::degree, "°"),
KeyValue(Keysym::period, _)
=> KeyValue::from(Keysym::ellipsis, "…"),
KeyValue(Keysym::comma, _)
=> KeyValue::from(Keysym::periodcentered, "·"),
KeyValue(Keysym::exclam, _)
=> KeyValue::from(Keysym::exclamdown, "¡"),
KeyValue(Keysym::question, _)
=> KeyValue::from(Keysym::questiondown, "¿"),
KeyValue(Keysym::bar, _)
=> KeyValue::from(Keysym::brokenbar, "¦"),
Keysym::e => Keysym::EuroSign, KeyValue(Keysym::e, _)
Keysym::l => Keysym::sterling, => KeyValue::from(Keysym::EuroSign, "€"),
// Keysym::r => Keysym::from_char('\u{20B9}'), KeyValue(Keysym::l, _)
Keysym::y => Keysym::yen, => KeyValue::from(Keysym::sterling, "£"),
Keysym::c => Keysym::cent, KeyValue(Keysym::r, _)
// Keysym::p => Keysym::from_char('\u{20BD}'), => KeyValue::from(Keysym::NoSymbol, "₹"),
// Keysym::b => Keysym::from_char('\u{20B1}'), KeyValue(Keysym::y, _)
// Keysym::h => Keysym::from_char('\u{20B4}'), => KeyValue::from(Keysym::yen, "¥"),
// Keysym::z => Keysym::from_char('\u{20BF}'), KeyValue(Keysym::c, _)
=> KeyValue::from(Keysym::cent, "¢"),
KeyValue(Keysym::p, _)
=> KeyValue::from(Keysym::NoSymbol, "₽"),
KeyValue(Keysym::b, _)
=> KeyValue::from(Keysym::NoSymbol, "₱"),
KeyValue(Keysym::h, _)
=> KeyValue::from(Keysym::NoSymbol, "₴"),
KeyValue(Keysym::z, _)
=> KeyValue::from(Keysym::NoSymbol, "₿"),
_ => orig_sym, _ => orig_sym.clone(),
} }
} }
fn modify_no_fn(orig_sym: Keysym) -> Keysym fn modify_no_fn(orig: &KeyValue) -> KeyValue
{ {
match orig_sym { match orig {
Keysym::F11 => Keysym::NoSymbol, KeyValue(Keysym::F11, _) => KeyValue::from(Keysym::NoSymbol, ""),
Keysym::F12 => Keysym::NoSymbol, KeyValue(Keysym::F12, _) => KeyValue::from(Keysym::NoSymbol, ""),
_ => orig_sym, _ => orig.clone(),
} }
} }
fn new(orig_sym: Keysym) -> Part fn new(orig: KeyValue) -> Part
{ {
let val = Self::modify_no_fn(&orig);
Part { Part {
orig_sym, orig,
sym: Self::modify_no_fn(orig_sym), val,
presses: 0, presses: 0,
} }
} }
@ -183,7 +244,7 @@ impl Part {
#[inline(always)] #[inline(always)]
pub fn sym(&self) -> Keysym pub fn sym(&self) -> Keysym
{ {
self.sym self.val.0
} }
#[inline(always)] #[inline(always)]
@ -206,7 +267,7 @@ impl Part {
pub fn modifier_id(&self) -> usize pub fn modifier_id(&self) -> usize
{ {
match self.sym { match self.val.0 {
Keysym::Shift_L => MOD_SHIFT, Keysym::Shift_L => MOD_SHIFT,
Keysym::Control_L => MOD_CTRL, Keysym::Control_L => MOD_CTRL,
Keysym::Alt_L => MOD_ALT, Keysym::Alt_L => MOD_ALT,
@ -217,20 +278,28 @@ impl Part {
pub fn update_modifiers(&mut self, mod_state: &[ModState]) pub fn update_modifiers(&mut self, mod_state: &[ModState])
{ {
let mut sym = self.orig_sym; let mut val = self.orig.clone();
if mod_state[MOD_FN - 1] != ModState::Released { if mod_state[MOD_FN - 1] != ModState::Released {
sym = Self::modify_fn(sym); val = Self::modify_fn(&val);
} else { } else {
sym = Self::modify_no_fn(sym); val = Self::modify_no_fn(&val);
} }
self.sym = sym; self.val = val;
}
pub fn display_label(&self) -> &str
{
match self.val.1.as_ref() {
" " => "␣",
l => l,
}
} }
pub fn display_symbol(&self, mod_state: &[ModState]) -> Keysym pub fn display_symbol(&self, mod_state: &[ModState]) -> Keysym
{ {
let mut sym = self.sym; let mut sym = self.val.0;
if mod_state[MOD_SHIFT - 1] != ModState::Released { if mod_state[MOD_SHIFT - 1] != ModState::Released {
sym = Self::modify_shift(sym); sym = Self::modify_shift(sym);
@ -250,15 +319,15 @@ pub struct Key {
impl Key { impl Key {
fn new(x1: f64, y1: f64, x2: f64, y2: f64, fn new(x1: f64, y1: f64, x2: f64, y2: f64,
center: Keysym, center: KeyValue,
top_left: Keysym, top_left: KeyValue,
top_right: Keysym, top_right: KeyValue,
bottom_left: Keysym, bottom_left: KeyValue,
bottom_right: Keysym, bottom_right: KeyValue,
left: Keysym, left: KeyValue,
right: Keysym, right: KeyValue,
top: Keysym, top: KeyValue,
bottom: Keysym) -> Key bottom: KeyValue) -> Key
{ {
Key { Key {
x1, y1, x2, y2, x1, y1, x2, y2,
@ -285,27 +354,27 @@ pub struct Layout {
in_row: u32, in_row: u32,
} }
const KEYSYMS: [(&str, Keysym); 20] = [ const KEYSYMS: [(&str, Keysym, &str); 20] = [
("\\#", Keysym::numbersign), ("\\#", Keysym::numbersign, "#"),
("\\?", Keysym::question), ("\\?", Keysym::question, "?"),
("\\@", Keysym::at), ("\\@", Keysym::at, "@"),
("\\\\", Keysym::backslash), ("\\\\", Keysym::backslash, "\\"),
("backspace", Keysym::BackSpace), ("backspace", Keysym::BackSpace, "⌫"),
("ctrl", Keysym::Control_L), ("ctrl", Keysym::Control_L, "Ctrl"),
("delete", Keysym::Delete), ("delete", Keysym::Delete, "⌦"),
("down", Keysym::Down), ("down", Keysym::Down, "↓"),
("enter", Keysym::Return), ("enter", Keysym::Return, "⏎"),
("esc", Keysym::Escape), ("esc", Keysym::Escape, "Esc"),
("f11_placeholder", Keysym::F11), ("f11_placeholder", Keysym::F11, "F11"),
("f12_placeholder", Keysym::F12), ("f12_placeholder", Keysym::F12, "F12"),
("fn", Keysym::XF86_Fn), ("fn", Keysym::XF86_Fn, "Fn"),
("left", Keysym::Left), ("left", Keysym::Left, "←"),
("loc alt", Keysym::Alt_L), ("loc alt", Keysym::Alt_L, "Alt"),
("right", Keysym::Right), ("right", Keysym::Right, "→"),
("shift", Keysym::Shift_L), ("shift", Keysym::Shift_L, "⇧"),
("space", Keysym::space), ("space", Keysym::space, "␣"),
("tab", Keysym::Tab), ("tab", Keysym::Tab, "⭾"),
("up", Keysym::Up), ("up", Keysym::Up, "↑"),
]; ];
impl Layout { impl Layout {
@ -335,10 +404,10 @@ impl Layout {
} }
} }
fn get_keysym_by_name(name: &str) -> Keysym fn get_keysym_by_name(name: &str) -> KeyValue
{ {
if let Ok(idx) = KEYSYMS.binary_search_by_key(&name, |&(k, _)| k) { if let Ok(idx) = KEYSYMS.binary_search_by_key(&name, |&(k, _, _)| k) {
return KEYSYMS[idx].1; return KeyValue::from(KEYSYMS[idx].1, KEYSYMS[idx].2);
} }
let mut chars = name.chars(); let mut chars = name.chars();
@ -346,8 +415,8 @@ impl Layout {
let c1 = chars.next(); let c1 = chars.next();
let c2 = chars.next(); let c2 = chars.next();
match (c1, c2) { match (c1, c2) {
(Some(c), None) => Keysym::new(c as u32), (Some(c), None) => KeyValue::from(Keysym::new(c as u32), name),
_ => Keysym::NoSymbol, _ => KeyValue::from(Keysym::NoSymbol, ""),
} }
} }