blockworx_kernel/

frame.rs

//! One canvas frame, over whatever [`Canvas`] the host hands in.
//!
//! The on-screen shell and the kernel run *this* function; neither has a
//! second copy. What is left outside it is only what the surface owns — the
//! grid under the diagram, the widget the in-place editor is rendered as, and
//! the easing a framing glides along.

use blockworx_editor::{edit::describe::Label, widget::drawing::Drawing};
use blockworx_geom::{Align2, Rect, WorldPx, grid::GRID_SIZE, vec2};
use blockworx_paint::{
    Canvas, Font, Interaction, Renderer,
    theme::{Role, RoleStroke, Style},
};
use blockworx_router::turtle::Mark;
use blockworx_tools::{
    SelectTool,
    tool::{Tool, ToolTrait, Transition},
};

use crate::session::{Diagnostic, Session};

/// What one canvas frame left for the chrome around it.
pub struct Framed {
    /// What the tool asked for, if anything.
    pub transition: Option<Transition>,
    /// The selection's on-screen bounding box, for the overlay that anchors
    /// to it. Taken inside the frame, where the world→screen transform and
    /// the text metrics the pin bounds need are both in scope.
    pub selection_bounds: Option<Rect>,
}

/// Draw debug marks from the routing engine. Coordinates and sizes are in
/// world units; `Style` applies the zoom transform and world→screen mapping,
/// so they pass through unscaled.
fn draw_debug_marks(painter: &Style<'_, impl Renderer>, marks: &[Mark]) {
    let font = Font::monospace(6.0);
    for mark in marks {
        match *mark {
            Mark::Line { from, to } => {
                painter.line_segment([from, to], (0.5, Role::DebugMark));
            }
            Mark::Circle { center, radius } => {
                painter.circle(center, radius, Role::DebugMark, RoleStroke::NONE);
            }
            Mark::Label { value, pos } => {
                painter.text(
                    pos,
                    Align2::CENTER_CENTER,
                    format!("{value:.1}"),
                    &font,
                    Role::DebugMark,
                );
            }
        }
    }
}

impl Session {
    /// What a fit-to-content framing would frame: the extent of everything
    /// this level's draw passes cover, measured through the backend that
    /// would draw them.
    pub fn content_bounds<R: Renderer>(&mut self, renderer: &mut R) -> Option<Rect> {
        let Session {
            doc,
            time_machine,
            doc_index,
            spatial,
            presentation,
            gesture,
            path,
            theme,
            ..
        } = self;
        let document = match time_machine {
            None => doc.repo(),
            Some(past) => past.repo(),
        }
        .document();
        let index = spatial.get(doc_index, document, path, presentation);
        let drawing =
            Drawing::new_indexed(doc_index.view(document), path, index, presentation, gesture);
        drawing.content_bounds(&Style::new(theme, renderer))
    }

    /// One canvas frame: the gesture bracket, the ring over what the last
    /// step changed, the tool, and the escape that drops back to selection.
    ///
    /// The pass *is* the tool's gesture: everything written before the seal
    /// at the end is one commit, labelled for the tool that made it. A pass
    /// that only previewed writes nothing and seals to no commit.
    pub fn canvas_frame<C: Canvas>(&mut self, interaction: &Interaction, canvas: &mut C) -> Framed {
        self.begin_gesture(Label::verb(self.tool.name().verb()));
        // Remember the world-space pointer position so a paste can drop the
        // group under the cursor (hover preferred, else last click).
        self.note_pointer(interaction.event);
        let framed = {
            let Session {
                doc,
                time_machine,
                doc_index,
                spatial,
                presentation,
                gesture,
                path,
                theme,
                tool,
                spotlight,
                diagnostic,
                ..
            } = self;
            let document = match time_machine {
                None => doc.repo(),
                Some(past) => past.repo(),
            }
            .document();
            // Rebuilt here (not in a prior pass) so render and hit-tests share
            // one index; a stale index can't be read — `get` rebuilds it if an
            // edit invalidated it or the level changed.
            let index = spatial.get(doc_index, document, path, presentation);
            let mut drawing =
                Drawing::new_indexed(doc_index.view(document), path, index, presentation, gesture);
            let mut style = Style::new(theme, canvas);
            // What the last document step changed, ringed for as long as the
            // ring lasts. Drawn under the tool so a preview or a handle is
            // never behind it.
            spotlight.ring(path.scope(), &mut style);
            let mut transition = {
                let _span = tracing::info_span!("tool_widget").entered();
                blockworx_tools::tool::frame(tool, &mut drawing, interaction, &mut style)
            };
            // Esc cancels the active tool, dropping back to plain selection —
            // unless the tool consumed the key itself (a rename box
            // commits/aborts its edit and sets its own action above; an
            // in-progress route clears its preview).
            if transition.is_none()
                && interaction.escape_pressed
                && !matches!(tool, Tool::Select(_))
            {
                transition = Some(Transition::SwitchTool(Tool::Select(SelectTool)));
            }
            if *diagnostic == Diagnostic::RegionalRouter {
                let selected = tool
                    .selection()
                    .and_then(|d| d.shapes())
                    .unwrap_or_default();
                let foreground = blockworx_editor::widget::foreground::Foreground::raising(
                    selected.iter().copied(),
                    &drawing,
                );
                blockworx_editor::widget::display::draw_foreground(
                    &drawing,
                    &foreground,
                    &mut style,
                );
                if let Some((bound, lattice)) = drawing.healing_bound(&foreground) {
                    draw_debug_marks(&style, &lattice);
                    style.rect(
                        bound,
                        WorldPx::ZERO,
                        Role::Transparent,
                        (1.5, Role::DebugMark),
                    );
                }
            }
            let selection_bounds = tool.selection().and_then(|sel| {
                // A tool may pin its overlay to a specific point (a route
                // anchors at the click, not its wide bounding box); otherwise
                // fall back to the selection's bounds.
                let world = match tool.overlay_anchor() {
                    Some(anchor) => {
                        Some(Rect::from_center_size(anchor, vec2(GRID_SIZE, GRID_SIZE)))
                    }
                    None => blockworx_tools::selection_bounds::selection_world_bounds(
                        &sel, &drawing, &style,
                    ),
                };
                world.map(|world| style.remap_rect(world))
            });
            Framed {
                transition,
                selection_bounds,
            }
        };
        self.end_gesture();
        framed
    }
}