Enum EditRoute 

pub enum EditRoute {
    Idle,
    Hovered {
        id: RouteId,
    },
    Selected {
        id: RouteId,
        anchor: Pos2,
    },
    DraggingEdge {
        id: RouteId,
        direction: RouteDirection,
        start_cursor: Pos2,
        end_cursor: Pos2,
        session: Option<RouteEditSession>,
    },
    DraggingWaypoint {
        id: RouteId,
        cursor: Pos2,
        session: Option<RouteEditSession>,
    },
}

Variants

Idle

Hovered

Fields

id: RouteId

Selected

Fields

id: RouteId

anchor: Pos2

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.

DraggingEdge

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.

Fields

id: RouteId

direction: RouteDirection

start_cursor: Pos2

end_cursor: Pos2

session: Option<RouteEditSession>

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.

DraggingWaypoint

Fields

id: RouteId

cursor: Pos2

session: Option<RouteEditSession>

The edit plan for the dragged corner, built lazily on the first Dragging frame (see DraggingEdge::session). None until then.

Implementations

impl EditRoute

pub(crate) fn drag_from( data: &Drawing<'_>, id: RouteId, pos: Pos2, ) -> Option<Self>

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 — a staged plan would be thrown away by the select→drag tool switch’s re-route, and this signature makes staging one unrepresentable.

fn preview_drag( &mut self, data: &mut Drawing<'_>, event: Option<Event>, phase: &PreviewPhase, )

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 render<C: Canvas>( &self, data: &Drawing<'_>, interaction: &Interaction, painter: &mut Style<'_, C>, )

Trait Implementations

impl From<EditRoute> for Tool

fn from(v: EditRoute) -> Tool

Converts to this type from the input type.

impl ToolTrait for EditRoute

fn name(&self) -> ToolName

fn selection(&self) -> Option<Deletable>

The item this tool currently has selected that can be deleted, if any. Used to drive the delete button overlay.

fn overlay_anchor(&self) -> Option<Pos2>

A world-space point the selection overlay should anchor to, overriding the selection’s bounding box. A route spans a wide bbox but is picked at one spot, so its overlay anchors at the click instead of the whole polyline.

fn preview<C: Canvas>( &mut self, data: &mut Drawing<'_>, interaction: &Interaction, _painter: &mut Style<'_, C>, phase: &PreviewPhase, )

Advance this frame’s drag state and preview the geometry it implies. Runs before Self::widget paints, on every frame of a drag — including one carrying no event at all, which is what a repaint mid-drag looks like.

fn widget<C: Canvas>( &mut self, data: &mut Drawing<'_>, interaction: &Interaction, painter: &mut Style<'_, C>, ) -> Option<Transition>

impl TryInto<EditRoute> for Tool

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<EditRoute, <Self as TryInto<EditRoute>>::Error>

Performs the conversion.