Holding South on a row, or shift+s on the keyboard, plays its tracks in random order with track shuffle on, so turning shuffle off goes back to their own order. On a song row it shuffles the page the song is on. An artist plays every track of every album, fetched a few albums at a time. South now acts on release, so a long press can mean something else. A long press on a row with nothing to shuffle activates as before.
339 lines
14 KiB
Rust
339 lines
14 KiB
Rust
//! 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,
|
|
Volume,
|
|
Mute,
|
|
/// Cycles the shuffle mode on now playing: the queue button on a
|
|
/// controller, a key of its own on the keyboard.
|
|
Shuffle,
|
|
/// Shuffle play on a row: a long press of activate on a controller.
|
|
ShufflePlay,
|
|
/// 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; 14] = [
|
|
Control::Activate,
|
|
Control::Back,
|
|
Control::PlayPause,
|
|
Control::Queue,
|
|
Control::Skip,
|
|
Control::Sections,
|
|
Control::Search,
|
|
Control::NowPlaying,
|
|
Control::Seek,
|
|
Control::Volume,
|
|
Control::Mute,
|
|
Control::Shuffle,
|
|
Control::ShufflePlay,
|
|
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")],
|
|
Volume => &[icon!("keyboard", "keyboard_minus"), icon!("keyboard", "keyboard_plus")],
|
|
Mute => &[icon!("keyboard", "keyboard_m")],
|
|
Shuffle => &[icon!("keyboard", "keyboard_s")],
|
|
ShufflePlay => &[icon!("keyboard", "keyboard_shift"), icon!("keyboard", "keyboard_s")],
|
|
OnScreenKeyboard => &[],
|
|
},
|
|
Prompts::Pad(Family::Xbox) => match control {
|
|
Activate => &[icon!("xbox", "xbox_button_color_a")],
|
|
ShufflePlay => &[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")],
|
|
Shuffle => &[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")],
|
|
Volume => &[icon!("xbox", "xbox_stick_r_vertical")],
|
|
Mute => &[icon!("xbox", "xbox_stick_r_press")],
|
|
OnScreenKeyboard => &[icon!("xbox", "xbox_guide"), icon!("xbox", "xbox_button_color_x")],
|
|
},
|
|
Prompts::Pad(Family::PlayStation) => match control {
|
|
Activate => &[icon!("playstation", "playstation_button_color_cross")],
|
|
ShufflePlay => &[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")],
|
|
Shuffle => &[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")],
|
|
Volume => &[icon!("playstation", "playstation_stick_r_vertical")],
|
|
Mute => &[icon!("playstation", "playstation_stick_r_press")],
|
|
// 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")],
|
|
ShufflePlay => &[icon!("switch", "switch_button_b")],
|
|
Back => &[icon!("switch", "switch_button_a")],
|
|
PlayPause => &[icon!("switch", "switch_button_y")],
|
|
Queue => &[icon!("switch", "switch_button_x")],
|
|
Shuffle => &[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")],
|
|
Volume => &[icon!("switch", "switch_stick_r_vertical")],
|
|
Mute => &[icon!("switch", "switch_stick_r_press")],
|
|
OnScreenKeyboard => &[
|
|
icon!("switch", "switch_button_home"),
|
|
icon!("switch", "switch_button_y"),
|
|
],
|
|
},
|
|
Prompts::Pad(Family::SteamDeck) => match control {
|
|
Activate => &[icon!("steamdeck", "steamdeck_button_a")],
|
|
ShufflePlay => &[icon!("steamdeck", "steamdeck_button_a")],
|
|
Back => &[icon!("steamdeck", "steamdeck_button_b")],
|
|
PlayPause => &[icon!("steamdeck", "steamdeck_button_x")],
|
|
Queue => &[icon!("steamdeck", "steamdeck_button_y")],
|
|
Shuffle => &[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")],
|
|
Volume => &[icon!("steamdeck", "steamdeck_stick_r_vertical")],
|
|
Mute => &[icon!("steamdeck", "steamdeck_stick_r_press")],
|
|
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);
|
|
}
|
|
}
|