mod hp17bii;
mod hp19bii;
mod hp27s;
mod hp28s;
mod hp38g;
mod hp39g;
mod hp42s;
mod hp48gx;
mod hp48sx;
mod hp49g;
mod pioneer;
use saturnus_core::Model;
use serde::ser::SerializeMap as _;
pub const LCD_COLUMNS: i16 = 131;
pub const LCD_ROWS: i16 = 72;
pub const ANNUNCIATOR_ROWS: i16 = 8;
pub fn lcd_rows(model: Model) -> i16 {
let rows = i16::try_from(model.lcd_size().1).unwrap_or(i16::MAX);
rows + ANNUNCIATOR_ROWS
}
pub fn lcd_columns(model: Model) -> i16 {
i16::try_from(model.lcd_size().0).unwrap_or(LCD_COLUMNS)
}
pub const SOFTKEY_LABEL_PITCH: f64 = 22.0;
pub const SOFTKEY_LABEL_PITCH_28S: f64 = 23.0;
pub const SOFTKEY_LABEL_CENTRE: f64 = 10.5;
pub fn softkey_label_centre(model: Model, s: &Skin, i: usize) -> f64 {
let pitch = if lcd_columns(model) == 137 {
SOFTKEY_LABEL_PITCH_28S
} else {
SOFTKEY_LABEL_PITCH
};
let px = (pitch - 1.0) / 2.0 + pitch * i as f64;
f64::from(s.lcd.x) + px * f64::from(s.lcd.w) / f64::from(lcd_columns(model))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Typing {
pub alpha: &'static str,
pub lower_shift: &'static str,
pub shift_first: bool,
pub alpha_locks: bool,
pub space: &'static [&'static str],
pub direct: bool,
}
pub fn typing(model: Model) -> Option<Typing> {
Some(match model {
Model::Hp42s | Model::Hp27s | Model::Hp17bii | Model::Hp17b => {
return None;
}
Model::Hp19bii => Typing {
alpha: "",
lower_shift: "",
shift_first: false,
alpha_locks: false,
space: &[],
direct: true,
},
Model::Hp28s => Typing {
alpha: "alpha",
lower_shift: "lc",
shift_first: true,
alpha_locks: false,
space: &[],
direct: true,
},
Model::Hp48sx | Model::Hp48gx | Model::Hp49g => Typing {
alpha: "alpha",
lower_shift: "leftshift",
shift_first: false,
alpha_locks: true,
space: &[],
direct: false,
},
Model::Hp38g | Model::Hp39g | Model::Hp40g => Typing {
alpha: "alpha",
lower_shift: "shift",
shift_first: true,
alpha_locks: false,
space: if matches!(model, Model::Hp38g) {
&["shift", "2"]
} else {
&[]
},
direct: false,
},
})
}
pub fn letters(model: Model) -> Vec<(char, &'static str)> {
let Some(skin) = skin(model) else {
return Vec::new();
};
skin.keys
.iter()
.filter_map(|k| match k.alpha {
"SPACE" => Some((' ', k.name)),
a => {
let mut chars = a.chars();
match (chars.next(), chars.next()) {
(Some(c), None) if c.is_ascii_uppercase() => Some((c, k.name)),
_ => None,
}
}
})
.collect()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Rect {
pub x: i16,
pub y: i16,
pub w: i16,
pub h: i16,
}
pub const fn r(x: i16, y: i16, w: i16, h: i16) -> Rect {
Rect { x, y, w, h }
}
impl Rect {
fn right(self) -> i16 {
self.x + self.w
}
fn bottom(self) -> i16 {
self.y + self.h
}
pub fn inside(self, outer: Rect) -> bool {
self.x >= outer.x
&& self.y >= outer.y
&& self.right() <= outer.right()
&& self.bottom() <= outer.bottom()
}
pub fn overlaps(self, other: Rect) -> bool {
self.x < other.right()
&& other.x < self.right()
&& self.y < other.bottom()
&& other.y < self.bottom()
}
}
impl serde::Serialize for Rect {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
[self.x, self.y, self.w, self.h].serialize(s)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Shape {
Key,
Up,
Down,
Left,
Right,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
pub struct Cap {
pub fill: &'static str,
pub ink: &'static str,
pub well: i16,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
pub struct SkinKey {
pub name: &'static str,
pub rect: Rect,
pub shape: Shape,
#[serde(flatten)]
pub cap: Cap,
pub label: &'static str,
#[serde(skip_serializing_if = "str::is_empty")]
pub left: &'static str,
#[serde(skip_serializing_if = "str::is_empty")]
pub right: &'static str,
#[serde(skip_serializing_if = "str::is_empty")]
pub alpha: &'static str,
#[serde(skip_serializing_if = "str::is_empty")]
pub below: &'static str,
}
#[allow(clippy::too_many_arguments)]
pub const fn k(
name: &'static str,
rect: Rect,
cap: Cap,
label: &'static str,
left: &'static str,
right: &'static str,
alpha: &'static str,
below: &'static str,
) -> SkinKey {
SkinKey {
name,
rect,
shape: Shape::Key,
cap,
label,
left,
right,
alpha,
below,
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum AlphaStyle {
Outside,
Corner,
Badge,
Below,
Label,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Relief {
Flat,
Raised,
Sunk,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Panel {
pub rect: Rect,
pub radius: i16,
pub bottom_radius: i16,
pub fill: &'static str,
pub bow: i16,
pub relief: Relief,
}
pub const fn panel(rect: Rect, radius: i16, bottom_radius: i16, fill: &'static str) -> Panel {
Panel {
rect,
radius,
bottom_radius,
fill,
bow: 0,
relief: Relief::Flat,
}
}
pub const fn raised(rect: Rect, radius: i16, bottom_radius: i16, fill: &'static str) -> Panel {
Panel {
relief: Relief::Raised,
..panel(rect, radius, bottom_radius, fill)
}
}
pub const fn sunk(rect: Rect, radius: i16, bottom_radius: i16, fill: &'static str) -> Panel {
Panel {
relief: Relief::Sunk,
..panel(rect, radius, bottom_radius, fill)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
pub struct Mark {
pub x: i16,
pub y: i16,
pub size: i16,
pub fill: &'static str,
pub text: &'static str,
pub italic: bool,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub bold: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
pub struct Line {
pub x1: i16,
pub y1: i16,
pub x2: i16,
pub y2: i16,
pub stroke: &'static str,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Fold {
pub letters: Rect,
pub display: Rect,
pub hinge: Rect,
pub stacked_letters: Rect,
pub stacked_display: Rect,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Skin {
pub width: i16,
pub height: i16,
pub panels: &'static [Panel],
pub lcd: Rect,
pub lcd_fill: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
pub glass: Option<Rect>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fold: Option<Fold>,
pub logo: Rect,
pub marks: &'static [Mark],
pub lines: &'static [Line],
pub left_ink: &'static str,
pub right_ink: &'static str,
pub alpha_ink: &'static str,
pub alpha_badge: &'static str,
pub alpha_style: AlphaStyle,
pub below_ink: &'static str,
pub small: i16,
pub well_fill: &'static str,
pub round: i16,
pub texture: i16,
pub keys: &'static [SkinKey],
}
pub fn skin(model: Model) -> Option<&'static Skin> {
Some(match model {
Model::Hp48sx => &hp48sx::SKIN,
Model::Hp48gx => &hp48gx::SKIN,
Model::Hp38g => &hp38g::SKIN,
Model::Hp49g => &hp49g::SKIN,
Model::Hp39g => &hp39g::SKIN_39G,
Model::Hp40g => &hp39g::SKIN_40G,
Model::Hp42s => &hp42s::SKIN,
Model::Hp27s => &hp27s::SKIN,
Model::Hp17bii => &hp17bii::SKIN_17BII,
Model::Hp17b => &hp17bii::SKIN_17B,
Model::Hp28s => &hp28s::SKIN,
Model::Hp19bii => &hp19bii::SKIN,
})
}
pub fn hosted_models() -> impl Iterator<Item = Model> {
Model::ALL.into_iter().filter(|&m| skin(m).is_some())
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Letters(pub Vec<(char, &'static str)>);
impl serde::Serialize for Letters {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
let mut map = s.serialize_map(Some(self.0.len()))?;
for (c, name) in &self.0 {
map.serialize_entry(&c.to_string(), name)?;
}
map.end()
}
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SkinView {
#[serde(flatten)]
pub skin: &'static Skin,
pub letters: Letters,
pub typing: Option<Typing>,
pub lcd_rows: i16,
pub lcd_columns: i16,
}
pub fn skin_view(model: Model) -> Option<SkinView> {
Some(SkinView {
skin: skin(model)?,
letters: Letters(letters(model)),
typing: typing(model),
lcd_rows: lcd_rows(model) - ANNUNCIATOR_ROWS,
lcd_columns: lcd_columns(model),
})
}
#[cfg(test)]
mod tests {
use super::*;
fn skin(model: Model) -> &'static Skin {
super::skin(model).unwrap()
}
fn skinned() -> impl Iterator<Item = Model> {
Model::ALL.into_iter().filter(|&m| super::skin(m).is_some())
}
use crate::layout::alpha_letter;
use saturnus_core::io::Key;
use std::collections::HashSet;
fn bounds(s: &Skin) -> Rect {
r(0, 0, s.width, s.height)
}
fn is_colour(c: &str) -> bool {
c.len() == 7 && c.starts_with('#') && c[1..].chars().all(|d| d.is_ascii_hexdigit())
}
#[test]
fn skins_cover_the_matrix_exactly_once() {
for model in skinned() {
let s = skin(model);
let mut seen = HashSet::new();
for key in s.keys {
let k = Key::from_name(key.name)
.unwrap_or_else(|| panic!("{}: unknown key {}", model.name(), key.name));
assert!(
model.has_key(k),
"{}: {} is not on its matrix",
model.name(),
key.name
);
assert!(seen.insert(k), "{}: {} twice", model.name(), key.name);
}
let matrix: HashSet<Key> = model.keys().collect();
assert_eq!(seen, matrix, "{}", model.name());
}
}
#[test]
fn keys_fit_the_case_and_do_not_overlap() {
for model in skinned() {
let s = skin(model);
let case = s.panels[0].rect;
assert_eq!(case, bounds(s), "{}: the case is the drawing", model.name());
for (i, a) in s.keys.iter().enumerate() {
assert!(a.rect.w > 0 && a.rect.h > 0, "{}", a.name);
assert!(
a.rect.inside(case),
"{}: {} off the case",
model.name(),
a.name
);
for b in &s.keys[i + 1..] {
assert!(
!a.rect.overlaps(b.rect),
"{}: {} overlaps {}",
model.name(),
a.name,
b.name
);
}
assert!(
!a.rect.overlaps(s.lcd),
"{}: {} on the LCD",
model.name(),
a.name
);
}
assert!(
s.lcd.inside(case) && s.logo.inside(case),
"{}",
model.name()
);
assert!(!s.logo.overlaps(s.lcd), "{}", model.name());
for p in s.panels {
assert!(p.rect.inside(case), "{}: panel off the case", model.name());
}
}
}
#[test]
fn lcd_window_is_the_display_at_square_pixels() {
for model in skinned() {
let lcd = skin(model).lcd;
let columns = lcd_columns(model);
assert!(lcd.w >= 3 * columns, "{}", model.name());
let rows = lcd_rows(model);
let want_h = f64::from(lcd.w) * f64::from(rows) / f64::from(columns);
assert!(
(f64::from(lcd.h) - want_h).abs() <= 1.0,
"{}: {} x {} is not {columns}:{rows}",
model.name(),
lcd.w,
lcd.h
);
}
}
#[test]
fn softkey_labels_sit_above_the_menu_keys() {
for model in skinned() {
let s = skin(model);
let (menu, tolerance) = if model == Model::Hp42s {
(["sigmaplus", "inv", "sqrt", "log", "ln", "xeq"], 50.0)
} else if model.is_pioneer() {
(["a", "b", "c", "d", "e", "f"], 50.0)
} else {
(["a", "b", "c", "d", "e", "f"], 3.0)
};
for (i, name) in menu.iter().enumerate() {
let key = s.keys.iter().find(|k| k.name == *name).unwrap();
let key_centre = f64::from(key.rect.x) + f64::from(key.rect.w) / 2.0;
let label = softkey_label_centre(model, s, i);
assert!(
(label - key_centre).abs() <= tolerance,
"{}: label {} at {label:.1}, key {name} at {key_centre:.1}",
model.name(),
i + 1
);
}
let bezel = s
.panels
.iter()
.find(|p| s.lcd.inside(p.rect) && p.rect != s.panels[0].rect)
.unwrap_or_else(|| panic!("{}: no bezel around the LCD", model.name()));
assert!(
bezel.rect.x < s.lcd.x && bezel.rect.right() > s.lcd.right(),
"{}: bezel narrower than the display",
model.name()
);
}
}
#[test]
fn case_ends_shortly_below_the_bottom_row() {
for model in skinned() {
let s = skin(model);
let cases = match s.fold {
Some(f) => vec![f.letters, f.display],
None => vec![bounds(s)],
};
for case in cases {
let keys: Vec<Rect> = s
.keys
.iter()
.map(|k| k.rect)
.filter(|r| r.inside(case))
.collect();
let lowest = keys.iter().map(|k| k.bottom()).max().unwrap();
let left = keys.iter().map(|k| k.x).min().unwrap() - case.x;
let right = keys.iter().map(|k| k.right()).max().unwrap();
let side = f64::from(left.min(case.right() - right));
let below = f64::from(case.bottom() - lowest);
assert!(
below <= side * 1.3 && below >= side * 0.8,
"{}: {below} units below the keys, {side} beside them",
model.name()
);
}
}
}
#[test]
fn fold_halves_hold_everything() {
for model in skinned() {
let s = skin(model);
let Some(f) = s.fold else {
continue;
};
assert_eq!((f.letters.w, f.letters.h), (f.display.w, f.display.h));
assert_eq!(f.letters.right().max(f.display.right()), s.width);
assert!(f.letters.right() < f.display.x, "a gap between the halves");
assert!(!f.letters.overlaps(f.display));
assert!(f.hinge.inside(f.letters) && f.hinge.h > f.letters.h / 2);
let in_one = |r: Rect| r.inside(f.letters) || r.inside(f.display);
let at = |x: i16, y: i16| in_one(super::r(x, y, 0, 0));
for k in s.keys {
assert!(in_one(k.rect), "{}: {}", model.name(), k.name);
assert!(
!k.rect.overlaps(f.hinge),
"{}: {} on the hinge",
model.name(),
k.name
);
}
for p in &s.panels[1..] {
assert!(in_one(p.rect), "{}: panel {:?}", model.name(), p.rect);
assert!(
!p.rect.overlaps(f.hinge),
"{}: panel {:?} on the hinge",
model.name(),
p.rect
);
}
for m in s.marks {
assert!(at(m.x, m.y), "{}: {}", model.name(), m.text);
}
for l in s.lines {
assert!(at(l.x1, l.y1) && at(l.x2, l.y2), "{}", model.name());
}
let glass = s.glass.unwrap_or(s.lcd);
for r in [s.lcd, glass, s.logo] {
assert!(r.inside(f.display), "{}: {r:?}", model.name());
}
for (half, shown) in [
(f.letters, f.stacked_letters),
(f.display, f.stacked_display),
] {
assert!(shown.inside(half), "{}", model.name());
let keys = s.keys.iter().filter(|k| k.rect.inside(half));
for k in keys.clone() {
let well = super::r(
k.rect.x - k.cap.well,
k.rect.y - k.cap.well,
k.rect.w + 2 * k.cap.well,
k.rect.h + 2 * k.cap.well,
);
assert!(
well.inside(shown),
"{}: {} off the stacked view",
model.name(),
k.name
);
}
let top_key = keys.map(|k| k.rect.y - k.cap.well).min().unwrap();
assert!(
shown.y < top_key - 2 * s.small,
"the labels over the top row stay"
);
for p in s.panels[1..].iter().filter(|p| p.rect.inside(half)) {
let cut = p.rect.overlaps(shown) && !p.rect.inside(shown);
assert!(
!cut || p.rect.y < shown.y,
"{}: {:?} cut at the side",
model.name(),
p.rect
);
}
}
let card = s.panels[1..]
.iter()
.filter(|p| p.rect.inside(f.letters))
.map(|p| p.rect)
.find(|r| r.y < f.stacked_letters.y);
assert!(
card.is_some_and(|c| c.bottom() <= f.stacked_letters.y),
"{}",
model.name()
);
}
assert!(skin(Model::Hp28s).fold.is_some());
assert!(
skinned()
.filter(|&m| skin(m).fold.is_some())
.eq([Model::Hp28s, Model::Hp19bii])
);
}
#[test]
fn letter_map_per_model() {
for m in skinned().filter(|m| m.is_pioneer()) {
assert!(letters(m).is_empty() && typing(m).is_none(), "{}", m.name());
}
for model in skinned().filter(|m| !m.is_pioneer()) {
let map = letters(model);
let abc: String = map.iter().map(|(c, _)| *c).filter(|c| *c != ' ').collect();
assert_eq!(abc, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "{}", model.name());
let mut keys = HashSet::new();
for (_, name) in &map {
let k = Key::from_name(name).unwrap();
assert!(model.has_key(k), "{name}");
assert!(keys.insert(k), "{}: {name} types two letters", model.name());
}
let space = map.iter().any(|(c, _)| *c == ' ');
assert_eq!(
space,
matches!(model, Model::Hp39g | Model::Hp40g | Model::Hp19bii)
);
let t = typing(model).unwrap();
let shifted_space: &[&str] = if model == Model::Hp38g {
&["shift", "2"]
} else {
&[]
};
assert_eq!(t.space, shifted_space, "{}", model.name());
for name in [t.alpha, t.lower_shift]
.into_iter()
.chain(t.space.iter().copied())
.filter(|n| model != Model::Hp19bii || !n.is_empty())
{
assert!(
Key::from_name(name).is_some_and(|k| model.has_key(k)),
"{}: {name}",
model.name()
);
}
}
let at = |m: Model, c: char| {
letters(m)
.into_iter()
.find(|(l, _)| *l == c)
.map(|(_, n)| n)
};
assert_eq!(at(Model::Hp48sx, 'A'), Some("a"));
assert_eq!(at(Model::Hp48gx, 'Z'), Some("eex"));
assert_eq!(at(Model::Hp49g, 'Z'), Some("divide"));
assert_eq!(at(Model::Hp38g, 'A'), Some("home"));
assert_eq!(at(Model::Hp19bii, 'A'), Some("lettera"));
assert_eq!(at(Model::Hp19bii, ' '), Some("space"));
let t19 = typing(Model::Hp19bii).unwrap();
assert!(t19.direct && t19.alpha.is_empty() && t19.lower_shift.is_empty());
assert_eq!(at(Model::Hp39g, 'A'), Some("vars"));
assert_eq!(at(Model::Hp40g, ' '), Some("plus"));
let t = |m: Model| typing(m).unwrap();
assert!(t(Model::Hp48sx).alpha_locks && !t(Model::Hp38g).alpha_locks);
assert!(t(Model::Hp39g).shift_first && !t(Model::Hp49g).shift_first);
}
#[test]
fn colours_are_hex() {
for model in skinned() {
let s = skin(model);
let mut all = vec![
s.lcd_fill,
s.left_ink,
s.right_ink,
s.alpha_ink,
s.alpha_badge,
s.below_ink,
];
all.extend(s.panels.iter().map(|p| p.fill));
all.extend(s.marks.iter().map(|m| m.fill));
all.extend(s.lines.iter().map(|l| l.stroke));
all.extend(s.keys.iter().flat_map(|k| [k.cap.fill, k.cap.ink]));
for c in all {
assert!(is_colour(c), "{}: {c:?}", model.name());
}
}
}
#[test]
fn aplet_49_alpha_letters_match_the_rom() {
for model in [Model::Hp39g, Model::Hp40g] {
for key in skin(model).keys {
let rom = alpha_letter(model, key.name).unwrap_or("");
let drawn = if key.alpha == "SPACE" {
"␣"
} else {
key.alpha
};
if matches!(key.name, "0" | "point" | "neg") {
assert!(!drawn.is_empty(), "{}", key.name);
continue;
}
assert_eq!(drawn, rom, "{}: {}", model.name(), key.name);
}
}
}
#[test]
fn hp48_alpha_letters_in_reading_order() {
for model in [Model::Hp48sx, Model::Hp48gx] {
let letters: String = skin(model).keys.iter().map(|k| k.alpha).collect();
assert_eq!(letters, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "{}", model.name());
}
}
#[test]
fn hp49_alpha_letters() {
let letters: Vec<(&str, &str)> = skin(Model::Hp49g)
.keys
.iter()
.filter(|k| !k.alpha.is_empty())
.map(|k| (k.name, k.alpha))
.collect();
let names: Vec<&str> = letters.iter().map(|(n, _)| *n).collect();
assert_eq!(
names,
[
"a", "b", "c", "d", "e", "f", "apps", "mode", "tool", "var", "sto", "nxt", "hist",
"cat", "eqw", "symb", "power", "sqrt", "sin", "cos", "tan", "eex", "neg", "x",
"inv", "divide"
]
);
let abc: String = letters.iter().map(|(_, l)| *l).collect();
assert_eq!(abc, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
}
#[test]
fn hp38_alpha_letters() {
let s = skin(Model::Hp38g);
let letter = |n: &str| s.keys.iter().find(|k| k.name == n).map(|k| k.alpha);
for (n, l) in [
("home", "A"),
("sqrt", "F"),
("lparen", "G"),
("power", "J"),
("7", "K"),
("divide", "N"),
("multiply", "R"),
("minus", "V"),
("0", "W"),
("comma", "Y"),
("plus", "Z"),
] {
assert_eq!(letter(n), Some(l), "{n}");
}
let count = s.keys.iter().filter(|k| !k.alpha.is_empty()).count();
assert_eq!(count, 26);
}
#[test]
fn forty_g_differs_only_in_its_name() {
let a = skin(Model::Hp39g);
let b = skin(Model::Hp40g);
assert_eq!(a.keys, b.keys);
assert_eq!(a.panels, b.panels);
assert_ne!(a.marks, b.marks);
assert!(b.marks.iter().any(|m| m.text == "40G"));
for model in skinned() {
for m in skin(model).marks {
assert!(!m.text.contains("HP"), "{}: {}", model.name(), m.text);
}
}
}
fn skin_json(model: Model) -> String {
serde_json::to_string(&skin_view(model).unwrap()).unwrap()
}
#[test]
fn json_shape() {
for model in skinned() {
let j = skin_json(model);
assert!(j.starts_with("{\"width\":"), "{j}");
assert_eq!(
j.matches("\"shape\":").count(),
skin(model).keys.len(),
"{}",
model.name()
);
}
let j = skin_json(Model::Hp48sx);
assert!(j.contains("\"name\":\"enter\""));
assert!(j.contains("\"alphaStyle\":\"outside\""));
assert!(skin_json(Model::Hp49g).contains("\"alphaStyle\":\"badge\""));
assert!(skin_json(Model::Hp40g).contains("\"alphaStyle\":\"below\""));
assert!(j.contains("\"letters\":{\"A\":\"a\",\"B\":\"b\""));
assert!(j.contains("\"typing\":{\"alpha\":\"alpha\",\"lowerShift\":\"leftshift\",\"shiftFirst\":false,\"alphaLocks\":true,\"space\":[],\"direct\":false}"));
assert!(skin_json(Model::Hp38g).contains("\"space\":[\"shift\",\"2\"]"));
assert!(skin_json(Model::Hp38g).contains("\"alphaStyle\":\"corner\""));
assert!(j.contains("\"wellFill\":") && j.contains("\"well\":9"));
assert!(j.contains("\"relief\":\"sunk\"") && j.contains("\"texture\":"));
assert!(skin_json(Model::Hp49g).contains("\"bow\":30"));
assert!(skin_json(Model::Hp39g).contains("\" \":\"plus\""));
let j42 = skin_json(Model::Hp42s);
assert!(j42.contains("\"name\":\"rdn\""));
assert!(j42.ends_with("\"letters\":{},\"typing\":null,\"lcdRows\":16,\"lcdColumns\":131}"));
assert!(j.ends_with(",\"lcdRows\":64,\"lcdColumns\":131}"));
assert!(!j.contains("\"fold\""));
let j28 = skin_json(Model::Hp28s);
assert!(j28.contains("\"fold\":{\"letters\":[0,0,836,1414],\"display\":[850,0,836,1414],"));
assert!(j28.contains("\"stackedLetters\":[") && j28.contains("\"stackedDisplay\":["));
assert!(j28.contains("\"alphaStyle\":\"label\""));
assert!(j28.contains("\"direct\":true"));
assert!(j28.contains("\"letters\":{\"A\":\"lettera\",\"B\":\"letterb\""));
assert!(j28.ends_with(",\"lcdRows\":32,\"lcdColumns\":137}"));
let j19 = skin_json(Model::Hp19bii);
assert!(j19.contains("\"fold\":{\"letters\":[0,0,832,1386],\"display\":[846,0,832,1386],"));
assert!(j19.contains("\"typing\":{\"alpha\":\"\",\"lowerShift\":\"\",\"shiftFirst\":false,\"alphaLocks\":false,\"space\":[],\"direct\":true}"));
assert!(j19.contains("\"letters\":{\"A\":\"lettera\",\"B\":\"letterb\""));
assert!(j19.contains("\" \":\"space\""));
assert!(j19.ends_with(",\"lcdRows\":32,\"lcdColumns\":137}"));
}
#[test]
fn hp42s_skin() {
let s = skin(Model::Hp42s);
let key = |n: &str| {
s.keys
.iter()
.find(|k| k.name == n)
.unwrap_or_else(|| panic!("{n}"))
};
let enter = key("enter");
let swap = key("swap");
let sto = key("sto");
let rcl = key("rcl");
assert_eq!(enter.rect.x, sto.rect.x);
assert_eq!(enter.rect.right(), rcl.rect.right());
assert!(enter.rect.w > 2 * sto.rect.w);
assert!(enter.rect.right() < swap.rect.x);
let shift = key("shift");
assert_eq!(shift.cap.fill, "#ef8b1d");
assert!(shift.label.is_empty());
assert_eq!(key("on").label, "EXIT");
assert_eq!(key("on").below, "ON");
assert!(s.marks.iter().any(|m| m.text == "42S"));
let shifted: Vec<&str> = s.keys[..6].iter().map(|k| k.left).collect();
assert_eq!(shifted, ["Σ−", "yˣ", "x²", "10ˣ", "eˣ", "GTO"]);
assert!(
s.keys
.iter()
.all(|k| k.right.is_empty() && k.alpha.is_empty())
);
assert!(s.keys.iter().all(|k| k.cap.well == 6));
assert_eq!(key("inv").rect.x - key("sigmaplus").rect.x, 101);
}
#[test]
fn reliefs_and_textures() {
for model in skinned() {
let s = skin(model);
assert!((0..=100).contains(&s.texture), "{}", model.name());
assert_eq!(s.panels[0].relief, Relief::Flat, "{}", model.name());
for p in &s.panels[1..] {
if p.relief != Relief::Flat {
assert!(
p.rect.w >= 60 && p.rect.h >= 60,
"{}: {:?} panel {:?} too small",
model.name(),
p.relief,
p.rect
);
}
}
assert!(
s.panels[1..].iter().any(|p| p.relief != Relief::Flat),
"{}",
model.name()
);
}
assert_eq!(skin(Model::Hp49g).texture, 0, "the 49G's blue is smooth");
}
fn contrast(a: &str, b: &str) -> f64 {
let luminance = |c: &str| {
let ch = |i: usize| {
let v = f64::from(u8::from_str_radix(&c[i..i + 2], 16).unwrap()) / 255.0;
if v <= 0.04045 {
v / 12.92
} else {
((v + 0.055) / 1.055).powf(2.4)
}
};
0.2126 * ch(1) + 0.7152 * ch(3) + 0.0722 * ch(5)
};
let (x, y) = (luminance(a), luminance(b));
(x.max(y) + 0.05) / (x.min(y) + 0.05)
}
#[test]
fn hp39g_colours() {
for model in [Model::Hp39g, Model::Hp40g] {
let s = skin(model);
let key = |n: &str| s.keys.iter().find(|k| k.name == n).unwrap();
let menu = key("a").cap;
assert!(["b", "c", "d", "e", "f"].iter().all(|n| key(n).cap == menu));
let digits = key("7").cap;
for n in [
"0", "1", "2", "3", "4", "5", "6", "8", "9", "divide", "multiply", "minus", "plus",
"point", "neg", "enter", "on",
] {
assert_eq!(key(n).cap, digits, "{n}");
}
assert_eq!(key("sin").cap, key("vars").cap);
assert_ne!(key("sin").cap, menu);
assert_eq!(key("alpha").cap.fill, "#1f1e22");
assert_eq!(key("shift").cap.fill, "#c64d0a");
for k in s.keys.iter().filter(|k| !k.label.is_empty()) {
let c = contrast(k.cap.ink, k.cap.fill);
assert!(c >= 4.5, "{}: {} {c:.2}", model.name(), k.name);
}
let face = s.panels[1].fill;
for ink in [s.left_ink, s.right_ink, s.alpha_ink, s.below_ink] {
let c = contrast(ink, face);
assert!(c >= 4.5, "{}: {ink} on {face} {c:.2}", model.name());
}
}
}
#[test]
fn pioneer_skins() {
let rects = |m: Model| skin(m).keys.iter().map(|k| k.rect).collect::<Vec<_>>();
assert_ne!(
rects(Model::Hp27s),
rects(Model::Hp42s),
"measured, not the 42S's"
);
for (model, shift, name) in [
(Model::Hp27s, "#6098c0", "27S"),
(Model::Hp17bii, "#d5a356", "17B II"),
(Model::Hp17b, "#e0a850", "17B"),
] {
let s = skin(model);
let key = |n: &str| s.keys.iter().find(|k| k.name == n).unwrap();
assert_eq!(
rects(model),
pioneer::GRID,
"{}: the Pioneer grid",
model.name()
);
assert_eq!(key("shift").cap.fill, shift, "{}", model.name());
assert!(key("shift").label.is_empty());
assert_eq!((key("on").label, key("on").left), ("CLR", "OFF"));
assert_eq!(key("on").below, "ON");
assert_eq!(key("input").rect.x, key("sto").rect.x);
assert_eq!(key("input").rect.right(), key("rcl").rect.right());
assert!(s.keys[..6].iter().all(|k| k.label == "^"));
assert!(
s.marks.iter().any(|m| m.text == name && m.bold),
"{}",
model.name()
);
assert!(
s.keys
.iter()
.all(|k| k.right.is_empty() && k.alpha.is_empty())
);
for k in s.keys.iter().filter(|k| !k.label.is_empty()) {
let c = contrast(k.cap.ink, k.cap.fill);
assert!(c >= 4.5, "{}: {} {c:.2}", model.name(), k.name);
}
for plate in [pioneer::PLATE, pioneer::BAND] {
let face = s.panels[plate].fill;
for ink in [s.left_ink, s.below_ink] {
let c = contrast(ink, face);
assert!(c >= 4.5, "{}: {ink} on {face} {c:.2}", model.name());
}
}
for m in s.marks {
let c = contrast(m.fill, s.panels[pioneer::SURROUND].fill);
assert!(c >= 4.5, "{}: {} {c:.2}", model.name(), m.text);
}
for p in &s.panels[pioneer::BAND + 1..] {
let c = contrast(s.left_ink, p.fill);
assert!(c >= 4.5, "{}: label on {} {c:.2}", model.name(), p.fill);
}
let glass = s.glass.expect("the Pioneers' glass");
assert!(s.lcd.inside(glass) && glass.inside(s.panels[3].rect));
assert!(glass.h > s.lcd.h + 40, "taller than the canvas");
}
let shifted = |m: Model| skin(m).keys.iter().map(|k| k.left).collect::<Vec<_>>();
assert_eq!(
shifted(Model::Hp27s)[..12],
[
"√x", "x²", "eˣ", "LN", "yˣ", "1/x", "10ˣ", "LOG", "ASIN", "ACOS", "ATAN", "MAIN"
]
);
assert_eq!(
skin(Model::Hp27s).panels.len(),
6 + 12,
"a grey bar behind each menu name of the digit block"
);
let (bii, b) = (skin(Model::Hp17bii), skin(Model::Hp17b));
let differs: Vec<&str> = bii
.keys
.iter()
.zip(b.keys)
.filter(|(x, y)| (x.label, x.left, x.below) != (y.label, y.left, y.below))
.map(|(x, _)| x.name)
.collect();
assert_eq!(differs, ["rcl", "lparen", "rparen", "equals"]);
let at = |s: &Skin, n: &str| *s.keys.iter().find(|k| k.name == n).unwrap();
assert_eq!(at(bii, "rcl").left, "RND");
assert_eq!(at(bii, "equals").below, "ENTER");
assert!(at(b, "equals").below.is_empty() && at(b, "rcl").left.is_empty());
assert_ne!(bii.panels, b.panels);
assert_eq!(
bii.lines.len(),
3,
"the 17BII's gold frame, open at the top"
);
assert!(b.lines.is_empty());
}
#[test]
fn hp28s_skin() {
let s = skin(Model::Hp28s);
let key = |n: &str| {
s.keys
.iter()
.find(|k| k.name == n)
.unwrap_or_else(|| panic!("{n}"))
};
for k in s.keys.iter().filter(|k| !k.alpha.is_empty()) {
assert_eq!(k.label, k.alpha, "{}", k.name);
assert_eq!(k.name, format!("letter{}", k.alpha.to_lowercase()));
}
assert_eq!(key("enter").rect.x, key("a").rect.x);
assert_eq!(key("enter").rect.right(), key("b").rect.right());
assert_eq!(key("space").rect.x, key("lettera").rect.x);
assert_eq!(key("space").rect.right(), key("letterb").rect.right());
assert!(key("shift").label.is_empty());
assert_eq!(key("shift").cap.fill, "#7e2a35");
assert_eq!(
(key("on").label, key("on").left, key("on").below),
("ON", "OFF", "ATTN")
);
assert!(
["a", "b", "c", "d", "e", "f"]
.iter()
.all(|n| key(n).label.is_empty())
);
assert_eq!(key("nxt").cap, key("7").cap, "NEXT is a light key");
let cursor: Vec<&str> = s
.marks
.iter()
.filter(|m| m.y == 638)
.map(|m| m.text)
.collect();
assert_eq!(cursor, ["INS", "DEL", "▲", "▼", "◀", "▶"]);
assert!(s.marks.iter().any(|m| m.text == "28S" && m.bold));
assert!(s.keys.iter().all(|k| k.right.is_empty()));
for k in s.keys.iter().filter(|k| !k.label.is_empty()) {
let c = contrast(k.cap.ink, k.cap.fill);
assert!(c >= 4.5, "{} {c:.2}", k.name);
}
let plates = [hp28s::LETTER_PLATE, hp28s::DISPLAY_PLATE];
let bands = &s.panels[hp28s::FIRST_BAND..hp28s::FIRST_BAND + 19];
assert!(bands.iter().all(|p| p.rect.h == 18));
for face in plates.iter().map(|&i| &s.panels[i]).chain(bands) {
for ink in [s.left_ink, s.below_ink] {
let c = contrast(ink, face.fill);
assert!(c >= 4.5, "{ink} on {} {c:.2}", face.fill);
}
}
for m in s.marks {
let under = s
.panels
.iter()
.rev()
.find(|p| super::r(m.x, m.y - m.size / 2, 0, 0).inside(p.rect))
.unwrap();
let c = contrast(m.fill, under.fill);
assert!(c >= 4.5, "{} on {} {c:.2}", m.text, under.fill);
}
assert!(s.panels[hp28s::CARD].rect.bottom() <= s.fold.unwrap().stacked_letters.y);
assert_eq!(s.panels[hp28s::NAME_PLATE].relief, Relief::Sunk);
assert_eq!(s.alpha_style, AlphaStyle::Label);
}
#[test]
fn hp19bii_skin() {
let s = skin(Model::Hp19bii);
let key = |n: &str| {
s.keys
.iter()
.find(|k| k.name == n)
.unwrap_or_else(|| panic!("{n}"))
};
for k in s.keys.iter().filter(|k| k.alpha.len() == 1) {
assert_eq!(k.label, k.alpha, "{}", k.name);
assert_eq!(k.name, format!("letter{}", k.alpha.to_lowercase()));
}
assert_eq!(key("space").rect.x + key("space").rect.w, 272);
assert_eq!(key("input").rect.x, key("a").rect.x);
assert_eq!(key("input").rect.right(), key("b").rect.right());
assert!(key("shift").label.is_empty());
assert_eq!(key("shift").cap.fill, "#eda646");
assert_eq!(key("exit").cap, key("7").cap, "EXIT is a cream key");
assert_eq!(key("a").cap, key("7").cap, "the menu keys are cream");
assert_eq!(key("sto").cap, key("lettera").cap, "STO is grey");
assert_eq!((key("equals").left, key("equals").below), ("LAST", "ENTER"));
assert_eq!(
(key("dsp").left, key("prt").left, key("exit").left),
("MODES", "PRINTER", "MAIN")
);
assert!(
["a", "b", "c", "d", "e", "f"]
.iter()
.all(|n| key(n).label.is_empty())
);
assert!(s.marks.iter().any(|m| m.text == "19BII" && m.bold));
assert!(s.keys.iter().all(|k| k.right.is_empty()));
for k in s.keys.iter().filter(|k| !k.label.is_empty()) {
let c = contrast(k.cap.ink, k.cap.fill);
assert!(c >= 4.5, "{} {c:.2}", k.name);
}
for face in [hp19bii::LETTER_PLATE, hp19bii::DISPLAY_PLATE].map(|i| &s.panels[i]) {
for ink in [s.left_ink, s.below_ink] {
let c = contrast(ink, face.fill);
assert!(c >= 4.5, "{ink} on {} {c:.2}", face.fill);
}
}
for m in s.marks {
let under = s
.panels
.iter()
.rev()
.find(|p| super::r(m.x, m.y - m.size / 2, 0, 0).inside(p.rect))
.unwrap();
let c = contrast(m.fill, under.fill);
assert!(c >= 4.5, "{} on {} {c:.2}", m.text, under.fill);
}
let groups = &s.panels[hp19bii::FIRST_GROUP..];
assert_eq!(groups.len(), 4);
assert!(
groups
.iter()
.all(|g| g.rect.inside(s.panels[hp19bii::CARD].rect))
);
assert!(s.panels[hp19bii::CARD].rect.bottom() <= s.fold.unwrap().stacked_letters.y);
assert_eq!(s.panels[hp19bii::NAME_PLATE].relief, Relief::Sunk);
assert_eq!(s.alpha_style, AlphaStyle::Label);
}
}