blockworx_paint/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 the [`Renderer`] API name-for-name (taking a `Role` where
//! the renderer takes a `Swatch`), so a geometry helper drives a `Style` with no
//! body changes. Where the backend is a live [`Canvas`], the second impl block
//! forwards the on-screen conveniences — cursor, in-place editor, pointer,
//! animation, repaint — so a tool reaches them through the `Style` it already
//! holds and never names a toolkit.

use std::time::Duration;

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

use crate::{
    AnimKey, Animator, Canvas, Cursor, EditText, Font, PointerKind, Renderer,
    palette::{PaletteStroke, Swatch},
    text::Layout,
    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::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 `Renderer`, 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 a toolkit painter's `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 a toolkit painter's `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: Angle,
    ) {
        self.inner
            .rotated_text(pos, anchor, text, font, self.swatch(color), angle);
    }

    // Mirrors a toolkit painter's `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 text_layout(&self, text: &str, font: &Font, max_width: WorldPx) -> Layout {
        self.inner.text_layout(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)
    }

    /// The frame animation behind this backend, or `None` offline. See
    /// [`Renderer::animator`].
    pub fn animator(&self) -> Option<&dyn Animator> {
        self.inner.animator()
    }

    /// 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)
    }
}

/// Live-canvas conveniences: when the backend is a [`Canvas`], a tool reaches
/// the cursor, the in-place editor, the pointer, the keyed easings and the
/// repaint schedule straight through the `Style` it already holds.
impl<C: Canvas> Style<'_, C> {
    pub fn set_edit_text(&mut self, edit: EditText) {
        self.inner.set_edit_text(edit);
    }

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

    pub fn cursor(&self) -> Option<Cursor> {
        self.inner.cursor()
    }

    /// The pointer in world space. See [`Animator::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)
    }

    /// The current value of the easing keyed by `key`. See [`Animator::animate`].
    pub fn animate(&self, key: AnimKey, goal: f32, over: Duration) -> f32 {
        self.inner.animate(key, goal, over)
    }

    pub fn request_repaint(&self) {
        self.inner.request_repaint();
    }

    pub fn request_repaint_after(&self, after: Duration) {
        self.inner.request_repaint_after(after);
    }

    /// The frame clock. See [`Canvas::now`].
    pub fn now(&self) -> Duration {
        self.inner.now()
    }

    pub fn pointer_kind(&self) -> PointerKind {
        self.inner.pointer_kind()
    }
}