Enum kas::event::Response

pub enum Response<M> {
    None,
    Unhandled,
    Pan(Offset),
    Focus(Rect),
    Select,
    Update,
    Msg(M),
}

Response type from Handler::handle.

This type wraps Handler::Msg allowing both custom messages and toolkit messages.

Variants

None

Nothing of external interest

This implies that the event was consumed, but does not affect parents. Note that we consider “view changes” (i.e. scrolling) to not be of external interest.

Unhandled

Unhandled event

Indicates that the event was not consumed. An ancestor or the event manager is thus able to make use of this event.

Pan(Offset)

Pan scrollable regions by the given delta

With the usual scroll offset conventions, this delta must be subtracted from the scroll offset.

Tuple Fields of Pan

0: Offset

Focus(Rect)

(Keyboard) focus has changed. This region should be made visible.

Tuple Fields of Focus

0: Rect

Select

Widget wishes to be selected (or have selection status toggled)

Update

Notify of update to widget’s data

Widgets which hold editable data should return either this or Response::Msg on handling events which update that data. Note: scrolling/adjusting a view is not considered a data update.

Msg(M)

Custom message type

This signals a (possible) update to the widget’s data, while passing a data payload to the parent widget.

Tuple Fields of Msg

0: M

Implementations

impl<M> Response<M>

pub fn none_or_msg(opt_msg: Option<M>) -> Response<M>

Construct None or Msg(msg)

pub fn update_or_msg(opt_msg: Option<M>) -> Response<M>

Construct Update or Msg(msg)

pub fn is_none(&self) -> bool

True if variant is None

pub fn is_unhandled(&self) -> bool

True if variant is Unhandled

pub fn is_msg(&self) -> bool

True if variant is Msg

pub fn from<N>(r: Response<N>) -> Response<M> where
    N: Into<M>, 

Map from one Response type to another

Once Rust supports specialisation, this will likely be replaced with a From implementation.

pub fn into<N>(self) -> Response<N> where
    M: Into<N>, 

Map one Response type into another

Once Rust supports specialisation, this will likely be redundant.

pub fn try_from<N>(r: Response<N>) -> Result<Response<M>, N>

Try mapping from one Response type to another, failing on Msg variant and returning the payload.

pub fn try_into<N>(self) -> Result<Response<N>, M>

Try mapping one Response type into another, failing on Msg variant and returning the payload.

impl Response<VoidMsg>

pub fn void_into<M>(self) -> Response<M>

Convert a Response<VoidMsg> to another Response

Trait Implementations

impl<M> Clone for Response<M> where
    M: Clone, 

pub fn clone(&self) -> Response<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M> Debug for Response<M> where
    M: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<M> From<M> for Response<M>

pub fn from(msg: M) -> Response<M>

Performs the conversion.

impl<K, M> From<Response<ChildMsg<K, M>>> for Response<M>

pub fn from(r: Response<ChildMsg<K, M>>) -> Response<M>

Performs the conversion.