blockworx/theme/

mod.rs

use blockworx_paint::{Color, Font};
use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use strum::IntoEnumIterator;

use crate::canvas::{Base, Palette, Swatch};
use blockworx_geom::WorldPx;

pub mod role_picker;

mod style;
pub use style::Style;

/// A semantic color slot. Drawing code passes a `Role` to every draw call; the
/// renderer resolves it through the active [`Theme`] (role → [`Base`] → color),
/// so call sites name *intent*, never a literal color. Add a variant here for
/// each semantically-distinct color in the app.
///
/// `Transparent` must remain the last variant: [`N_ROLES`] is derived from it.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Serialize, Deserialize, strum::EnumIter)]
pub enum Role {
    // Shapes (blocks and ports)
    ShapeFill,
    ShapeStroke,
    ShapeTitle,
    // Washed-out variants shown on a locked block, plus the block's type label
    // color (unlocked and locked) and the corner lock-hint icon color.
    LockedShapeFill,
    LockedShapeTitle,
    ShapeType,
    LockedShapeType,
    LockedHintIcon,

    // Accent (per-block outline) colors: a block's optional `role` picks one of
    // `Accent0..Accent7`; a block with no role uses `AccentDefault`.
    AccentDefault,
    Accent0,
    Accent1,
    Accent2,
    Accent3,
    Accent4,
    Accent5,
    Accent6,
    Accent7,

    // Text-box annotations
    TextBoxFill,
    TextBoxStroke,

    // Boundary areas (outline only, drawn above blocks and routes)
    AreaStroke,

    // Routes / wires
    RouteNormal,
    RouteSelected,
    RouteHighlighted,
    RouteInProgress,
    RouteProposedEndpoint,

    // Pins
    PinStem,
    PinText,
    PinTag,
    PinStemSelected,
    PinTagSelected,
    /// Faint "Add Name"/"Add Type" placeholder shown at an empty pin label slot
    /// while the pin's shape is selected.
    PinLabelPlaceholder,

    // Drag / move states
    DragPreviewStroke,
    DragActiveFill,
    DragActiveStroke,
    EdgeDragPreview,

    // Selection & editing controls
    SelectionFrame,
    SelectionFrameOutline,
    ControlHandleFill,
    ControlHandleStroke,
    WaypointFill,
    ResizeCornerFill,
    ResizeCornerStroke,
    ResizeCornerActiveFill,
    ResizeCornerActiveStroke,
    ImageDragBox,
    MarqueeFill,

    // Tool previews
    NewBlockPreviewStroke,
    NewPinPreviewFill,
    NewPinPreviewStroke,
    /// The grow-out target shown on a pin/anchor when hovering it in the select
    /// tool (to start a route) or nearing it while routing (to end one).
    RouteStartTarget,

    // UI chrome
    CanvasBackground,
    GridLine,
    PinDragIndicator,

    // Debug
    DebugTextBbox,
    DebugMark,

    /// Thin line shown while dragging when an edge/center/pin-stub lines up with
    /// another shape's. A base color, not an accent.
    AlignmentGuide,

    /// The grid-cell size readout shown inside a block's upper-left corner while
    /// it is being resized. A base color, like the other transient drag hints.
    SizeReadout,

    /// The liveness dot at the head of the top bar, in its four states
    /// (R50): recorded, a write in flight, nothing writable, and a scratch
    /// session with no file behind it. Hues rather than base tones — they
    /// say *which* state, not how loud — except the scratch one, which is a
    /// base tone on purpose: it is the absence of a state, not one of them.
    LiveDot,
    DotWriting,
    DotReadOnly,
    DotScratch,

    /// The top bar while the time machine is open (spec §2.0): the amber wash
    /// over the bar's own glass, the ink the centre's words and the dot take,
    /// and the word on the one filled control in the shell. The wash carries
    /// its own alpha, because it goes *over* the fill the bar already has —
    /// the bar changes state rather than becoming another object.
    ViewingTint,
    ViewingInk,
    ViewingReturnInk,

