blockworx/theme/

style.rs

//! The theme-aware drawing adapter.
//!
//! [`Style`] is a thin bridge between the app's semantic *roles* and the
//! palette-based [`Renderer`]. It bundles a borrowed
//! [`Theme`] with a borrowed renderer backend and resolves every [`Role`] /
//! [`RoleStroke`] to a [`Swatch`] / [`PaletteStroke`] before forwarding the
//! draw down to the canvas — so the canvas never sees a role or a theme, and the
//! whole render path can name a `Role` instead of a literal color. It adds no
//! drawing vocabulary of its own — its one piece of state beyond the two borrows
//! is the opacity a [`Style::with_opacity`] run folds into every swatch it
//! resolves, which is why fading needs no backend support.
//!
//! The methods mirror [`Painter`]'s drawing API
//! name-for-name (taking a `Role` where the painter takes a `Swatch`), so the
//! geometry helpers in [`render`](crate::render) drive a `Style` with
//! no body changes. Tools hold a `Style<Painter>` and reach the egui-only
//! conveniences (cursor, in-place editor, image handles) through the forwarding
//! impl at the bottom.

use blockworx_doc::block_model::Asset;
use blockworx_geom::{Align2, Pos2, Rect, Vec2, WorldPx};
use blockworx_paint::Font;

use crate::{
    canvas::{
        Renderer,
        image::ImageHandle,
        painter::{EditText, Painter},
        palette::{PaletteStroke, Swatch},
    },
    icons::Icon,
    theme::{Role, RoleStroke, Theme},
};

/// Theme-aware drawing surface: a `&Theme` paired with a `&mut` renderer
/// backend. See the module docs.
pub struct Style<'a, R: Renderer> {
    theme: &'a Theme,
    inner: &'a mut R,
    /// Dims every color resolved through this `Style`. `1.0` unless the draw is
    /// inside a [`Style::with_opacity`] run.
    opacity: f32,
}

impl<'a, R: Renderer> Style<'a, R> {
    pub fn new(theme: &'a Theme, inner: &'a mut R) -> Self {
        Self {
            theme,
            inner,
            opacity: 1.0,
        }
    }

    /// The active theme — used by the render path for fonts.
    pub fn theme(&self) -> &Theme {
        self.theme
    }

    /// The backend underneath, for a pass that needs to measure through it
    /// while drawing somewhere else (see [`Extent`](crate::canvas::Extent)).
    pub fn renderer(&self) -> &R {
        self.inner
    }

    // ── Role → palette resolution ────────────────────────────────────────────

    fn swatch(&self, role: Role) -> Swatch {
        let s = self.theme.swatch(role);
        Swatch {
            base: s.base,
            alpha: s.alpha * self.opacity,
        }
    }

    fn pstroke(&self, stroke: impl Into<RoleStroke>) -> PaletteStroke {
        let s = stroke.into();
        PaletteStroke {
            width: s.width,
            color: self.swatch(s.role),
        }
    }

    // ── Primitive draws (mirror `Painter`, but role-colored) ─────────────────

    pub fn rect(&self, rect: Rect, rounding: WorldPx, fill: Role, stroke: impl Into<RoleStroke>) {
        self.inner
            .rect(rect, rounding, self.swatch(fill), self.pstroke(stroke));
    }

    pub fn line(&self, points: Vec<Pos2>, stroke: impl Into<RoleStroke>) {
        self.inner.line(points, self.pstroke(stroke));
    }

