Trait chargrid_event_routine::EventRoutine[−][src]

pub trait EventRoutine: Sized {
    type Return;
    type Data;
    type View;
    type Event;
    fn handle<EP>(
        self, 
        data: &mut Self::Data, 
        view: &Self::View, 
        event_or_peek: EP
    ) -> Handled<Self::Return, Self>
    where
        EP: EventOrPeek<Event = Self::Event>;

    fn view<F, C>(
        &self, 
        data: &Self::Data, 
        view: &mut Self::View, 
        context: ViewContext<C>, 
        frame: &mut F
    )
    where
        F: Frame,
        C: ColModify;

    fn repeat<U, F>(self, f: F) -> Repeat<Self, F>
    where
        F: FnMut(Self::Return) -> Handled<U, Self>,
    { ... }

    fn select<S>(self, selector: S) -> Select<Self, S>
    where
        S: Selector<DataOutput = Self::Data, ViewOutput = Self::View>,
    { ... }

    fn then<U, F>(self, f: F) -> Then<Self, U, F>
    where
        U: EventRoutine<Data = Self::Data, View = Self::View>,
        F: FnOnce() -> U,
    { ... }

    fn and_then<U, F>(self, f: F) -> AndThen<Self, U, F>
    where
        U: EventRoutine<Data = Self::Data, View = Self::View>,
        F: FnOnce(Self::Return) -> U,
    { ... }

    fn map<F, U>(self, f: F) -> Map<Self, F>
    where
        F: FnOnce(Self::Return) -> U,
    { ... }

    fn convert_input_to_common_event(self) -> ConvertInputToCommonEvent<Self> { ... }

    fn app_one_shot_ignore_return(
        self, 
        data: Self::Data, 
        view: Self::View
    ) -> EventRoutineAppOneShotIgnoreReturn<Self> { ... }

    fn return_on_exit<F>(self, f: F) -> ReturnOnExit<Self, F>
    where
        F: FnOnce(&mut Self::Data) -> Self::Return,
    { ... }

    fn decorated<D>(self, d: D) -> Decorated<Self, D>
    where
        D: Decorate<View = Self::View, Data = Self::Data>,
    { ... }

    fn on_event<F>(self, f: F) -> OnEvent<Self, F>
    where
        F: FnMut(&mut &mut Self::Data, &Self::Event),
    { ... }
}

Associated Types

type Return[src]

type Data[src]

type View[src]

type Event[src]

Loading content...

Required methods

fn handle<EP>(
    self,
    data: &mut Self::Data,
    view: &Self::View,
    event_or_peek: EP
) -> Handled<Self::Return, Self> where
    EP: EventOrPeek<Event = Self::Event>, [src]

fn view<F, C>(
    &self,
    data: &Self::Data,
    view: &mut Self::View,
    context: ViewContext<C>,
    frame: &mut F
) where
    F: Frame,
    C: ColModify, [src]

Loading content...

Provided methods

fn repeat<U, F>(self, f: F) -> Repeat<Self, F> where
    F: FnMut(Self::Return) -> Handled<U, Self>, [src]

fn select<S>(self, selector: S) -> Select<Self, S> where
    S: Selector<DataOutput = Self::Data, ViewOutput = Self::View>, [src]

fn then<U, F>(self, f: F) -> Then<Self, U, F> where
    U: EventRoutine<Data = Self::Data, View = Self::View>,
    F: FnOnce() -> U, [src]

fn and_then<U, F>(self, f: F) -> AndThen<Self, U, F> where
    U: EventRoutine<Data = Self::Data, View = Self::View>,
    F: FnOnce(Self::Return) -> U, [src]

fn map<F, U>(self, f: F) -> Map<Self, F> where
    F: FnOnce(Self::Return) -> U, [src]

fn convert_input_to_common_event(self) -> ConvertInputToCommonEvent<Self>[src]

fn app_one_shot_ignore_return(
    self,
    data: Self::Data,
    view: Self::View
) -> EventRoutineAppOneShotIgnoreReturn<Self>[src]

