blockworx/

surface.rs

//! The drawing surface and the glass over it: the camera, the floating bands
//! of `docs/cad-ui-spec.md` §2, the selection popups, the command palette and
//! the navigator. Everything here is what a toolkit shows and what a pointer
//! or a key reaches — none of it is the document.

use blockworx_geom::{Pos2, vec2};
use blockworx_paint::Cursor;

use crate::canvas::View;
use crate::canvas::convert::{IntoEgui as _, IntoGeom};
use crate::io_pin_picker::{self, PinTypePick};
use crate::kernel::{Overlay, View as Shown};
use crate::panels::overlay::{OpenPicker, RightClick, selection_overlay};
use crate::panels::palette::{Palette, PaletteOutcome};
use crate::preferences::Preferences;
use crate::theme::Theme;
use crate::tools::commands::CommandSet;
use crate::tools::commands::{Act, CommandId, Effect};
use crate::tools::names::ToolName;
use crate::tools::tool::{Action, RoleTarget};
use blockworx_doc::id::PinId;

/// The eframe storage key the workspace panel's per-document state lives
/// under, beside the preferences blob and the recent-files list.
const WORKSPACES: &str = "workspaces";

#[derive(Default)]
pub(crate) struct Surface {
    /// The canvas the diagram is drawn on: the vantage, the viewport, the
    /// in-place text editor and the interaction this frame's pointer made.
    pub(crate) canvas: View,
    /// The open selection popup, if any. Set by an [`Action`] and read one frame
    /// later so the click that opened it isn't mistaken for a click-outside
    /// dismiss. The popup anchors itself above the selection overlay via
    /// [`Self::overlay_top_right`].
    popup: Option<Popup>,
    /// The selection overlay's top-right corner from the latest frame it was
    /// drawn, used to anchor the accent popup directly above it. `None` when
    /// nothing is selected.
    overlay_top_right: Option<Pos2>,
    /// The command palette while open (Ctrl+K toggles it).
    palette: Option<Palette>,
    /// Which view the navigator is showing, whether it is showing at all, and how
    /// wide it was left — for the document that is open.
    pub(crate) workspace: crate::shell::workspace::Workspace,
    /// The same, for every document this session has opened. Persisted
    /// through the eframe storage DB beside the recent-files list, so a
    /// document reopens with the panel it was left with.
    workspaces: std::collections::BTreeMap<String, crate::shell::workspace::Workspace>,
    /// What the floating chrome left the canvas last frame. Read by the
    /// framing that has to land inside it, and by the overlay that has to
    /// clamp into it.
    pub(crate) safe: crate::shell::SafeArea,
    /// The history panel's search box. Kept here rather than in
    /// egui's transient store because a query the user typed must survive
    /// the panel being collapsed and reopened.
    history_search: String,
}

/// A selection popup and the selection it acts on. At most one is open at a
/// time, so opening either closes the other.
pub(crate) enum Popup {
    /// The accent-color picker, for one block, port, route, area, or text box.
    Role(RoleTarget),
    /// The pin-type (I/O style) picker, for the pins it retypes (a single pin, a
    /// pin group, or a port's pin).
    PinType(Vec<PinId>),
}

impl Popup {
    fn picker(&self) -> OpenPicker {
        match self {
            Popup::Role(_) => OpenPicker::Role,
            Popup::PinType(_) => OpenPicker::PinType,
        }
    }
}

/// What the top bar reads that the surface does not own: how the shell names
/// this document, the appearance menu it edits in place, and — where there
/// are files — the containers to reopen and the rename box.
pub(crate) struct BarState<'a> {
    pub theme: &'a Theme,
    pub preferences: &'a mut Preferences,
    #[cfg(not(target_arch = "wasm32"))]
    pub recent: &'a [std::path::PathBuf],
    #[cfg(not(target_arch = "wasm32"))]
    pub rename_draft: &'a mut String,
}

/// What the canvas pass left for the chrome floating over it: which picker is
/// open, so the overlay draws it active, and what the tool asked for, which
/// any layer above may override.
pub(crate) struct OverCanvas {
    pub picker: Option<OpenPicker>,
    pub act: Option<Act>,
}