    pub fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<RoleStroke>) {
        self.inner.line_segment(points, self.pstroke(stroke));
    }

    pub fn circle(&self, center: Pos2, radius: WorldPx, fill: Role, stroke: impl Into<RoleStroke>) {
        self.inner
            .circle(center, radius, self.swatch(fill), self.pstroke(stroke));
    }

    pub fn circle_filled(&self, center: Pos2, radius: WorldPx, fill: Role) {
        self.inner
            .circle(center, radius, self.swatch(fill), PaletteStroke::NONE);
    }

    pub fn add_convex_polygon(&self, points: Vec<Pos2>, fill: Role, stroke: impl Into<RoleStroke>) {
        self.inner
            .add_convex_polygon(points, self.swatch(fill), self.pstroke(stroke));
    }

    // Mirrors egui's `Painter::text(pos, anchor, text, font, color)`, extended with
    // the wrap width / rotation this canvas needs. Grouping these into a struct
    // would make every call site diverge from the API it wraps.
    #[expect(clippy::too_many_arguments)]
    pub fn text(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: Role,
    ) -> Rect {
        self.inner.text(pos, anchor, text, font, self.swatch(color))
    }

    // Mirrors egui's `Painter::text(pos, anchor, text, font, color)`, extended with
    // the wrap width / rotation this canvas needs. Grouping these into a struct
    // would make every call site diverge from the API it wraps.
    #[expect(clippy::too_many_arguments)]
    pub fn rotated_text(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: Role,
        angle: f32,
    ) {
        self.inner
            .rotated_text(pos, anchor, text, font, self.swatch(color), angle);
    }

    // Mirrors egui's `Painter::text(pos, anchor, text, font, color)`, extended with
    // the wrap width / rotation this canvas needs. Grouping these into a struct
    // would make every call site diverge from the API it wraps.
    #[expect(clippy::too_many_arguments)]
    pub fn text_wrapped(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: Role,
        max_width: WorldPx,
    ) -> Rect {
        self.inner
            .text_wrapped(pos, anchor, text, font, self.swatch(color), max_width)
    }

    pub fn text_size(&self, text: impl ToString, font: &Font) -> Vec2 {
        self.inner.text_size(text, font)
    }

    pub fn text_size_wrapped(&self, text: impl ToString, font: &Font, max_width: WorldPx) -> Vec2 {
        self.inner.text_size_wrapped(text, font, max_width)
    }

    pub fn draw_image(&self, rect: Rect, image: &Asset) {
        self.inner.draw_image(rect, image);
    }

    pub fn image_intrinsic_size(&self, image: &Asset) -> Option<Vec2> {
        self.inner.image_intrinsic_size(image)
    }

    /// Frame-animation inputs (egui context + world-space pointer) for
    /// interactive overlays drawn on the generic render path; `None` on offline
    /// backends. See [`Renderer::anim_target`].
    pub fn anim_target(&self) -> Option<(egui::Context, Option<Pos2>)> {
        self.inner.anim_target()
    }

    /// The visible world-space rect for viewport culling, or `None` on backends
    /// with no viewport (SVG export). See [`Renderer::visible_world_bounds`].
    pub fn visible_world_bounds(&self) -> Option<Rect> {
        self.inner.visible_world_bounds()
    }

    /// Draw a faded run: `draw` receives a `Style` whose colors are dimmed by
    /// `factor` (composing with each role's own alpha). The fade is a swatch
    /// transform applied where roles resolve, so no backend holds fade state and
    /// every backend fades identically. Nestable — a nested run multiplies the
    /// factors. Used for ghost/dimmed previews and faint overlays.
    pub fn with_opacity<T>(&mut self, factor: f32, draw: impl FnOnce(&mut Style<'_, R>) -> T) -> T {
        let mut faded = Style {
            theme: self.theme,
            inner: &mut *self.inner,
            opacity: self.opacity * factor,
        };
        draw(&mut faded)
    }
}