fn return_on_exit<F>(self, f: F) -> ReturnOnExit<Self, F> where
    F: FnOnce(&mut Self::Data) -> Self::Return, [src]

fn decorated<D>(self, d: D) -> Decorated<Self, D> where
    D: Decorate<View = Self::View, Data = Self::Data>, [src]

fn on_event<F>(self, f: F) -> OnEvent<Self, F> where
    F: FnMut(&mut &mut Self::Data, &Self::Event), [src]

Loading content...

Implementors

impl<D, V> EventRoutine for Delay<D, V>[src]

type Return = ()

type Data = D

type View = V

type Event = CommonEvent

impl<F, D, V, E, T> EventRoutine for SideEffect<F, D, V, E> where
    F: FnOnce(&mut D, &V) -> T, [src]

type Return = T

type Data = D

type View = V

type Event = E

impl<F, D, V, E, U> EventRoutine for SideEffectThen<F, D, V, E, U> where
    U: EventRoutine<Data = D, View = V, Event = E>,
    F: FnOnce(&mut D, &V) -> U, [src]

type Return = U::Return

type Data = D

type View = V

type Event = E

impl<T> EventRoutine for ConvertInputToCommonEvent<T> where
    T: EventRoutine<Event = Input>, [src]

type Return = T::Return

type Data = T::Data

type View = T::View

type Event = CommonEvent

impl<T, D> EventRoutine for Decorated<T, D> where
    T: EventRoutine,
    D: Decorate<View = T::View, Data = T::Data>, [src]

type Return = T::Return

type Data = T::Data

type View = T::View

type Event = T::Event

impl<T, D, V, E> EventRoutine for Value<T, D, V, E>[src]

type Return = T

type Data = D

type View = V

type Event = E

impl<T, F> EventRoutine for ReturnOnExit<T, F> where
    T: EventRoutine<Event = CommonEvent>,
    F: FnOnce(&mut T::Data) -> T::Return, [src]

type Return = T::Return

type Data = T::Data

type View = T::View

type Event = CommonEvent

impl<T, F> EventRoutine for OnEvent<T, F> where
    T: EventRoutine,
    F: FnMut(&mut &mut T::Data, &T::Event), [src]

type Return = T::Return

type Data = T::Data

type View = T::View

type Event = T::Event

impl<T, F, R> EventRoutine for Loop<T, F, R> where
    F: FnMut() -> R,
    R: EventRoutine<Return = Option<T>>, [src]

type Return = T

type Data = R::Data

type View = R::View

type Event = R::Event

impl<T, S> EventRoutine for Select<T, S> where
    T: EventRoutine,
    S: Selector<DataOutput = T::Data, ViewOutput = T::View>, [src]

type Return = T::Return

type Data = S::DataInput

type View = S::ViewInput

type Event = T::Event

impl<T, U, F> EventRoutine for AndThen<T, U, F> where
    T: EventRoutine,
    U: EventRoutine<Data = T::Data, View = T::View, Event = T::Event>,
    F: FnOnce(T::Return) -> U, [src]

type Return = U::Return

type Data = T::Data

type View = T::View

type Event = T::Event

impl<T, U, F> EventRoutine for Map<T, F> where
    T: EventRoutine,
    F: FnOnce(T::Return) -> U, [src]

type Return = U

type Data = T::Data

type View = T::View

type Event = T::Event

impl<T, U, F> EventRoutine for Repeat<T, F> where
    T: EventRoutine,
    F: FnMut(T::Return) -> Handled<U, T>, [src]

type Return = U

type Data = T::Data

type View = T::View

type Event = T::Event

impl<T, U, F> EventRoutine for Then<T, U, F> where
    T: EventRoutine,
    U: EventRoutine<Data = T::Data, View = T::View, Event = T::Event>,
    F: FnOnce() -> U, [src]

type Return = U::Return

type Data = T::Data

type View = T::View

type Event = T::Event

impl<T, U, F, R> EventRoutine for Unfold<T, U, F, R> where
    F: FnMut(T) -> R,
    R: EventRoutine<Return = Handled<U, T>>, [src]

type Return = U

type Data = R::Data

type View = R::View

type Event = R::Event

Loading content...