Struct RouteTool 

pub struct RouteTool {
    state: RouteToolState,
    preview_path: Vec<TaggedPoint>,
    preview_cache: Option<Box<PreviewCache>>,
    return_to_select: bool,
}

Fields

state: RouteToolState

preview_path: Vec<TaggedPoint>

preview_cache: Option<Box<PreviewCache>>

Cached router + fixed legs for the live preview; rebuilt only when a waypoint is added or a new route starts, and dropped when the gesture ends (which also covers commit changing the set of existing routes). Boxed to keep it off the Tool enum’s stack footprint — it is the widest thing a tool owns, and only the route tool ever has one.

return_to_select: bool

When set, completing or cancelling the route returns to the select tool (the route was started from a select-tool hover target) rather than staying in the route tool ready for the next route.

Implementations

impl RouteTool

pub fn routing_from(start: PinId, head: Pos2) -> Self

Start routing immediately from start, with the route head at head: the caller hands off mid-gesture and the in-progress handling carries the same gesture to a connecting anchor.

pub fn routing_from_select(start: PinId, head: Pos2) -> Self

Like Self::routing_from, but completing or cancelling the route returns to the select tool. Used when a route is started from a select-tool hover target.

fn commit( &mut self, data: &mut Drawing<'_>, start: PinId, finish: FinishTarget, waypoints: Vec<Waypoint>, ) -> RouteToolState

Build and add the route from start to finish through waypoints and return to Idle. A FinishTarget::NewPin finish reconstructs its pin first, in this same frame, so the pin and route collapse into one undo step (state is snapshotted once per frame). A degenerate (zero-length) route is rejected, leaving the proposal in place — and, importantly, no pin is created in that case.

fn finish_pos(data: &Drawing<'_>, finish: &FinishTarget) -> Option<Pos2>

Resolve a finish target’s world position. An existing anchor resolves through data; a new-pin target reports the slot’s prospective connection point directly (the pin doesn’t exist yet).

fn finish_at( data: &Drawing<'_>, start: PinId, pos: Pos2, ) -> Option<FinishTarget>

Resolve the cursor at pos to a finish target during routing: an existing anchor (other than start) takes priority; failing that, the free slot’s marker a press there would land on — the same one the “(+)” and the add-pin tool commit on, so no two tools disagree about where it is.

fn update_preview(&mut self, data: &mut Drawing<'_>)

fn preview_route( &mut self, data: &Drawing<'_>, gesture: &PreviewRequest<'_>, ) -> Vec<TaggedPoint>

Route the in-progress route start → waypoints → end for the live preview, reusing the cached router. start_pos/end are grid-snapped. The router is (re)built only when its fixed inputs change — a different start (new route) or a different waypoint count (a waypoint was added); the moving cursor (end) does not change the graph and is routed via the existing L-path fallback. Routes read-only (SelfCost::Skip semantics) so the cache never accumulates the in-progress route’s own occupancy between frames.

fn draw_new_pin_markers<C: Canvas>( data: &Drawing<'_>, painter: &mut Style<'_, C>, )

While a route is in progress, surface the nearest block’s new-pin markers so the route can terminate on a not-yet-existent pin.

fn render<C: Canvas>(&self, data: &Drawing<'_>, painter: &mut Style<'_, C>)

fn draw_end_target<C: Canvas>( data: &Drawing<'_>, start: PinId, painter: &mut Style<'_, C>, )

Grow the green route-end target on the anchor nearest the cursor (other than start), mirroring the select tool’s start affordance.

fn draw_hover_anchor_target<C: Canvas>( data: &Drawing<'_>, painter: &mut Style<'_, C>, )

Before a route starts, show the same animated anchor target the select tool’s route-start does, so hovering the route tool over a pin reads identically.

fn world_pointer<C: Canvas>(painter: &Style<'_, C>) -> Option<Pos2>

Trait Implementations

impl Default for RouteTool

fn default() -> RouteTool

Returns the “default value” for a type.

impl From<RouteTool> for Tool

fn from(v: RouteTool) -> Tool

Converts to this type from the input type.

impl ToolTrait for RouteTool

fn name(&self) -> ToolName

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

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 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.

impl TryInto<RouteTool> for Tool

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.