    /// The toast that says what a file operation did (playbook R38): the
    /// slab and the words on it. The mockup's is a dark glass plate with
    /// white text, which is one scheme's answer to a question the palette
    /// answers for both — so it takes the inverse-video pairing
    /// [`Role::TagBadge`] argues for, like every other thing in this app
    /// that has to be read over whatever is behind it.
    Toast,
    ToastText,

    /// A named rev's badge in the history list: the chip behind the tag,
    /// and the text on it. Inverse video off the base ramp — the
    /// foreground slot filled, the background slot written on it — which
    /// is the only pairing that clears WCAG AA in every scheme this app
    /// ships, light and dark. A badge whose text you cannot read is not a
    /// badge.
    TagBadge,
    TagBadgeText,

    /// The initials disc beside a history row (§8.1). One of five accent
    /// slots, picked by hashing the author's name, so the same hand keeps
    /// the same colour down the list without anybody assigning one.
    ///
    /// Roles rather than arithmetic on the palette: the avatar wants
    /// *categorical* colour, which is what the accent ramp is for, and
    /// naming the five means a scheme can re-point them.
    AuthorAvatar0,
    AuthorAvatar1,
    AuthorAvatar2,
    AuthorAvatar3,
    AuthorAvatar4,
    /// The initials themselves, read over any of the five.
    AuthorAvatarText,

    /// The outline around a title block, in both homes it has: the editor's
    /// corner of the canvas and the printed sheet's footer. Sheet furniture,
    /// not a document object — which is why it does not borrow
    /// [`Role::AreaStroke`], whose color a user edits to restyle their own
    /// boundary areas.
    TitleBlockBorder,

    /// The ring a document step leaves round what it changed (R55). A guide
    /// role, so a base tone — it points at the drawing for a moment, like
    /// [`Role::AlignmentGuide`] and [`Role::SizeReadout`] beside it, and is
    /// not content with an accent of its own.
    ChangeRing,

    /// Resolves to a fully transparent color (transparent fills, no-op strokes).
    /// Keep this the last variant — [`N_ROLES`] depends on it.
    Transparent,
}

/// Number of [`Role`] variants. Used to size the [`Theme`]'s tone table.
pub const N_ROLES: usize = Role::Transparent as usize + 1;

/// Map an optional accent index to its accent [`Role`]: `Some(0..=7)` →
/// [`Role::Accent0`]..[`Role::Accent7`], `None` or out of range → `None`.
/// Shared by every shape that carries an `Option<u8>` accent `role` (blocks,
/// ports, routes); each call site supplies its own fallback for the `None` case.
pub fn accent_role(role: Option<u8>) -> Option<Role> {
    Some(match role? {
        0 => Role::Accent0,
        1 => Role::Accent1,
        2 => Role::Accent2,
        3 => Role::Accent3,
        4 => Role::Accent4,
        5 => Role::Accent5,
        6 => Role::Accent6,
        7 => Role::Accent7,
        _ => return None,
    })
}

/// A stroke described by a world-space width plus a [`Role`] — the app-side,
/// role-based counterpart to the canvas's
/// [`PaletteStroke`](crate::canvas::PaletteStroke). The [`Style`]
/// adapter resolves the role to a [`Swatch`] (and hands the width through) when
/// forwarding to the palette-based renderer. Construct from a `(width, role)`
/// tuple, which wraps the literal width as a [`WorldPx`]; use
/// [`RoleStroke::NONE`] for no stroke.
#[derive(Clone, Copy)]
pub struct RoleStroke {
    pub width: WorldPx,
    pub role: Role,
}

impl RoleStroke {
    /// A zero-width, transparent stroke (draws nothing).
    pub const NONE: RoleStroke = RoleStroke {
        width: WorldPx::ZERO,
        role: Role::Transparent,
    };
}

impl From<(f32, Role)> for RoleStroke {
    fn from((width, role): (f32, Role)) -> Self {
        RoleStroke {
            width: WorldPx::new(width),
            role,
        }
    }
}