/// On-screen-only conveniences: when the backend is the egui [`Painter`], tools
/// reach its world↔screen remaps, in-place text editor, cursor and image
/// handles straight through the `Style` they already hold.
impl Style<'_, Painter> {
    pub fn set_edit_text(&mut self, edit: EditText) {
        self.inner.set_edit_text(edit);
    }

    /// The egui [`Context`](egui::Context), for frame-driven animation and
    /// repaint scheduling. Reaches the backend painter's context directly.
    pub fn ctx(&self) -> &egui::Context {
        self.inner.ctx()
    }

    /// The pointer in world space — real on the live canvas, synthetic in a
    /// scripted session. See [`Painter::pointer_world`].
    pub fn pointer_world(&self) -> Option<Pos2> {
        self.inner.pointer_world()
    }

    /// World-space rect → screen-space rect, for placing screen-space overlays
    /// (e.g. the selection bar) relative to a selection's on-canvas bounds.
    pub fn remap_rect(&self, rect: Rect) -> Rect {
        self.inner.remap_rect(rect)
    }

    pub fn set_cursor(&mut self, cursor: egui::CursorIcon) {
        self.inner.set_cursor(cursor);
    }

    pub fn cursor(&self) -> Option<egui::CursorIcon> {
        self.inner.cursor()
    }

    // Icon/image drawing is unused since the tag overlays were retired; kept for
    // the planned toolbar icons.
    #[allow(dead_code)]
    pub fn icon(&self, icon: Icon) -> Option<&ImageHandle> {
        self.inner.icon(icon)
    }

    #[allow(dead_code)]
    pub fn image(&self, rect: Rect, handle: &ImageHandle) {
        self.inner.image(rect, handle);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::canvas::SvgRenderer;
    use crate::preferences::FontChoice;
    use blockworx_geom::{pos2, vec2};

    /// Draw one `Role::Accent0` rect (B08, `#ff757f` in the default palette)
    /// through `draw` and return the exported SVG.
    fn faded_rect(draw: impl FnOnce(&mut Style<'_, SvgRenderer>)) -> String {
        let theme = Theme::default();
        let mut svg = SvgRenderer::new(theme.palette().clone(), FontChoice::Sketchy);
        let mut style = Style::new(&theme, &mut svg);
        draw(&mut style);
        svg.finish().0
    }

    fn unit_rect() -> Rect {
        Rect::from_min_size(pos2(0.0, 0.0), vec2(10.0, 10.0))
    }

    #[test]
    fn opacity_folds_into_the_swatch_alpha() {
        let opaque = faded_rect(|s| {
            s.rect(unit_rect(), WorldPx::ZERO, Role::Accent0, RoleStroke::NONE);
        });
        assert!(opaque.contains("fill=\"#ff757f\""));
        assert!(
            !opaque.contains("fill-opacity"),
            "a solid role is fully opaque:\n{opaque}"
        );

        // The hex shifts a little through the premultiplied-alpha round trip, so
        // the opacity attribute — not the color — is the signal.
        let faded = faded_rect(|s| {
            s.with_opacity(0.5, |p| {
                p.rect(unit_rect(), WorldPx::ZERO, Role::Accent0, RoleStroke::NONE);
            });
        });
        assert!(
            faded.contains("fill-opacity=\"0.50"),
            "the fade halves the effective alpha:\n{faded}"
        );
    }

    #[test]
    fn nested_opacity_runs_multiply() {
        let faded = faded_rect(|s| {
            s.with_opacity(0.5, |p| {
                p.with_opacity(0.5, |q| {
                    q.rect(unit_rect(), WorldPx::ZERO, Role::Accent0, RoleStroke::NONE);
                });
            });
        });
        assert!(
            faded.contains("fill-opacity=\"0.25"),
            "nested fades compose:\n{faded}"
        );
    }

    #[test]
    fn a_faded_run_does_not_outlive_its_closure() {
        let after = faded_rect(|s| {
            s.with_opacity(0.5, |p| {
                p.rect(
                    unit_rect(),
                    WorldPx::ZERO,
                    Role::Transparent,
                    RoleStroke::NONE,
                );
            });
            s.rect(unit_rect(), WorldPx::ZERO, Role::Accent0, RoleStroke::NONE);
        });
        assert!(
            !after.contains("fill-opacity"),
            "the draw after the run is undimmed:\n{after}"
        );
    }
}