Struct widgetry::mapspace::world::World

pub struct World<ID: ObjectID> {
    objects: HashMap<ID, Object<ID>>,
    quadtree: QuadTree<ID>,
    draw_master_batches: Vec<ToggleZoomed>,
    hovering: Option<ID>,
    dragging_from: Option<(Pt2D, bool)>,
}

A World manages objects that exist in “map-space”, the zoomable and pannable canvas. These objects can be drawn, hovered on, clicked, dragged, etc.

Fields

objects: HashMap<ID, Object<ID>>

quadtree: QuadTree<ID>

draw_master_batches: Vec<ToggleZoomed>

hovering: Option<ID>

dragging_from: Option<(Pt2D, bool)>

Implementations

impl<ID: ObjectID> World<ID>

pub fn unbounded() -> World<ID>

Creates an empty World, whose objects can exist anywhere from (0, 0) to the max f64.

pub fn bounded(bounds: &Bounds) -> World<ID>

Creates an empty World, whose objects can exist in the provided rectangular boundary.

pub fn add(&mut self, id: ID) -> ObjectBuilder<'_, ID>

Start adding an object to the World. The caller should specify the object with methods on ObjectBuilder, then call build.

pub fn delete(&mut self, id: ID)

Delete an object. Not idempotent – this will panic if the object doesn’t exist. Will panic if the object is deleted in the middle of being dragged.

pub fn delete_before_replacement(&mut self, id: ID)

Delete an object, with the promise to recreate it with the same ID before the next call to event. This may be called while the object is being hovered on or dragged.

pub fn initialize_hover(&mut self, ctx: &EventCtx<'_>)

After adding all objects to a World, call this to initially detect if the cursor is hovering on an object. This may also be called after adding or deleting objects to immediately recalculate hover before the mouse moves.

pub fn rebuilt_during_drag(&mut self, prev_world: &World<ID>)

If a drag event causes the world to be totally rebuilt, call this with the previous world to preserve the ongoing drag.

This should be called after initialize_hover.

Important: the rebuilt world must include the same object ID that’s currently being dragged from the previous world.

pub fn draw_master_batch<I: Into<ToggleZoomedBuilder>>(
    &mut self,
    ctx: &EventCtx<'_>,
    draw: I
)

Draw something underneath all objects. This is useful for performance, when a large number of objects never change appearance.

pub fn draw_master_batch_built(&mut self, draw: ToggleZoomed)

Like draw_master_batch, but for already-built objects.

pub fn event(&mut self, ctx: &mut EventCtx<'_>) -> WorldOutcome<ID>

Let objects in the world respond to something happening.

fn calculate_hover(&self, cursor: Pt2D) -> Option<ID>

pub fn draw(&self, g: &mut GfxCtx<'_>)

Draw objects in the world that’re currently visible.

pub fn get_hovering(&self) -> Option<ID>

Returns the object currently hovered on.

pub fn override_tooltip(&mut self, id: &ID, tooltip: Option<Text>) -> bool

Change an object’s tooltip. Returns true for success, false if the object didn’t exist.

pub fn calculate_hovering(&self, ctx: &EventCtx<'_>) -> Option<ID>

Calculate the object currently underneath the cursor. This should only be used when the World is not being actively updated by calling event. If another state temporarily needs to disable most interactions with objects, it can poll this instead.

pub fn get_hovered_keybindings(&self) -> Option<&Vec<(MultiKey, &'static str)>>

If an object is currently being hovered on, return its keybindings. This should be used to describe interactions; to detect the keypresses, listen for WorldOutcome::Keypress.

impl World<DummyID>

pub fn add_unnamed(&mut self) -> ObjectBuilder<'_, DummyID>

Begin adding an unnamed object to the World.

Note: You must call build on this object before calling add_unnamed again. Otherwise, the object IDs will collide.

TODO This will break when objects are deleted!