blockworx/tools/

edit_route.rs

use crate::render::{
    RouteRenderMode, render_path_with_chamfered_corners, render_route_label_at,
    render_text_anchors, render_waypoint_handles, route_text_color,
};
use crate::theme::Style;
use blockworx_doc::id::RouteId;
use blockworx_geom::{Pos2, vec2};
use blockworx_paint::{Canvas, Event, Interaction};

use crate::{
    grid::{GRID_SIZE, HIT_RADIUS, PORT_RADIUS, grid_point, px_point, snap_to_grid},
    presentation::{RouteDirection, RouteEdge},
    theme::Role,
    tools::{
        names::ToolName,
        tool::{Action, Deletable, Supposing, ToolTrait},
    },
    widget::{
        DrawingPasses,
        auto_route::{RouteGeometry, hit_waypoint, text_anchors},
        drawing::Drawing,
        edge::RouteEdgeExt,
        routing::RouteEditSession,
    },
};

pub enum EditRoute {
    Idle,
    Hovered {
        id: RouteId,
    },
    Selected {
        id: RouteId,
        /// Where the route was last picked/edited, in world space. The selection
        /// overlay anchors here so it opens next to the click rather than at the
        /// route's bounding-box corner.
        anchor: Pos2,
    },
    /// While dragging an edge, `start_cursor`/`end_cursor` accumulate the raw
    /// (sub-grid) drag deltas. The working corner positions are snapped each
    /// frame from these cursors, so small per-frame deltas don't get rounded
    /// to zero before they accumulate past a grid step.
    DraggingEdge {
        id: RouteId,
        direction: RouteDirection,
        start_cursor: Pos2,
        end_cursor: Pos2,
        /// The edit plan for the two boundary corners, built lazily on the
        /// first `Dragging` frame — after the select→drag tool switch and its
        /// re-route, which would otherwise invalidate a plan made earlier.
        /// `None` until then. While it lives, the document is never written:
        /// the drag previews into derived state and commits once on release.
        session: Option<RouteEditSession>,
    },
    DraggingWaypoint {
        id: RouteId,
        cursor: Pos2,
        /// The edit plan for the dragged corner, built lazily on the first
        /// `Dragging` frame (see `DraggingEdge::session`). `None` until then.
        session: Option<RouteEditSession>,
    },
}

impl ToolTrait for EditRoute {
    fn name(&self) -> ToolName {
        ToolName::EditRoute
    }

    fn selection(&self) -> Option<Deletable> {
        match self {
            EditRoute::Selected { id, .. } => Some(Deletable::Route(*id)),
            _ => None,
        }
    }

    fn overlay_anchor(&self) -> Option<Pos2> {
        match self {
            EditRoute::Selected { anchor, .. } => Some(*anchor),
            _ => None,
        }
    }