impl Surface {
    /// This frame's selection popup, driven from state set on a previous frame
    /// (so the click that opened it isn't read as a click-outside dismiss).
    /// Returns which picker was open on entry: the toolbar's Accent/I/O buttons
    /// show active from it, and it has to be captured before a dismissal here
    /// clears it, or the dismissing click reads as a request to reopen — and
    /// whatever it reported, which is dispatched with the frame's other
    /// actions rather than written here, so it takes the same road as the rest.
    pub(crate) fn show_popups(
        &mut self,
        ctx: &egui::Context,
        bar: Option<&Overlay>,
        theme: &Theme,
    ) -> (Option<OpenPicker>, Option<Action>) {
        let was_open = self.popup.as_ref().map(Popup::picker);
        // A popup anchors above the selection overlay, whose corner was captured
        // last frame; with no overlay there is nowhere to put it.
        let Some(corner) = self.overlay_top_right else {
            return (was_open, None);
        };
        let at = corner - vec2(0.0, crate::grid::GRID_SIZE);
        let (still_open, picked) = match self.popup.take() {
            Some(Popup::Role(target)) => show_role_picker(ctx, bar, theme, at, target),
            Some(Popup::PinType(pins)) => show_pin_type_picker(ctx, bar, at, pins),
            None => (None, None),
        };
        self.popup = still_open;
        (was_open, picked)
    }

    /// While an in-canvas text editor has focus, a plain-text paste should feed
    /// the `TextEdit`, but an OBJECT paste (our clipboard format) should behave
    /// like a normal deselected object paste instead of dumping JSON into the
    /// box. Consume that event here and surrender editor focus so the tool
    /// commits the box's current text this frame; the payload is returned to be
    /// pasted after the canvas pass.
    pub(crate) fn intercept_object_paste(&self, ctx: &egui::Context) -> Option<String> {
        if !ctx.egui_wants_keyboard_input() {
            return None;
        }
        let text = latest_paste(ctx)?;
        if !crate::widget::clipboard::is_object_clipboard(&text) {
            return None;
        }
        ctx.input_mut(|i| {
            i.events.retain(|e| !matches!(e, egui::Event::Paste(_)));
            i.raw.events.retain(|e| !matches!(e, egui::Event::Paste(_)));
        });
        let focused = ctx
            .memory(egui::Memory::focused)
            .or_else(|| self.canvas.focused_edit_id());
        if let Some(id) = focused {
            ctx.memory_mut(|m| m.surrender_focus(id));
        }
        Some(text)
    }

    /// The chrome that still floats over the canvas: the selection overlay
    /// and its pickers, and the command palette. Everything docked went into
    /// [`crate::shell`]. Each layer's request overrides the one below it,
    /// starting from what the tool asked for on the canvas.
    pub(crate) fn show_canvas_chrome(
        &mut self,
        ui: &mut egui::Ui,
        shown: &mut Shown,
        over: OverCanvas,
    ) -> Option<Act> {
        let ctx_owned = ui.ctx().clone();
        let ctx = &ctx_owned;
        let OverCanvas {
            picker: open_picker,
            act: mut action,
        } = over;
        let Shown {
            commands,
            overlay: bar,
            history,
            nav_tree,
            viewport,
            ..
        } = shown;
        let viewport = *viewport;
        // The right-click menu is a pointer-platform duplicate of the bar, so
        // the gesture is read where the canvas is: a right-click over a
        // floating piece of chrome belongs to that piece, and a right *drag*
        // pans instead.
        let right_click = RightClick::from(
            self.canvas.canvas_hovered() && ctx.input(|i| i.pointer.secondary_clicked()),
        );
        let (overlay_action, overlay_corner) = selection_overlay(
            ui,
            crate::panels::overlay::Overlay {
                commands,
                bar: bar.as_ref(),
                open_picker,
                safe: self.safe,
                camera: self.canvas.camera(),
                right_click,
            },
        );
        if let Some(overlay_action) = overlay_action {
            action = Some(overlay_action);
        }
        self.overlay_top_right = overlay_corner.map(IntoGeom::geom);
        // A popup can't outlive the selection it targets.
        if overlay_corner.is_none() {
            self.popup = None;
        }
        let scope = crate::panels::palette::PaletteScope {
            tree: nav_tree,
            revs: history,
        };
        let outcome = self
            .palette
            .as_mut()
            .map(|palette| palette.show(ctx, commands, scope, viewport.egui()));
        match outcome {
            None | Some(PaletteOutcome::Open) => {}
            Some(PaletteOutcome::Close) => self.palette = None,
            Some(PaletteOutcome::Dispatch(palette_action)) => {
                action = Some(*palette_action);
                self.palette = None;
            }
        }
        action
    }

    /// Open the palette, or shut the one that is open. The chord that asks
    /// for this is a row of the binding table like any other, so the command
    /// arrives here rather than being read off the keyboard in place.
    pub(crate) fn toggles_the_palette(&mut self) {
        self.palette = match self.palette {
            None => Some(Palette::new()),
            Some(_) => None,
        };
    }