/// The six canvas text sizes (in px), the font counterpart to the role → base
/// color mapping. Layered onto [`Theme`] from the embedded `font_sizes.json`
/// (see [`Theme::from_embedded`]) and tuned live by the font editor
/// (`--font-editor`). `#[serde(default)]` lets a partial file specify only the
/// sizes it overrides; the rest fall back to [`FontSizes::default`].
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct FontSizes {
    pub title: f32,
    pub block_type: f32,
    pub pin: f32,
    pub pin_subtitle: f32,
    pub tag: f32,
    pub route: f32,
}

impl Default for FontSizes {
    fn default() -> Self {
        use crate::grid;
        Self {
            title: grid::TITLE_TEXT_SIZE,
            block_type: grid::BLOCK_TYPE_TEXT_SIZE,
            pin: grid::PORT_TEXT_SIZE,
            pin_subtitle: grid::PORT_SUBTITLE_TEXT_SIZE,
            tag: grid::TAG_TEXT_SIZE,
            route: grid::ROUTE_TEXT_SIZE,
        }
    }
}

#[derive(Clone)]
pub struct Theme {
    // Fonts
    pub title_font: Font,
    /// A block's type label, drawn slightly smaller than `title_font`.
    pub type_font: Font,
    pub pin_font: Font,
    /// Second line of a pin/port name, drawn smaller than `pin_font`.
    pub pin_subtitle_font: Font,
    pub tag_font: Font,
    pub route_font: Font,
    /// The sizes the six font fields above were built from, so the font editor
    /// can read them back and re-derive the `Font`s on a change.
    font_sizes: FontSizes,

    /// The 16 base colors every role resolves into.
    palette: Palette,
    /// Role → [`Swatch`] mapping (base slot + alpha), indexed by `role as usize`.
    tones: [Swatch; N_ROLES],
}

impl Theme {
    /// The concrete color for a role: its [`Swatch`] resolved against the
    /// palette. [`Role::Transparent`] and any role mapped to `None` resolve to a
    /// fully transparent color. Kept for code that draws with the raw egui
    /// painter (the canvas chrome, the theme editor / role picker swatches); the
    /// render path passes a `Swatch`/`PaletteStroke` to the canvas instead.
    pub fn resolve(&self, role: Role) -> Color {
        self.palette.resolve(self.swatch(role))
    }

    /// The palette [`Swatch`] a role resolves to (its base slot plus alpha).
    /// [`Role::Transparent`] is always the transparent swatch. This is the
    /// hand-off point to the palette-based canvas: app roles become swatches
    /// here, and the renderer turns swatches into colors.
    pub fn swatch(&self, role: Role) -> Swatch {
        if role == Role::Transparent {
            return Swatch::TRANSPARENT;
        }
        self.tones[role as usize]
    }

    /// The palette backing this theme (for deriving egui's [`egui::Visuals`]).
    pub fn palette(&self) -> &Palette {
        &self.palette
    }

    /// Swap the backing palette (e.g. when the user picks a different scheme).
    /// The role → base `tones` table is palette-independent, so every role — and
    /// all egui chrome derived via [`Palette::egui_visuals`] — restyles at once.
    pub fn set_palette(&mut self, palette: Palette) {
        self.palette = palette;
    }

    /// The palette slot a role resolves through, or `None` if it draws nothing
    /// (transparent). Alpha is ignored here.
    pub fn base_of(&self, role: Role) -> Option<Base> {
        self.tones[role as usize].base
    }

    /// Repoint a role at a different palette slot (or `None` for transparent),
    /// preserving its alpha. [`Role::Transparent`] is fixed, so it is untouched.
    pub fn set_base(&mut self, role: Role, base: Option<Base>) {
        if role != Role::Transparent {
            self.tones[role as usize].base = base;
        }
    }

    /// The full role → base mapping, in declaration order, excluding
    /// [`Role::Transparent`] (which is always transparent). A role with no base
    /// serializes as `null`. This is what the theme editor writes to `theme.json`.
    pub fn overrides(&self) -> IndexMap<Role, Option<Base>> {
        Role::iter()
            .filter(|r| *r != Role::Transparent)
            .map(|r| (r, self.base_of(r)))
            .collect()
    }

