Struct guion_sdl2::simple::env::SimpleEnv

pub struct SimpleEnv;

Trait Implementations

impl AsHandlerStateful<SimpleEnv> for SimpleCtx

type T = SimpleHandler

fn stateful_mut(&mut self) -> &mut Self::T

fn stateful(&self) -> &Self::T

impl Backend<SimpleEnv> for SimpleBackend

type Renderer = Render<Window>

type Event = DynEvent<SimpleEnv, Key, StdDest<SimpleDest>>

type Style = Style

type Size = Size

impl Clone for SimpleEnv

fn clone(&self) -> SimpleEnv

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Context<SimpleEnv> for SimpleCtx

type Handler = SimpleHandler

type Queue = Queue<SimpleEnv>

fn queue_mut(&mut self) -> &mut Self::Queue

fn queue(&self) -> &Self::Queue

fn _handler_mut(&mut self) -> &mut Self::Handler

fn _handler(&self) -> &Self::Handler

fn default_style(&self) -> &Style

fn default_border(&self) -> &Border

fn handler_mut<H>(&mut self) -> &mut H where
    H: Handler<E>,
    Self: AsRefMut<H>, 

fn handler<H>(&self) -> &H where
    H: Handler<E>,
    Self: AsRefMut<H>, 

fn render(&mut self, w: Resolved<E>, r: &mut RenderLink<E>) -> bool

fn event(
    &mut self,
    w: Resolved<E>,
    e: (<<E as Env>::Backend as Backend<E>>::Event, &Bounds, u64)
)

fn size(&mut self, w: Resolved<E>) -> <<E as Env>::Backend as Backend<E>>::Size

fn _event_root(
    &mut self,
    w: Resolved<E>,
    e: (<<E as Env>::Backend as Backend<E>>::Event, &Bounds, u64)
)

fn link<'l, 's>(&'s mut self, w: Resolved<'l, E>) -> Link<'s, E> where
    'l: 's, 

fn state(&self) -> &<<E as Env>::Context as AsHandlerStateful<E>>::T where
    Self: AsHandlerStateful<E>, 

impl Env for SimpleEnv

type Backend = SimpleBackend

type Context = SimpleCtx

type Storage = SimpleStor

type WidgetID = StdID

type WidgetPath = StandardPath

type ValidState = SimpleValidState

impl EnvFlexStyleVariant for SimpleEnv

type StyleVariant = StdStyleVariant

impl PartialEq<SimpleEnv> for SimpleEnv

fn eq(&self, other: &SimpleEnv) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralPartialEq for SimpleEnv

impl Widgets<SimpleEnv> for SimpleStor

fn widget<'a>(&'a self, i: StandardPath) -> Result<Resolved<'a, SimpleEnv>, ()>

fn _widget_mut<'a>(
    &'a mut self,
    i: StandardPath,
    invalidate: bool
) -> Result<ResolvedMut<'a, SimpleEnv>, ()>

fn trace_bounds(
    &self,
    ctx: &mut SimpleCtx,
    i: StandardPath,
    b: &Bounds,
    force: bool
) -> Result<Bounds, ()>

fn widget_mut(
    &'a mut self,
    i: <E as Env>::WidgetPath
) -> Result<ResolvedMut<'a, E>, ()>

fn has_widget(&self, i: <E as Env>::WidgetPath) -> bool

fn tune_path(&self, _i: &mut <E as Env>::WidgetPath)

Deprecated

fn tune_path_mut(&mut self, _i: &mut <E as Env>::WidgetPath)

Deprecated

fn with_env<F>(&self) -> &<F as Env>::Storage where
    F: Env<Storage = Self>,
    Self: Widgets<F>,