    fn suppose<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        _painter: &mut Style<'_, C>,
        phase: &Supposing,
    ) {
        self.preview_drag(data, interaction.event, phase);
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Action> {
        self.render(data, interaction, painter);
        match self {
            EditRoute::Idle => {
                if let Some(Event::HoverAt(pos)) = interaction.event {
                    if let Some(id) = data.route_at_pos(pos) {
                        *self = EditRoute::Hovered { id };
                    }
                } else if let Some(Event::Clicked { pos }) = interaction.event
                    && let Some(id) = data.route_at_pos(pos)
                {
                    *self = EditRoute::Selected { id, anchor: pos };
                }
            }

            EditRoute::Hovered { id } => {
                let id = *id;
                if let Some(Event::HoverAt(pos)) = interaction.event {
                    match data.route_at_pos(pos) {
                        Some(new_id) => *self = EditRoute::Hovered { id: new_id },
                        None => return Some(Action::default()),
                    }
                } else if let Some(Event::Clicked { pos }) = interaction.event {
                    *self = EditRoute::Selected { id, anchor: pos };
                }
            }

            EditRoute::Selected { id, .. } => {
                let id = *id;
                if interaction.delete_pressed {
                    return Some(Action::Delete(Deletable::Route(id)));
                }
                if let Some(Event::Clicked { pos }) = interaction.event {
                    // Click another object to select it directly; empty canvas
                    // deselects. (Clicking this route resolves back to itself.)
                    return Some(
                        crate::tools::select_tool::click_to_select(data, pos, painter)
                            .unwrap_or_default(),
                    );
                } else if let Some(Event::DragStarted { pos }) = interaction.event {
                    // Dragging this route's edge/waypoint edits it; dragging
                    // anything else starts moving that object straight away.
                    match start_drag(data, id, pos) {
                        Some(new_state) => *self = new_state,
                        None => {
                            return Some(crate::tools::select_tool::drag_to_move(
                                data, pos, painter,
                            ));
                        }
                    }
                }
            }

            EditRoute::DraggingEdge {
                id,
                start_cursor,
                end_cursor,
                session,
                ..
            } => {
                if let Some(Event::DragStopped { .. }) = interaction.event {
                    // Release: the one document write of the whole edit — the
                    // working corners land locked (user-placed) and the final
                    // geometry is promoted to stored waypoints. Skip if the drag
                    // never realized (no `Dragging` frame occurred).
                    let (id, start, end) = (*id, *start_cursor, *end_cursor);
                    if let Some(s) = session {
                        data.commit_route_edit(id, s, &[start, end]);
                    }
                    *self = EditRoute::Selected {
                        id,
                        anchor: start + (end - start) * 0.5,
                    };
                }
            }

            EditRoute::DraggingWaypoint {
                id,
                cursor,
                session,
            } => {
                if let Some(Event::DragStopped { .. }) = interaction.event {
                    // Release: commit the working corner (locked, user-placed) and
                    // promote the final geometry. Skip if the drag never realized.
                    let (id, cursor) = (*id, *cursor);
                    if let Some(s) = session {
                        data.commit_route_edit(id, s, &[cursor]);
                    }
                    *self = EditRoute::Selected { id, anchor: cursor };
                }
            }
        }
        None
    }
}

impl EditRoute {
    /// Begin editing route `id` already mid-drag, as if it had been selected and
    /// the drag started on it. Lets the select/resize tools hand off a drag that
    /// lands on a route edge, skipping the separate click-to-select step. Returns
    /// `None` if `pos` isn't on a draggable part of the route.
    ///
    /// Borrows the drawing immutably, which is the whole of the "lazy" in
    /// lazy edge drag: starting a drag *cannot* stage waypoints, because it
    /// has no way to write. It used to, and the eager plan was then thrown
    /// away by the select→drag tool switch's re-route; a test guarded that
    /// until this signature made it unrepresentable.
    pub(crate) fn drag_from(data: &Drawing, id: RouteId, pos: Pos2) -> Option<Self> {
        start_drag(data, id, pos)
    }

    /// Advance a live drag by this frame's `event` and relay the wire through
    /// its working corners, into derived state only — no autoroute, so the
    /// segment goes exactly where the user drags it. The plan is built on the
    /// first frame that actually drags, after the select→drag tool switch has
    /// re-routed (which would invalidate a plan staged earlier); an event-less
    /// repaint re-relays the plan it already has.
    fn preview_drag(&mut self, data: &mut Drawing<'_>, event: Option<Event>, phase: &Supposing) {
        let dragged = match event {
            Some(Event::Dragging { delta, .. }) => Some(delta),
            _ => None,
        };
        match self {
            EditRoute::DraggingEdge {
                id,
                direction,
                start_cursor,
                end_cursor,
                session,
            } => {
                if dragged.is_some() && session.is_none() {
                    *session = data.route_edit_session(*id, &[*start_cursor, *end_cursor]);
                }
                let Some(s) = session else { return };
                if let Some(delta) = dragged {
                    let constrained = match direction {
                        RouteDirection::Horizontal => vec2(0.0, delta.y),
                        RouteDirection::Vertical => vec2(delta.x, 0.0),
                    };
                    *start_cursor += constrained;
                    *end_cursor += constrained;
                }
                data.preview_route_edit(phase, *id, s, &[*start_cursor, *end_cursor]);
            }
            EditRoute::DraggingWaypoint {
                id,
                cursor,
                session,
            } => {
                if dragged.is_some() && session.is_none() {
                    *session = data.route_edit_session(*id, &[*cursor]);
                }
                let Some(s) = session else { return };
                if let Some(delta) = dragged {
                    *cursor += delta;
                }
                data.preview_route_edit(phase, *id, s, &[*cursor]);
            }
            _ => {}
        }
    }