    /// The active canvas font sizes (px).
    pub fn font_sizes(&self) -> FontSizes {
        self.font_sizes
    }

    /// Retune the six canvas fonts to `fs` (rebuilding each `Font`) and record
    /// the sizes. The font editor writes these to `font_sizes.json` on exit.
    pub fn set_font_sizes(&mut self, fs: FontSizes) {
        self.apply_font_sizes(fs);
    }

    /// Rebuild the six `Font` fields from `fs` and remember the sizes.
    fn apply_font_sizes(&mut self, fs: FontSizes) {
        self.title_font = Font::canvas(fs.title);
        self.type_font = Font::canvas(fs.block_type);
        self.pin_font = Font::canvas(fs.pin);
        self.pin_subtitle_font = Font::canvas(fs.pin_subtitle);
        self.tag_font = Font::canvas(fs.tag);
        self.route_font = Font::canvas(fs.route);
        self.font_sizes = fs;
    }

    /// The compile-time default theme: [`Theme::default`] (fonts, alphas, and a
    /// fallback base for every role) with the role → base overrides from the
    /// embedded `theme.json`, then the embedded `font_sizes.json`, layered on
    /// top. A `null` value maps the role to no color. A malformed file falls back
    /// to the built-in defaults rather than failing to start.
    pub fn from_embedded() -> Self {
        let mut theme = Theme::default();
        match serde_json::from_str::<IndexMap<Role, Option<Base>>>(EMBEDDED_THEME) {
            Ok(overrides) => {
                for (role, base) in overrides {
                    theme.set_base(role, base);
                }
            }
            Err(e) => tracing::warn!("theme.json parse error, using built-in defaults: {e}"),
        }
        match serde_json::from_str::<FontSizes>(EMBEDDED_FONT_SIZES) {
            Ok(fs) => theme.apply_font_sizes(fs),
            Err(e) => tracing::warn!("font_sizes.json parse error, using defaults: {e}"),
        }
        theme
    }
}

/// The role → base overrides baked into the binary, written by the theme editor
/// (`--theme-editor`) on exit. See [`Theme::from_embedded`].
const EMBEDDED_THEME: &str = include_str!("theme.json");

/// The canvas font sizes baked into the binary, written by the font editor
/// (`--font-editor`) on exit. See [`Theme::from_embedded`].
const EMBEDDED_FONT_SIZES: &str = include_str!("font_sizes.json");