    /// The top bar: the document menu and its name, the liveness dot, the
    /// breadcrumb, the viewing mode, and the right-hand actions.
    pub(crate) fn show_top_bar(
        &mut self,
        chrome: &mut crate::shell::Chrome,
        model: &crate::kernel::TopBar,
        commands: &mut CommandSet,
        bar: BarState<'_>,
    ) -> Option<Act> {
        let BarState {
            theme,
            preferences,
            #[cfg(not(target_arch = "wasm32"))]
            recent,
            #[cfg(not(target_arch = "wasm32"))]
            rename_draft,
        } = bar;
        let clicked = crate::shell::top_bar::top_bar(
            chrome,
            commands,
            crate::shell::top_bar::Docked {
                model,
                navigator: self.workspace.open().into(),
                theme,
                prefs: preferences,
                #[cfg(not(target_arch = "wasm32"))]
                recent,
                #[cfg(not(target_arch = "wasm32"))]
                document: crate::shell::top_bar::Document {
                    draft: rename_draft,
                    renaming: model.renaming,
                },
            },
        );
        if clicked.browse {
            self.workspace.toggle();
        }
        clicked.action
    }

    /// Put the navigator away, because the user is going back to work.
    ///
    /// More than shutting it: the Hierarchy filter is a transient search, not
    /// a persistent view, so it goes too rather than surviving Escape.
    pub(crate) fn dismiss_navigator(&mut self, ctx: &egui::Context) {
        if !self.workspace.open() {
            return;
        }
        self.workspace.close();
        crate::panels::nav_tree::clear_filter(ctx);
    }

    /// The navigator's body: whichever view its segments have open.
    pub(crate) fn show_navigator_body(
        &mut self,
        ui: &mut egui::Ui,
        shown: &Shown,
        theme: &Theme,
    ) -> Option<Act> {
        let view = self.workspace.view;
        match view {
            crate::shell::workspace::PanelView::History => crate::panels::history_panel::body(
                ui,
                crate::panels::history_panel::HistoryPanel {
                    scene: crate::panels::history_panel::HistoryScene {
                        rows: &shown.history,
                        viewing: shown.top_bar.lens.viewing,
                        head: shown.top_bar.lens.head,
                        now: blockworx_store::history::now(),
                        theme,
                    },
                    search: &mut self.history_search,
                },
            ),
            crate::shell::workspace::PanelView::Hierarchy => crate::panels::nav_tree::body(
                ui,
                crate::panels::nav_tree::NavScene {
                    tree: &shown.nav_tree,
                    theme,
                },
            )
            .map(Act::from),
        }
    }

    /// What a cell carried off the tool cluster and released comes to: a
    /// stamp at the drop point, in the canvas's own coordinates. The image
    /// cell has nothing to stamp — there is no image until one is picked — so
    /// its drop opens the picker, the same as pressing it does.
    ///
    /// `None` where the drop landed on the glass, on the navigator, or off the
    /// window — the gesture ends and the cell springs back, because a
    /// release the canvas never saw must not become a thing on it.
    pub(crate) fn dropped(
        ctx: &egui::Context,
        shown: &Shown,
        carried: crate::shell::tool_cluster::DragOut,
    ) -> Option<Act> {
        let onto_the_canvas = shown.viewport.contains(carried.at.geom())
            && !crate::shell::over_the_chrome(ctx, carried.at);
        if !onto_the_canvas {
            return None;
        }
        let at = shown
            .vantage
            .screen_to_world(shown.viewport.min, carried.at.geom());
        Some(match carried.tool {
            ToolName::NewImage => Effect::AddImage.into(),
            tool => Action::StampTool { tool, at }.into(),
        })
    }

    /// Drop the popup, because what it hung off is gone.
    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn forget_popup(&mut self) {
        self.popup = None;
    }

    /// Open a selection popup, replacing whatever was open. It renders from the
    /// top of the next frame so this opening click isn't read as a
    /// click-outside dismiss; the selection stays in the tool behind it.
    pub(crate) fn open_popup(&mut self, ctx: &egui::Context, popup: Popup) {
        self.popup = Some(popup);
        ctx.request_repaint();
    }

    /// File away the panel state the document `was` was left with, and adopt
    /// the one `now` was. Called wherever the document is replaced or
    /// renamed, so a panel never follows the wrong document.
    // Both of those are container doors, which the browser has none of.
    #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
    pub(crate) fn settle_workspace(&mut self, was: &str, now: &str) {
        self.workspaces.insert(was.to_owned(), self.workspace);
        self.workspace = self.workspaces.get(now).copied().unwrap_or_default();
    }