    fn render<C: Canvas>(
        &self,
        data: &Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) {
        match self {
            EditRoute::Idle => {
                crate::widget::display::widget(data, interaction, painter);
            }
            EditRoute::Hovered { id } => {
                let id = *id;
                DrawingPasses::new(data)
                    .route_mode(move |rid| {
                        if rid == id {
                            RouteRenderMode::Highlighted
                        } else {
                            RouteRenderMode::Normal
                        }
                    })
                    .draw(painter);
            }
            EditRoute::Selected { id, .. } => {
                render_selected(data, painter, *id);
            }
            EditRoute::DraggingEdge {
                id,
                start_cursor,
                end_cursor,
                session,
                ..
            } => match session {
                Some(session) => render_dragging(
                    data,
                    painter,
                    DragFrame {
                        id: *id,
                        session,
                        cursors: &[*start_cursor, *end_cursor],
                        grabbed: None,
                    },
                ),
                None => render_selected(data, painter, *id),
            },
            EditRoute::DraggingWaypoint {
                id,
                cursor,
                session,
            } => match session {
                Some(session) => render_dragging(
                    data,
                    painter,
                    DragFrame {
                        id: *id,
                        session,
                        cursors: &[*cursor],
                        grabbed: Some(*cursor),
                    },
                ),
                None => render_selected(data, painter, *id),
            },
        }
    }
}

fn render_selected<C: Canvas>(data: &Drawing, painter: &mut Style<'_, C>, id: RouteId) {
    let authoring = data.authoring();
    DrawingPasses::new(data)
        .route_mode(move |rid| {
            if rid == id {
                RouteRenderMode::Selected { authoring }
            } else {
                RouteRenderMode::Normal
            }
        })
        .draw(painter);
}

/// One drag frame's working state, for the overlay: the plan, the cursors
/// driving the working corners, and — for a waypoint drag — the grabbed
/// corner that gets its emphasis ring.
#[derive(Clone, Copy)]
struct DragFrame<'a> {
    id: RouteId,
    session: &'a RouteEditSession,
    cursors: &'a [Pos2],
    grabbed: Option<Pos2>,
}

/// Draw a drag frame: the edited route in `Editing` mode (halo, no stored
/// decorations — the document's corner set is stale mid-drag), then the
/// working state on top: the session's hypothetical handles, the text
/// anchors on the previewed geometry, each label pinned at its captured
/// drag-start anchor, and the drag's own emphasis (the projected segment
/// for an edge drag, the grabbed-corner ring for a waypoint drag). Before
/// the first `Dragging` frame there is no session and the stored set is
/// still current, so the route draws as plain `Selected` instead.
fn render_dragging<C: Canvas>(data: &Drawing, painter: &mut Style<'_, C>, frame: DragFrame) {
    let DragFrame {
        id,
        session,
        cursors,
        grabbed,
    } = frame;
    let cursors = cursors.to_vec();
    DrawingPasses::new(data)
        .route_mode(move |rid| {
            if rid == id {
                RouteRenderMode::Editing
            } else {
                RouteRenderMode::Normal
            }
        })
        .suppress_route_label(id)
        .overlay(move |painter| {
            let (Some(wire), Some(geometry)) = (data.auto_route(id), data.route_geometry(id))
            else {
                return;
            };
            render_waypoint_handles(
                painter,
                session
                    .corners(&wire.route.waypoints, &cursors)
                    .into_iter()
                    .map(|(pos, lock)| (px_point(pos), lock)),
            );
            render_text_anchors(painter, text_anchors(&wire.labels, geometry));
            // Pin each label at its drag-start world anchor: re-project the
            // anchor onto the previewed geometry, exactly as the commit's
            // re-anchoring will.
            let color = route_text_color(wire.route, RouteRenderMode::Editing);
            for &(_, anchor) in session.anchors() {
                let at = geometry.map_linear_distance_to_position(geometry.distance_along(anchor));
                render_route_label_at(painter, wire.route, at, color);
            }
            if let Some(cursor) = grabbed {
                // The grabbed corner's ring, over its handle.
                painter.circle(
                    px_point(grid_point(cursor)),
                    PORT_RADIUS,
                    Role::WaypointFill,
                    (1.0, Role::ControlHandleFill),
                );
            } else {
                // The dragged segment's projection.
                let projected: Vec<Pos2> =
                    geometry.points().into_iter().map(snap_to_grid).collect();
                let path = render_path_with_chamfered_corners(&projected);
                path.render(painter, (1.5, Role::EdgeDragPreview));
            }
        })
        .draw(painter);
}

