blockworx_kernel/

dispatch.rs

//! Applying one [`Action`] to the session.
//!
//! The document-scoped arms live in `commands::apply_scripted`, shared with
//! the script engine so a scripted session and a live one cannot drift. What
//! this adds is the arms that also move the editor: the clipboard, the
//! history walk, navigation, the lens, the camera, and the palette.
//!
//! [`Action`] is exactly what the core executes. A file dialog, a picker
//! window, a document door belong to the shell, which performs them itself and
//! never asks the core about one — so no action is handed back here. What an
//! action *produces* — the bytes of an export, the text of a copy — is left in
//! the session's [`Handoff`] list for the host to take.

use blockworx_doc::{block_model::Asset, id::BlockId};
use blockworx_editor::{
    edit::{assets, describe::Label, lower::asset_within_limit},
    shape::ShapeId,
};
use blockworx_paint::{TextLayout, ZoomStep};
use blockworx_tools::{
    SelectTool,
    commands::{ScriptedApply, apply_transition},
    resize_block::ResizeBlock,
    tool::{Action, Tool, Transition},
};

use crate::{handoff::Handoff, session::Session};

impl Session {
    /// Apply one action, or a tool's hand-off — all of it, since that is what
    /// the core executes and nothing else reaches here.
    ///
    /// `layout` is the host's text engine: an export lays its diagram out
    /// through the engine the canvas paints with, so it breaks its lines where
    /// the screen did.
    pub fn dispatch(&mut self, transition: impl Into<Transition>, layout: &dyn TextLayout) {
        let transition = transition.into();
        let label = transition.label();
        let outcome = self.commit_gesture(Label::verb(label), |drawing| {
            apply_transition(transition, drawing)
        });
        let action = match outcome {
            ScriptedApply::Applied(settles_on) => {
                if let Some(tool) = settles_on {
                    self.tool = tool;
                }
                return;
            }
            ScriptedApply::NeedsApp(action) => *action,
            ScriptedApply::NotApplicable(effect) => {
                unreachable!("the shell performs {} itself", effect.named())
            }
        };
        match action {
            Action::Copy(shapes) => {
                let clip = self.drawing().copy_selection(&shapes);
                self.copied(clip);
            }
            Action::CopyPins(pins) => {
                let clip = self.drawing().copy_pins(&pins);
                self.copied(clip);
            }
            Action::Cut(shapes) => {
                let from = self.doc.session();
                let clip =
                    self.commit_gesture(Label::verb(label), |d| d.cut_selection(&shapes, from));
                self.copied(clip);
                self.tool = Tool::Select(SelectTool);
            }
            Action::CutPins(pins) => {
                let from = self.doc.session();
                let clip = self.commit_gesture(Label::verb(label), |d| d.cut_pins(&pins, from));
                self.copied(clip);
                self.tool = Tool::Select(SelectTool);
            }
            Action::Paste(text) => self.paste(&text),
            Action::ExpandBlock(rid) => {
                self.path.push(rid);
                self.after_navigate();
            }
            Action::GoToPath(path) => {
                self.path = path;
                self.after_navigate();
            }
            Action::NavSelect { block, extend } => self.nav_select(block, extend.into()),
            // Above the document root there is nowhere to go, and the registry
            // withholds the command there so the button draws dead.
            Action::FrameRect(rect) => self.fit_to_rect(rect),
            Action::AcknowledgeFailure(failure) => {
                self.failures
                    .acknowledge(crate::chrome::Acknowledged(failure));
            }
            Action::GoUp => {
                if self.path.pop().is_some() {
                    self.after_navigate();
                }
            }
            Action::Undo => self.step_history(blockworx_tools::history::Direction::Back),
            Action::Redo => self.step_history(blockworx_tools::history::Direction::Forward),
            Action::Nudge { dx, dy } => self.nudge_selection(dx, dy),
            Action::ResetView => self.fit_view(),
            Action::ToggleDiagnostic => self.diagnostic = self.diagnostic.toggled(),
            Action::ToggleFrameRate => self.frame_rate = self.frame_rate.toggled(),
            Action::Zoom(step) => self.zoom(step),
            Action::ViewRev(rev) => self.view_rev(rev),
            Action::ViewHead => self.view_head(),
            Action::TagRev { at, name, how } => self.tag_rev(at, &name, how),
            Action::SetPalette(palette) => self.paint_in(palette),
            Action::SetIcon { block, asset } => self.set_icon(block, &asset, label),
            Action::Export { format, selection } => {
                let content = self.export_content(layout, format, selection);
                let name = self.sheet.name.clone();
                self.hands_back(Handoff::Export { content, name });
            }
            Action::PlaceImage { asset } => self.place_picked_image(&asset, label),
            Action::StampTool { .. }
            | Action::Arm(_)
            | Action::ArmAddRouteLabel(_)
            | Action::OpenEditor(_)
            | Action::Delete(_)
            | Action::SetPinTags { .. }
            | Action::SetShapeTagHidden { .. }
            | Action::FlipShapePins(_)
            | Action::FlipBlockVertical(_)
            | Action::SetBlockLocked { .. }
            | Action::Reroute(_)
            | Action::RerouteBlock(_)
            | Action::SetRole { .. }
            | Action::SetPinsKind { .. } => {
                unreachable!("{label} is not the dispatcher's to apply")
            }
        }
    }

    /// Wear the artwork as the block's icon, left selected for repositioning.
    /// Artwork the document will not carry writes nothing, and the block
    /// itself is what stays selected.
    fn set_icon(&mut self, block: BlockId, asset: &Asset, label: &'static str) {
        let shape = if asset_within_limit(asset, "the picked icon") {
            self.commit_gesture(Label::verb(label), |d| d.set_icon(block, asset));
            ShapeId::Icon(block)
        } else {
            ShapeId::Rect(block)
        };
        self.tool = ResizeBlock::Selected { shape }.into();
    }

    /// Draw the artwork, left selected so the next gesture resizes it.
    /// Artwork the document will not carry — over the limit, or not an image
    /// at all — writes nothing and leaves the selection empty.
    fn place_picked_image(&mut self, asset: &Asset, label: &'static str) {
        let placed = asset_within_limit(asset, "the picked image")
            .then(|| self.place_image(asset, label))
            .flatten();
        self.tool = match placed {
            Some(shape) => ResizeBlock::Selected { shape }.into(),
            None => Tool::Select(SelectTool),
        };
    }

    /// The drawn image itself, or `None` for a file that is not one. The
    /// picker knows nothing about the canvas, so where the artwork goes is
    /// decided here: centred where a paste would land, at the size the file's
    /// own aspect gives it.
    fn place_image(&mut self, asset: &Asset, label: &'static str) -> Option<ShapeId> {
        let intrinsic = blockworx_paint::image::image_intrinsic_size(asset)
            .inspect_err(|_| tracing::error!("Failed to import image: not a valid image"))
            .ok()?;
        let placed = assets::Placement::Centered {
            center: self.paste_target(),
            intrinsic,
        };
        Some(self.commit_gesture(Label::verb(label), |d| d.add_image(placed, asset)))
    }

    /// One keyboard zoom step, about the pointer where there is one over the
    /// canvas.
    fn zoom(&mut self, step: ZoomStep) {
        let pointer = self.pointer_screen();
        self.zoom_step(step, pointer);
    }

    /// Leave whatever a copy or a cut yielded on the clipboard.
    fn copied(&mut self, clip: Option<blockworx_editor::edit::clipboard::Clipboard>) {
        if let Some(json) = clip.and_then(|clip| clip.to_json()) {
            self.hands_back(Handoff::Clipboard(json));
        }
    }
}