impl Default for Theme {
    fn default() -> Self {
        use Base::{
            B00, B0A, B0B, B0C, B0D, B0E, B0F, B01, B02, B03, B04, B05, B06, B07, B08, B09,
        };
        use Role::{
            Accent0, Accent1, Accent2, Accent3, Accent4, Accent5, Accent6, Accent7, AccentDefault,
            AlignmentGuide, AreaStroke, AuthorAvatar0, AuthorAvatar1, AuthorAvatar2, AuthorAvatar3,
            AuthorAvatar4, AuthorAvatarText, CanvasBackground, ChangeRing, ControlHandleFill,
            ControlHandleStroke, DebugMark, DebugTextBbox, DotReadOnly, DotScratch, DotWriting,
            DragActiveFill, DragActiveStroke, DragPreviewStroke, EdgeDragPreview, GridLine,
            ImageDragBox, LiveDot, LockedHintIcon, LockedShapeFill, LockedShapeTitle,
            LockedShapeType, MarqueeFill, NewBlockPreviewStroke, NewPinPreviewFill,
            NewPinPreviewStroke, PinDragIndicator, PinLabelPlaceholder, PinStem, PinStemSelected,
            PinTag, PinTagSelected, PinText, ResizeCornerActiveFill, ResizeCornerActiveStroke,
            ResizeCornerFill, ResizeCornerStroke, RouteHighlighted, RouteInProgress, RouteNormal,
            RouteProposedEndpoint, RouteSelected, RouteStartTarget, SelectionFrame,
            SelectionFrameOutline, ShapeFill, ShapeStroke, ShapeTitle, ShapeType, SizeReadout,
            TagBadge, TagBadgeText, TextBoxFill, TextBoxStroke, TitleBlockBorder, Toast, ToastText,
            ViewingInk, ViewingReturnInk, ViewingTint, WaypointFill,
        };

        // Default every slot to the foreground color, then assign each role.
        // Indexing by `role as usize` keeps this robust to variant reordering.
        let mut tones = [Swatch::solid(B05); N_ROLES];
        let mut set = |role: Role, tone: Swatch| tones[role as usize] = tone;

        // Shapes
        set(ShapeFill, Swatch::solid(B01));
        set(ShapeStroke, Swatch::solid(B0D));
        set(ShapeTitle, Swatch::solid(B0B));
        set(LockedShapeFill, Swatch::solid(B02));
        set(LockedShapeTitle, Swatch::solid(B0A));
        set(ShapeType, Swatch::solid(B0A));
        set(LockedShapeType, Swatch::solid(B09));
        set(LockedHintIcon, Swatch::solid(B0A));

        // Accent (per-block outline) colors: default + the 8 accents B08..B0F.
        set(AccentDefault, Swatch::solid(B04));
        set(Accent0, Swatch::solid(B08));
        set(Accent1, Swatch::solid(B09));
        set(Accent2, Swatch::solid(B0A));
        set(Accent3, Swatch::solid(B0B));
        set(Accent4, Swatch::solid(B0C));
        set(Accent5, Swatch::solid(B0D));
        set(Accent6, Swatch::solid(B0E));
        set(Accent7, Swatch::solid(B0F));

        // Text boxes
        set(TextBoxFill, Swatch::faded(B01, 0.35));
        set(TextBoxStroke, Swatch::solid(B03));

        // Boundary areas: a solid, muted outline that reads as a grouping
        // frame without competing with block/route strokes.
        set(AreaStroke, Swatch::solid(B06));

        // Routes
        set(RouteNormal, Swatch::solid(B0B));
        // A selected route draws a wider halo in this color behind its resting
        // wire; B07 (the lightest foreground) reads as a highlight, matching the
        // `*Selected` pin roles.
        set(RouteSelected, Swatch::solid(B07));
        set(RouteHighlighted, Swatch::faded(B0B, 0.3));
        set(RouteInProgress, Swatch::solid(B0A));
        set(RouteProposedEndpoint, Swatch::solid(B0F));

        // Pins
        set(PinStem, Swatch::solid(B0F));
        set(PinText, Swatch::solid(B05));
        set(PinTag, Swatch::solid(B0B));
        set(PinStemSelected, Swatch::solid(B08));
        set(PinTagSelected, Swatch::solid(B0C));
        set(PinLabelPlaceholder, Swatch::solid(B04));

        // Drag / move
        set(DragPreviewStroke, Swatch::solid(B04));
        set(DragActiveFill, Swatch::solid(B02));
        set(DragActiveStroke, Swatch::solid(B0F));
        set(EdgeDragPreview, Swatch::faded(B04, 0.2));

        // Selection & controls
        set(SelectionFrame, Swatch::solid(B0F));
        set(SelectionFrameOutline, Swatch::solid(B0D));
        set(ControlHandleFill, Swatch::solid(B07));
        set(ControlHandleStroke, Swatch::solid(B00));
        set(WaypointFill, Swatch::faded(B0B, 0.5));
        set(ResizeCornerFill, Swatch::solid(B0B));
        set(ResizeCornerStroke, Swatch::solid(B0B));
        set(ResizeCornerActiveFill, Swatch::solid(B0C));
        set(ResizeCornerActiveStroke, Swatch::solid(B07));
        set(ImageDragBox, Swatch::solid(B0D));
        set(MarqueeFill, Swatch::faded(B0F, 0.1));

        // Tool previews
        set(NewBlockPreviewStroke, Swatch::solid(B0D));
        set(NewPinPreviewFill, Swatch::solid(B0D));
        set(NewPinPreviewStroke, Swatch::solid(B07));
        set(RouteStartTarget, Swatch::solid(B0B));

        // UI chrome
        set(CanvasBackground, Swatch::solid(B00));
        set(GridLine, Swatch::faded(B02, 0.6));
        set(PinDragIndicator, Swatch::faded(B04, 0.3));

        // Debug
        set(DebugTextBbox, Swatch::faded(B09, 0.7));
        set(DebugMark, Swatch::faded(B08, 0.6));

        // Alignment guides — a dim base color, fainter than the shape outline
        // (a base color, not an accent) so the hints don't dominate.
        set(AlignmentGuide, Swatch::solid(B07));

        // The resize size readout: the brightest base, so it reads over the
        // block's active drag fill without competing with an accent.
        set(SizeReadout, Swatch::solid(B07));

        // The liveness dot and the lens's amber (R42, §2.0). Two hues off the
        // ramp rather than two base tones: these say which state the document
        // is in, and a base tone would only say how loud it is. The wash is
        // faded because it goes over the bar's own glass — a solid one would
        // make the bar a different object instead of the same bar tinted.
        set(LiveDot, Swatch::solid(B0B));
        set(DotWriting, Swatch::solid(B0A));
        set(DotReadOnly, Swatch::solid(B08));
        set(DotScratch, Swatch::solid(B04));
        set(ViewingTint, Swatch::faded(B09, 0.28));
        set(ViewingInk, Swatch::solid(B09));
        set(ViewingReturnInk, Swatch::solid(B00));

        // The toast: the same pairing again, and for the same reason — it
        // stands over the drawing for two seconds and has to be read in
        // that time, whatever is under it.
        set(Toast, Swatch::solid(B07));
        set(ToastText, Swatch::solid(B00));

        // The title block's frame, on screen and in print: the same weight as
        // a block outline, so it reads as ruled sheet furniture rather than
        // as another thing on the drawing.
        set(TitleBlockBorder, Swatch::solid(B04));

        // What a step changed: the brightest base, so the ring reads as a
        // hint laid over the drawing rather than as another thing in it.
        set(ChangeRing, Swatch::solid(B07));

        // A named rev's badge: inverse video, so the chip and its text
        // stay legible whichever way round the scheme runs.
        set(TagBadge, Swatch::solid(B05));
        set(TagBadgeText, Swatch::solid(B00));

        // The avatar's five: the accents §2.2 leaves for categorical use,
        // with the darkest base written on them so the initials read on
        // every one of the five in both schemes.
        set(AuthorAvatar0, Swatch::solid(B0D));
        set(AuthorAvatar1, Swatch::solid(B0B));
        set(AuthorAvatar2, Swatch::solid(B09));
        set(AuthorAvatar3, Swatch::solid(B0E));
        set(AuthorAvatar4, Swatch::solid(B0C));
        set(AuthorAvatarText, Swatch::solid(B00));

        let fs = FontSizes::default();
        Self {
            title_font: Font::canvas(fs.title),
            type_font: Font::canvas(fs.block_type),
            pin_font: Font::canvas(fs.pin),
            pin_subtitle_font: Font::canvas(fs.pin_subtitle),
            tag_font: Font::canvas(fs.tag),
            route_font: Font::canvas(fs.route),
            font_sizes: fs,
            palette: Palette::tokyo_night_moon(),
            tones,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::canvas::Base;

    /// WCAG relative luminance, for the one claim a palette-independent
    /// role pair has to make.
    fn luminance(color: Color) -> f32 {
        let channel = |v: u8| {
            let v = f32::from(v) / 255.0;
            if v <= 0.039_28 {
                v / 12.92
            } else {
                ((v + 0.055) / 1.055).powf(2.4)
            }
        };
        0.2126 * channel(color.r()) + 0.7152 * channel(color.g()) + 0.0722 * channel(color.b())
    }

    fn contrast(a: Color, b: Color) -> f32 {
        let (a, b) = (luminance(a), luminance(b));
        (a.max(b) + 0.05) / (a.min(b) + 0.05)
    }

    /// The tag badge has to be readable in every scheme, both ways round.
    #[test]
    fn the_tag_badge_reads_in_every_scheme_and_both_luminances() {
        use crate::canvas::palette::Luminance;
        for scheme in crate::preferences::Theme::ALL {
            for luminance in [Luminance::Dark, Luminance::Light] {
                let mut theme = Theme::default();
                theme.set_palette(scheme.palette(luminance));
                let ratio = contrast(
                    theme.resolve(Role::TagBadge),
                    theme.resolve(Role::TagBadgeText),
                );
                assert!(
                    ratio >= 4.5,
                    "{scheme:?}/{luminance:?}: the tag badge reads at {ratio:.1}:1",
                );
            }
        }
    }

    #[test]
    fn locked_and_type_roles_resolve_to_expected_bases() {
        let theme = Theme::default();
        assert_eq!(theme.base_of(Role::LockedShapeFill), Some(Base::B02));
        assert_eq!(theme.base_of(Role::LockedShapeTitle), Some(Base::B0A));
        assert_eq!(theme.base_of(Role::ShapeType), Some(Base::B0A));
        assert_eq!(theme.base_of(Role::LockedShapeType), Some(Base::B09));
        assert_eq!(theme.base_of(Role::LockedHintIcon), Some(Base::B0A));
    }

    #[test]
    fn font_sizes_default_matches_grid_constants() {
        use crate::grid;
        let fs = FontSizes::default();
        assert_eq!(fs.title, grid::TITLE_TEXT_SIZE);
        assert_eq!(fs.block_type, grid::BLOCK_TYPE_TEXT_SIZE);
        assert_eq!(fs.pin, grid::PORT_TEXT_SIZE);
        assert_eq!(fs.pin_subtitle, grid::PORT_SUBTITLE_TEXT_SIZE);
        assert_eq!(fs.tag, grid::TAG_TEXT_SIZE);
        assert_eq!(fs.route, grid::ROUTE_TEXT_SIZE);
    }

    #[test]
    fn font_sizes_json_round_trip() {
        let fs = FontSizes::default();
        let json = serde_json::to_string(&fs).unwrap();
        let back: FontSizes = serde_json::from_str(&json).unwrap();
        assert_eq!(fs, back);
    }

    #[test]
    fn font_sizes_partial_json_uses_defaults() {
        let fs: FontSizes = serde_json::from_str(r#"{"title":20.0}"#).unwrap();
        let default = FontSizes::default();
        assert_eq!(fs.title, 20.0);
        assert_eq!(fs.block_type, default.block_type);
        assert_eq!(fs.pin, default.pin);
        assert_eq!(fs.pin_subtitle, default.pin_subtitle);
        assert_eq!(fs.tag, default.tag);
        assert_eq!(fs.route, default.route);
    }

    #[test]
    fn set_font_sizes_rebuilds_font_ids() {
        let mut theme = Theme::default();
        let custom = FontSizes {
            title: 21.0,
            block_type: 18.0,
            pin: 17.0,
            pin_subtitle: 10.0,
            tag: 13.0,
            route: 14.0,
        };
        theme.set_font_sizes(custom);
        assert_eq!(theme.title_font.size, custom.title);
        assert_eq!(theme.type_font.size, custom.block_type);
        assert_eq!(theme.pin_font.size, custom.pin);
        assert_eq!(theme.pin_subtitle_font.size, custom.pin_subtitle);
        assert_eq!(theme.tag_font.size, custom.tag);
        assert_eq!(theme.route_font.size, custom.route);
        assert_eq!(theme.font_sizes(), custom);
    }

    #[test]
    fn embedded_font_sizes_parses() {
        assert!(serde_json::from_str::<FontSizes>(EMBEDDED_FONT_SIZES).is_ok());
    }
}