/// Classify where `pos` lands on route `id` and return the matching lazy drag
/// state — reading only, staging no document mutation. The edit plan is built
/// on the drag's first `Dragging` frame (see [`EditRoute::widget`]), after the
/// select→drag tool switch has re-routed the wire.
/// Priority: waypoint → corner → edge center.
fn start_drag(data: &Drawing, id: RouteId, pos: Pos2) -> Option<EditRoute> {
    if data.authoring().is_withheld() {
        return None;
    }
    let wire = data.auto_route(id)?;
    let geometry = data.route_geometry(id)?;

    // 1. Existing waypoint.
    let waypoints = wire.route.waypoints.clone();
    if let Some(ordinal) = hit_waypoint(&waypoints, pos, HIT_RADIUS.get()) {
        let wp_pos = waypoints.get(usize::from(ordinal))?.pos;
        return Some(EditRoute::DraggingWaypoint {
            id,
            cursor: px_point(wp_pos),
            session: None,
        });
    }

    // 2. Corner (junction of two edges).
    if let Some((edge_1, _)) = geometry.hovered_corner(pos) {
        let corner_pos: Pos2 = geometry.edge(edge_1).map(|e| px_point(e.end))?;
        return Some(EditRoute::DraggingWaypoint {
            id,
            cursor: corner_pos,
            session: None,
        });
    }

    // 3. Edge center — draggable only if two boundary waypoints fit, each at
    // least a cell from either anchor (a shorter linear segment is not editable).
    if let Some(edge_id) = geometry.hovered_edge(pos) {
        let edge = geometry.edge(edge_id)?.clone();
        if edge.distance(pos).1 <= HIT_RADIUS.get()
            && let Some((start_cursor, end_cursor)) = boundary_seeds(geometry, &edge)
        {
            return Some(EditRoute::DraggingEdge {
                id,
                direction: edge.direction(),
                start_cursor,
                end_cursor,
                session: None,
            });
        }
    }

    None
}

/// Seed positions for an edge drag's two boundary waypoints, or `None` when the
/// edge can't host them. Every waypoint a drag adds must sit at least one cell
/// from either route anchor (one on an anchor would overlap the pin), so an edge
/// end that lands on an anchor — a straight pin-to-pin segment — is pulled one
/// cell inward along the edge. A segment shorter than three cells leaves no room
/// for two such waypoints and is not editable. An interior edge's ends are
/// existing corners, already clear of the anchors, and are used unchanged.
fn boundary_seeds(geometry: &RouteGeometry, edge: &RouteEdge) -> Option<(Pos2, Pos2)> {
    let start: Pos2 = px_point(edge.start);
    let end: Pos2 = px_point(edge.end);
    let along = end - start;
    let len = along.length();
    if len == 0.0 {
        return None;
    }
    let step = along / len * GRID_SIZE; // one cell along the edge
    let start_seed = if is_anchor(geometry, edge.start) {
        start + step
    } else {
        start
    };
    let end_seed = if is_anchor(geometry, edge.end) {
        end - step
    } else {
        end
    };
    (clear_of_anchors(geometry, start_seed)
        && clear_of_anchors(geometry, end_seed)
        && (end_seed - start_seed).length() >= GRID_SIZE - 0.5)
        .then_some((start_seed, end_seed))
}

/// Whether grid point `p` is one of the route's fixed anchors.
fn is_anchor(geometry: &RouteGeometry, p: blockworx_doc::geometry::GridPoint) -> bool {
    p == geometry.start_pos || p == geometry.end_pos
}

/// Whether `pos` sits at least one cell from both anchors — the invariant every
/// waypoint added during a drag must satisfy (a closer one would overlap a pin).
fn clear_of_anchors(geometry: &RouteGeometry, pos: Pos2) -> bool {
    let cell = GRID_SIZE - 0.5;
    geometry.start_pos().distance(pos) >= cell && geometry.end_pos().distance(pos) >= cell
}