feat: show keyboard keys or the controller's own buttons in the hint bar

The hint bar always named Xbox buttons, so someone at a keyboard was
told to press buttons they did not have, and owners of other pads got
the wrong letters. Hints now name an action, and the keys or button
icons come from the input used last: keyboard, or an Xbox, PlayStation,
Switch or Steam Deck controller.

Behind Steam, every pad is Steam's virtual one. remus reads the file
Steam names in SteamVirtualGamepadInfo to find the physical controller,
matching the slot in the pad's name, as SDL does. Icons are Kenney's
Input Prompts (CC0), with the licence beside them.
This commit is contained in:
Ansho Rei
2026-11-04 10:43:56 +01:00
parent 8255e39047
commit 28a8b8af11
69 changed files with 902 additions and 71 deletions
+307
View File
@@ -0,0 +1,307 @@
//! Which icons the hint bar shows: keyboard keys, or the buttons of the
//! controller in use. Icons are Kenney's Input Prompts (CC0), in ui/prompts.
use std::collections::HashMap;
/// Controller families with their own button icons.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Family {
Xbox,
PlayStation,
Switch,
SteamDeck,
}
/// What the hints are drawn for.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Prompts {
Keyboard,
Pad(Family),
}
/// An action the hint bar can point at. Each maps to one control per input:
/// the gamepad side matches `button_action` in src/input.rs, the keyboard
/// side the key-pressed handler in ui/app.slint.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Control {
Activate,
Back,
PlayPause,
Queue,
Skip,
Sections,
Search,
NowPlaying,
Seek,
/// Steam + X brings up Steam's on-screen keyboard. Nothing to show for a
/// real keyboard.
OnScreenKeyboard,
}
#[cfg(test)]
impl Control {
pub const ALL: [Control; 10] = [
Control::Activate,
Control::Back,
Control::PlayPause,
Control::Queue,
Control::Skip,
Control::Sections,
Control::Search,
Control::NowPlaying,
Control::Seek,
Control::OnScreenKeyboard,
];
}
macro_rules! icon {
($dir:literal, $name:literal) => {
include_bytes!(concat!("../ui/prompts/", $dir, "/", $name, ".svg")) as &'static [u8]
};
}
/// The SVG icons for `control`, left to right. Empty when there is nothing to
/// press for it with this input.
pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
use Control::*;
match prompts {
Prompts::Keyboard => match control {
Activate => &[icon!("keyboard", "keyboard_enter")],
Back => &[icon!("keyboard", "keyboard_escape")],
PlayPause => &[icon!("keyboard", "keyboard_space")],
Queue => &[icon!("keyboard", "keyboard_q")],
Skip => &[icon!("keyboard", "keyboard_p"), icon!("keyboard", "keyboard_n")],
Sections => &[icon!("keyboard", "keyboard_tab")],
Search => &[icon!("keyboard", "keyboard_slash_forward")],
NowPlaying => &[icon!("keyboard", "keyboard_f")],
Seek => &[icon!("keyboard", "keyboard_arrows_horizontal")],
OnScreenKeyboard => &[],
},
Prompts::Pad(Family::Xbox) => match control {
Activate => &[icon!("xbox", "xbox_button_color_a")],
Back => &[icon!("xbox", "xbox_button_color_b")],
PlayPause => &[icon!("xbox", "xbox_button_color_x")],
Queue => &[icon!("xbox", "xbox_button_color_y")],
Skip => &[icon!("xbox", "xbox_lb"), icon!("xbox", "xbox_rb")],
Sections => &[icon!("xbox", "xbox_lt"), icon!("xbox", "xbox_rt")],
Search => &[icon!("xbox", "xbox_button_view")],
NowPlaying => &[icon!("xbox", "xbox_button_menu")],
Seek => &[icon!("xbox", "xbox_dpad_horizontal")],
OnScreenKeyboard => &[icon!("xbox", "xbox_guide"), icon!("xbox", "xbox_button_color_x")],
},
Prompts::Pad(Family::PlayStation) => match control {
Activate => &[icon!("playstation", "playstation_button_color_cross")],
Back => &[icon!("playstation", "playstation_button_color_circle")],
PlayPause => &[icon!("playstation", "playstation_button_color_square")],
Queue => &[icon!("playstation", "playstation_button_color_triangle")],
Skip => &[
icon!("playstation", "playstation_trigger_l1"),
icon!("playstation", "playstation_trigger_r1"),
],
Sections => &[
icon!("playstation", "playstation_trigger_l2"),
icon!("playstation", "playstation_trigger_r2"),
],
Search => &[icon!("playstation", "playstation5_button_create")],
NowPlaying => &[icon!("playstation", "playstation5_button_options")],
Seek => &[icon!("playstation", "playstation_dpad_horizontal")],
// The pack has no PS button; Steam's own label says the same thing.
OnScreenKeyboard => &[
icon!("steamdeck", "steamdeck_button_guide"),
icon!("playstation", "playstation_button_color_square"),
],
},
// By position, as gilrs reports buttons: the bottom face button is B on a Switch.
Prompts::Pad(Family::Switch) => match control {
Activate => &[icon!("switch", "switch_button_b")],
Back => &[icon!("switch", "switch_button_a")],
PlayPause => &[icon!("switch", "switch_button_y")],
Queue => &[icon!("switch", "switch_button_x")],
Skip => &[icon!("switch", "switch_button_l"), icon!("switch", "switch_button_r")],
Sections => &[icon!("switch", "switch_button_zl"), icon!("switch", "switch_button_zr")],
Search => &[icon!("switch", "switch_button_minus")],
NowPlaying => &[icon!("switch", "switch_button_plus")],
Seek => &[icon!("switch", "switch_dpad_horizontal")],
OnScreenKeyboard => &[
icon!("switch", "switch_button_home"),
icon!("switch", "switch_button_y"),
],
},
Prompts::Pad(Family::SteamDeck) => match control {
Activate => &[icon!("steamdeck", "steamdeck_button_a")],
Back => &[icon!("steamdeck", "steamdeck_button_b")],
PlayPause => &[icon!("steamdeck", "steamdeck_button_x")],
Queue => &[icon!("steamdeck", "steamdeck_button_y")],
Skip => &[
icon!("steamdeck", "steamdeck_button_l1"),
icon!("steamdeck", "steamdeck_button_r1"),
],
Sections => &[
icon!("steamdeck", "steamdeck_button_l2"),
icon!("steamdeck", "steamdeck_button_r2"),
],
Search => &[icon!("steamdeck", "steamdeck_button_view")],
NowPlaying => &[icon!("steamdeck", "steamdeck_button_options")],
Seek => &[icon!("steamdeck", "steamdeck_dpad_horizontal")],
OnScreenKeyboard => &[
icon!("steamdeck", "steamdeck_button_guide"),
icon!("steamdeck", "steamdeck_button_x"),
],
},
}
}
const VENDOR_MICROSOFT: u16 = 0x045e;
const VENDOR_SONY: u16 = 0x054c;
const VENDOR_NINTENDO: u16 = 0x057e;
pub const VENDOR_VALVE: u16 = 0x28de;
/// Steam's virtual gamepad, which stands in for whatever is really connected.
pub const PRODUCT_STEAM_VIRTUAL_GAMEPAD: u16 = 0x11ff;
const PRODUCT_STEAM_DECK: u16 = 0x1205;
/// The family of a physical controller, by its USB ids. Unknown controllers,
/// and Steam's virtual one, get Xbox icons: most pads follow that layout.
pub fn family_from_ids(vendor: Option<u16>, product: Option<u16>) -> Family {
match (vendor, product) {
(Some(VENDOR_SONY), _) => Family::PlayStation,
(Some(VENDOR_NINTENDO), _) => Family::Switch,
(Some(VENDOR_VALVE), Some(PRODUCT_STEAM_DECK)) => Family::SteamDeck,
(Some(VENDOR_MICROSOFT), _) => Family::Xbox,
_ => Family::Xbox,
}
}
/// One physical controller listed in Steam's virtual gamepad file.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct VirtualPad {
pub vendor: Option<u16>,
pub product: Option<u16>,
}
/// Parses the file `SteamVirtualGamepadInfo` points at, as SDL does
/// (src/joystick/SDL_steam_virtual_gamepad.c): `[slot N]` sections with
/// `VID=` and `PID=` lines, numbers in C notation (0x for hex).
pub fn parse_virtual_pads(text: &str) -> HashMap<u32, VirtualPad> {
let mut pads = HashMap::new();
let mut slot: Option<u32> = None;
for line in text.lines().map(str::trim) {
if let Some(n) = line.strip_prefix("[slot").and_then(|r| r.strip_suffix(']')) {
slot = n.trim().parse().ok();
if let Some(s) = slot {
pads.entry(s).or_insert(VirtualPad {
vendor: None,
product: None,
});
}
continue;
}
let (Some(s), Some((key, value))) = (slot, line.split_once('=')) else {
continue;
};
let Some(pad) = pads.get_mut(&s) else { continue };
match key {
"VID" => pad.vendor = parse_c_number(value),
"PID" => pad.product = parse_c_number(value),
_ => {}
}
}
pads
}
fn parse_c_number(s: &str) -> Option<u16> {
let s = s.trim();
match s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
Some(hex) => u16::from_str_radix(hex, 16).ok(),
None if s.len() > 1 && s.starts_with('0') => u16::from_str_radix(&s[1..], 8).ok(),
None => s.parse().ok(),
}
}
/// The slot of a Steam virtual pad, from its OS name ("... pad 2" is slot 2),
/// as SDL reads it.
pub fn virtual_slot(os_name: &str) -> Option<u32> {
let rest = &os_name[os_name.find("pad ")? + 4..];
let digits: String = rest.chars().take_while(char::is_ascii_digit).collect();
digits.parse().ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_control_has_icons_for_every_controller() {
for family in [Family::Xbox, Family::PlayStation, Family::Switch, Family::SteamDeck] {
for control in Control::ALL {
assert!(
!icons(Prompts::Pad(family), control).is_empty(),
"{family:?} {control:?}"
);
}
}
}
#[test]
fn keyboard_has_icons_for_everything_but_steam_keyboard() {
for control in Control::ALL {
let n = icons(Prompts::Keyboard, control).len();
if control == Control::OnScreenKeyboard {
assert_eq!(n, 0);
} else {
assert!(n > 0, "{control:?}");
}
}
}
#[test]
fn icons_are_svg() {
for prompts in [
Prompts::Keyboard,
Prompts::Pad(Family::Xbox),
Prompts::Pad(Family::PlayStation),
Prompts::Pad(Family::Switch),
Prompts::Pad(Family::SteamDeck),
] {
for control in Control::ALL {
for svg in icons(prompts, control) {
assert!(svg.starts_with(b"<svg") || svg.starts_with(b"<?xml"));
}
}
}
}
#[test]
fn families_by_usb_ids() {
assert_eq!(family_from_ids(Some(0x054c), Some(0x0ce6)), Family::PlayStation);
assert_eq!(family_from_ids(Some(0x057e), Some(0x2009)), Family::Switch);
assert_eq!(family_from_ids(Some(0x28de), Some(0x1205)), Family::SteamDeck);
assert_eq!(family_from_ids(Some(0x045e), Some(0x0b12)), Family::Xbox);
assert_eq!(family_from_ids(Some(0x28de), Some(0x11ff)), Family::Xbox);
assert_eq!(family_from_ids(None, None), Family::Xbox);
}
#[test]
fn steam_virtual_pad_file() {
let text = "[slot 0]\nname=Steam Deck\nVID=0x28de\nPID=0x1205\ntype=steamdeck\nhandle=0x1\n\n\
[slot 1]\r\nname=DualSense\r\nVID=0x054c\r\nPID=3302\r\n";
let pads = parse_virtual_pads(text);
assert_eq!(
pads[&0],
VirtualPad {
vendor: Some(0x28de),
product: Some(0x1205)
}
);
assert_eq!(pads[&1].product, Some(3302));
assert_eq!(family_from_ids(pads[&1].vendor, pads[&1].product), Family::PlayStation);
assert!(parse_virtual_pads("VID=0x054c\ngarbage\n").is_empty());
}
#[test]
fn slots_come_from_the_pad_name() {
assert_eq!(virtual_slot("Microsoft X-Box 360 pad 0"), Some(0));
assert_eq!(virtual_slot("Microsoft X-Box 360 pad 12"), Some(12));
assert_eq!(virtual_slot("Steam Virtual Gamepad"), None);
assert_eq!(virtual_slot("gamepad x"), None);
}
}