Struct map_gui::SimpleApp

pub struct SimpleApp<T> {
    pub map: Map,
    pub draw_map: DrawMap,
    pub cs: ColorScheme,
    pub opts: Options,
    pub current_selection: Option<ID>,
    pub session: T,
    pub time: Time,
}

Simple app state that just renders a static map, without any dynamic agents on the map.

Fields

map: Map

draw_map: DrawMap

cs: ColorScheme

opts: Options

current_selection: Option<ID>

session: T

Custom per-app state can be stored here

time: Time

If desired, this can be advanced to render traffic signals changing.

Implementations

impl<T: 'static> SimpleApp<T>

pub fn new<F: 'static + Fn(&mut EventCtx<'_>, &mut SimpleApp<T>) -> Vec<Box<dyn State<SimpleApp<T>>>>>(
    ctx: &mut EventCtx<'_>,
    opts: Options,
    map_name: MapName,
    cam: Option<String>,
    session: T,
    init_states: F
) -> (SimpleApp<T>, Vec<Box<dyn State<SimpleApp<T>>>>)

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

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

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_buildings(&self, ctx: &EventCtx<'_>) -> Option<ID>

Only select buildings, and work whether zoomed in or not.

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

Trait Implementations

impl<T: 'static> AppLike for SimpleApp<T>

fn map(&self) -> &Map

fn sim(&self) -> &Sim

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>,
    _: Option<ID>
) -> Box<dyn State<SimpleApp<T>>>

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<T: 'static> SharedAppState for SimpleApp<T>

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.

fn before_event(&mut self)

Before State::event is called, call this.

impl<T> State<SimpleApp<T>> for SimpleWarper

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

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

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

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> + 'static, Global>

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