Struct App

pub struct App {
    pub primary: PerMap,
    pub secondary: Option<PerMap>,
    pub store_unedited_map_in_secondary: bool,
    pub cs: ColorScheme,
    pub opts: Options,
    pub per_obj: PerObjectActions,
    pub session: SessionState,
}

The top-level data that lasts through the entire game, no matter what state the game is in.

Fields

primary: PerMap

State (like the simulation and drawing stuff) associated with the “primary” map.

secondary: Option<PerMap>

Represents state for a different version of the primary map. swap_map can be used to switch the primary and secondary state. This is currently used to compare an edited and unedited map for Ungap the Map and as a debug mode to compare different files representing the same area.

store_unedited_map_in_secondary: bool

cs: ColorScheme

opts: Options

per_obj: PerObjectActions

session: SessionState

Static data that lasts the entire session. Use sparingly.

Implementations

impl App

pub fn has_prebaked(&self) -> Option<(&MapName, &String)>

pub fn prebaked(&self) -> &Analytics

pub fn set_prebaked(&mut self, prebaked: Option<(MapName, String, Analytics)>)

pub fn draw( &self, g: &mut GfxCtx<'_>, opts: DrawOptions, show_objs: &dyn ShowObject, )

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

Assumes some defaults.

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

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

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

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

pub fn mouseover_debug_mode( &self, ctx: &EventCtx<'_>, show_objs: &dyn ShowObject, ) -> Option<ID>

fn calculate_current_selection( &self, ctx: &EventCtx<'_>, show_objs: &dyn ShowObject, debug_mode: bool, unzoomed_roads_and_intersections: bool, unzoomed_buildings: bool, ) -> Option<ID>

fn get_renderables_back_to_front<'a>( &'a self, bounds: Bounds, prerender: &Prerender, agents: &'a mut AgentCache, show_objs: &dyn ShowObject, ) -> Vec<&'a (dyn GameRenderable + 'a)>

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

Ensure the map edits are blank, reset the simulation, and blank out prebaked results.

pub fn swap_map(&mut self)

This swaps the primary and secondary PerMaps. Depending on what state the rest of the app is in, things like IDs might totally change!

impl App

pub fn click_on_intersection<S: Into<String>>( &mut self, ctx: &mut EventCtx<'_>, label: S, ) -> Option<IntersectionID>

If an intersection was clicked, return its ID.

Trait Implementations

impl AppLike for App

fn map(&self) -> &Map

fn cs(&self) -> &ColorScheme

fn mut_cs(&mut self) -> &mut ColorScheme

fn draw_map(&self) -> &DrawMap

fn mut_draw_map(&mut self) -> &mut DrawMap

fn opts(&self) -> &Options

fn mut_opts(&mut self) -> &mut Options

fn map_switched( &mut self, ctx: &mut EventCtx<'_>, map: Map, timer: &mut Timer<'_>, )

fn draw_with_opts(&self, g: &mut GfxCtx<'_>, opts: DrawOptions)

fn make_warper( &mut self, ctx: &EventCtx<'_>, pt: Pt2D, target_cam_zoom: Option<f64>, id: Option<ID>, ) -> Box<dyn State<App>>

Create a widgetry::State that warps to the given point.

fn sim_time(&self) -> Time

fn current_stage_and_remaining_time( &self, id: IntersectionID, ) -> (usize, Duration)

fn change_color_scheme( &mut self, ctx: &mut EventCtx<'_>, cs: ColorSchemeChoice, ) -> bool

Change the color scheme. Idempotent. Return true if there was a change.

impl MinimapControls<App> for MinimapController

fn has_zorder(&self, app: &App) -> bool

Should the user be able to control the z-order visible? The control is only present when zoomed in, placed beneath the zoom column.

fn has_layer(&self, app: &App) -> bool

Is there some additional layer displayed on the minimap? If this changes, the panel gets recalculated.

fn draw_extra(&self, g: &mut GfxCtx<'_>, app: &App)

Draw extra stuff on the minimap, just pulling from the app.

fn make_unzoomed_panel(&self, ctx: &mut EventCtx<'_>, app: &App) -> Panel

When unzoomed, display this panel. By default, no controls when unzoomed.

fn make_legend(&self, ctx: &mut EventCtx<'_>, app: &App) -> Widget

A row beneath the minimap in the zoomed view, usually used as a legend for things on the minimap.

fn make_zoomed_side_panel(&self, ctx: &mut EventCtx<'_>, app: &App) -> Widget

Controls to be placed to the left to the zoomed-in panel

fn panel_clicked( &self, ctx: &mut EventCtx<'_>, app: &mut App, action: &str, ) -> Option<Transition<App>>

If a button is clicked that was produced by some method in this trait, respond to it here.

fn panel_changed(&self, _: &mut EventCtx<'_>, app: &mut App, panel: &Panel)

Called for Outcome::Changed on the panel.

impl SharedAppState for App

fn before_event(&mut self)

Before State::event is called, call this.

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

When DrawBaselayer::DefaultDraw is called, run this.

fn dump_before_abort(&self, canvas: &Canvas)

Will be called if State::event or State::draw panics.

fn before_quit(&self, canvas: &Canvas)

Called before a normal exit, like window close

fn free_memory(&mut self)

If widgetry determines the video card is low on memory, this may be called. The application should make its best effort to delete any unused Drawables.

impl SimpleState<App> for About

fn on_click( &mut self, _: &mut EventCtx<'_>, _: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for ChallengesPicker

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for ChangeDuration

fn on_click( &mut self, _: &mut EventCtx<'_>, _: &mut App, x: &str, panel: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn panel_changed( &mut self, ctx: &mut EventCtx<'_>, _: &mut App, panel: &mut Panel, ) -> Option<Transition<App>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn other_event( &mut self, ctx: &mut EventCtx<'_>, _: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

fn draw_baselayer(&self) -> DrawBaselayer

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

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

impl SimpleState<App> for ChangeScenario

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for DepartureSummary

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for DevToolsMode

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for EditingMarker

fn on_click( &mut self, _: &mut EventCtx<'_>, _: &mut App, x: &str, panel: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn draw_baselayer(&self) -> DrawBaselayer

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

impl SimpleState<App> for GenericCompareCounts

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, panel: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn other_event( &mut self, ctx: &mut EventCtx<'_>, _: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for OneBlock

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn other_event( &mut self, ctx: &mut EventCtx<'_>, _: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for Proposals

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for ShareProposal

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn other_event(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Transition<A>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for ShowAbsolute

fn on_click( &mut self, _: &mut EventCtx<'_>, _: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_mouseover(&mut self, ctx: &mut EventCtx<'_>, app: &mut App)

Called when the mouse has moved.

fn other_event( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for ShowRelative

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_mouseover(&mut self, ctx: &mut EventCtx<'_>, app: &mut App)

Called when the mouse has moved.

fn other_event( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for StopSignEditor

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_mouseover(&mut self, ctx: &mut EventCtx<'_>, _: &mut App)

Called when the mouse has moved.

fn other_event( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for TuneRelative

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, panel: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn other_event( &mut self, ctx: &mut EventCtx<'_>, _: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for UberTurnPicker

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn on_mouseover(&mut self, ctx: &mut EventCtx<'_>, app: &mut App)

Called when the mouse has moved.

fn other_event( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn panel_changed( &mut self, _: &mut EventCtx<'_>, _: &mut A, _: &mut Panel, ) -> Option<Transition<A>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn draw_baselayer(&self) -> DrawBaselayer

impl SimpleState<App> for UberTurnViewer

fn on_click( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, x: &str, _: &mut Panel, ) -> Transition<App>

Called when something on the panel has been clicked. Since the action is just a string, the fallback case can just use unreachable!().

fn panel_changed( &mut self, ctx: &mut EventCtx<'_>, app: &mut App, panel: &mut Panel, ) -> Option<Transition<App>>

Called when something on the panel has changed. If a transition is returned, stop handling the event and immediately apply the transition.

fn other_event( &mut self, ctx: &mut EventCtx<'_>, _: &mut App, ) -> Transition<App>

If a panel on_click event didn’t occur and panel_changed didn’t return transition, then call this to handle all other events.

fn draw_baselayer(&self) -> DrawBaselayer

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

fn on_click_custom( &mut self, _ctx: &mut EventCtx<'_>, _app: &mut A, _action: Box<dyn CloneableAny>, _panel: &mut Panel, ) -> Transition<A>

Called when something on the panel has been clicked.

fn on_mouseover(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Called when the mouse has moved.

impl State<App> for ActiveTraffic

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for AgentSpawner

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for AllRoutesExplorer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for AreaSpawner

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for BackToTitleScreen

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for Blockfinder

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for BulkSelect

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ChangeMode

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for CollisionsViewer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for CommuterPatterns

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ConfirmDiscard

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for CrosswalkEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for CutscenePlayer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for DebugMode

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for DebugWarp

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for DrawFreehand

fn event(&mut self, ctx: &mut EventCtx<'_>, _: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for EditMode

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for EditScenarioModifiers

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ExploreMap

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for FinalScore

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for Floodfiller

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for JumpToTime

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for LoadEdits

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ModeShift

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ParkingOverhead

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PathCostDebugger

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PathCounter

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PickLayer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PolygonDebugger

fn event(&mut self, ctx: &mut EventCtx<'_>, _: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PolygonEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PopularDestinations

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for PreviewTrafficSignal

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for QuickSketch

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for RectangularSelector

fn event(&mut self, ctx: &mut EventCtx<'_>, _: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for RiskSummaries

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for RoadEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for RouteEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for RouteExplorer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for SandboxLoader

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for SandboxMode

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, app: &mut App)

Before this state is popped or replaced, call this.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for SaveEdits

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ScenarioManager

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ScreenshotTest

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for SelectSegments

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn on_destroy(&mut self, ctx: &mut EventCtx<'_>, _: &mut App)

Before this state is popped or replaced, call this.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ShowGaps

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ShowMessage

fn event(&mut self, ctx: &mut EventCtx<'_>, _: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for SignalPicker

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for StoryMapEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TimeWarpScreen

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, app: &mut App)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TrafficRecorder

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TrafficSignalDemand

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TrafficSignalEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TransitRoutes

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TravelTimes

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TripPlanner

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, app: &mut App)

Before this state is popped or replaced, call this.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TripTable

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for TurnExplorer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

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

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ViewKML

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for Viewer

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for Warping

fn event(&mut self, ctx: &mut EventCtx<'_>, _: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl State<App> for ZoneEditor

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

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

Draw

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn on_destroy(&mut self, _: &mut EventCtx<'_>, _: &mut A)

Before this state is popped or replaced, call this.

fn recreate(&mut self, _: &mut EventCtx<'_>, _: &mut A) -> Box<dyn State<A>>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.

impl TripManagementState<App> for TripPlanner

fn mut_files(&mut self) -> &mut TripManagement<App, Self>

fn app_session_current_trip_name(app: &mut App) -> &mut Option<String>

fn sync_from_file_management(&mut self, ctx: &mut EventCtx<'_>, app: &mut App)