    /// Restore the per-document panel state from the eframe storage DB, and
    /// adopt the one the document named `key` was left with.
    pub(crate) fn restore(&mut self, storage: &dyn eframe::Storage, key: &str) {
        if let Some(s) = storage.get_string(WORKSPACES)
            && let Ok(workspaces) = serde_json::from_str(&s)
        {
            self.workspaces = workspaces;
            self.workspace = self.workspaces.get(key).copied().unwrap_or_default();
        }
    }

    pub(crate) fn save(&mut self, storage: &mut dyn eframe::Storage, key: &str) {
        self.workspaces.insert(key.to_owned(), self.workspace);
        match serde_json::to_string(&self.workspaces) {
            Ok(s) => storage.set_string(WORKSPACES, s),
            Err(e) => tracing::error!("Failed to serialize workspaces: {e}"),
        }
    }
}

/// Keyboard copy/paste/nudge, independent of the mouse-driven actions — the
/// keys egui reports as events rather than as keystrokes, which a binding
/// table cannot name. Skipped while a rename `TextEdit` holds focus so Cmd+C/V
/// edits its text instead of the canvas selection (the canvas itself runs
/// unfocused).
pub(crate) fn handle_keyboard(ctx: &egui::Context, shown: &mut Shown) -> Option<Act> {
    if ctx.egui_wants_keyboard_input() {
        return None;
    }
    let paste_txt = latest_paste(ctx);
    // Copy is the one chord a read-only session keeps: it is how the
    // time machine pays off (copy out of the past, paste into the
    // present). The chords are consumed either way, so a withheld one
    // does nothing rather than falling through to another handler.
    let writable = shown.writable == blockworx_store::doc::Writability::Writable;
    if let Some(text) = paste_txt {
        writable.then_some(Action::Paste(text).into())
    } else if ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Copy))) {
        // The registry already says what a copy of this selection is — the
        // shapes, or the pins of a pin group.
        shown.commands.take(CommandId::Copy)
    } else if ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Cut))) {
        shown.commands.take(CommandId::Cut)
    } else {
        None
    }
}

/// The accent-color picker for `target`. The targeted shape stays selected
/// behind it. `None` once it is dismissed.
fn show_role_picker(
    ctx: &egui::Context,
    bar: Option<&Overlay>,
    theme: &Theme,
    at: Pos2,
    target: RoleTarget,
) -> (Option<Popup>, Option<Action>) {
    let current = bar.and_then(|bar| bar.accent);
    let picked = match crate::role_picker::show(ctx, at.egui(), theme, current, target) {
        crate::role_picker::RolePick::Set(role) => Some(Action::SetRole { target, role }),
        crate::role_picker::RolePick::Dismiss => return (None, None),
        crate::role_picker::RolePick::None => None,
    };
    (Some(Popup::Role(target)), picked)
}

/// The pin-type (I/O style) picker for `pins`, which stay selected behind
/// it. The current cell is the pins' shared type, or none when they
/// disagree; a click sets every one of them. `None` once dismissed.
fn show_pin_type_picker(
    ctx: &egui::Context,
    bar: Option<&Overlay>,
    at: Pos2,
    pins: Vec<PinId>,
) -> (Option<Popup>, Option<Action>) {
    let current = bar.and_then(|bar| bar.pin_dir);
    let picked = match io_pin_picker::show(ctx, at.egui(), current) {
        PinTypePick::Set(kind) => Some(Action::SetPinsKind {
            pins: pins.clone(),
            kind,
        }),
        PinTypePick::Dismiss => return (None, None),
        PinTypePick::None => None,
    };
    (Some(Popup::PinType(pins)), picked)
}

/// The cursor to actually publish for the active tool: the tool's requested
/// cursor while the pointer is over the canvas, and none otherwise so the tool
/// cursor never overrides an overlay's own cursor.
pub(crate) fn effective_cursor(
    tool_cursor: Option<Cursor>,
    pointer: PointerOver,
) -> Option<Cursor> {
    match pointer {
        PointerOver::Canvas => tool_cursor,
        PointerOver::Elsewhere => None,
    }
}

/// Where the pointer sits: over the canvas, or over an overlay (which owns its
/// own cursor).
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) enum PointerOver {
    Canvas,
    Elsewhere,
}

/// The most recent paste event's text this frame, if any.
fn latest_paste(ctx: &egui::Context) -> Option<String> {
    ctx.input(|i| {
        i.events.iter().rev().find_map(|e| match e {
            egui::Event::Paste(s) => Some(s.clone()),
            _ => None,
        })
    })
}