Struct cursive::views::OnEventView

pub struct OnEventView<T> where
    T: View,  { /* fields omitted */ }

A wrapper view that can react to events.

This view registers a set of callbacks tied to specific events, to be run in certain conditions.

• Some callbacks are called only for events ignored by the wrapped view.

  (those registered by on_event or on_event_inner)

• Others are processed first, and can control whether the child view should be given the event (those registered by on_pre_event or on_pre_event_inner).

"Inner" callbacks (on_event_inner and on_pre_event_inner) are given a reference to the inner wrapped view (but not to the Cursive root). They can then return another callback, taking only a &mut Cursive root as argument.

"Simple" callbacks (on_event and on_pre_event) skip this first phase and are only called with a &mut Cursive.

Examples

let view = OnEventView::new(TextView::new("This view has an event!"))
                        .on_event('q', |s| s.quit())
                        .on_event(event::Key::Esc, |s| s.quit());

Implementations

impl<T> OnEventView<T> where
    T: View, 

pub fn new(view: T) -> OnEventView<T>

Wraps the given view in a new OnEventView.

pub fn clear_event<E>(&mut self, event: E) where
    E: Into<Event>, 

Remove all callbacks associated with the given event.

pub fn on_event<F, E>(self, trigger: E, cb: F) -> OnEventView<T> where
    E: Into<EventTrigger>,
    F: 'static + Fn(&mut Cursive), 

Registers a callback when the given event is ignored by the child.

Chainable variant.

Examples

let view = OnEventView::new(DummyView)
    .on_event('q', |s| s.quit())
    .on_event(Key::Esc, |s| {
        s.pop_layer();
    })
    .on_event(EventTrigger::mouse(), |s| {
        s.add_layer(DummyView);
    });

pub fn on_pre_event<F, E>(self, trigger: E, cb: F) -> OnEventView<T> where
    E: Into<EventTrigger>,
    F: 'static + Fn(&mut Cursive), 

Registers a callback when the given event is received.

The child will never receive this event.

Chainable variant.

pub fn on_pre_event_inner<F, E>(self, trigger: E, cb: F) -> OnEventView<T> where
    E: Into<EventTrigger>,
    F: Fn(&mut T, &Event) -> Option<EventResult> + 'static, 

Registers a callback when the given event is received.

The given callback will be run before the child view sees the event.

• If the result is None, then the child view is given the event as usual.
• Otherwise, it bypasses the child view and directly processes the result.

Chainable variant.

pub fn on_event_inner<F, E>(self, trigger: E, cb: F) -> OnEventView<T> where
    E: Into<EventTrigger>,
    F: Fn(&mut T, &Event) -> Option<EventResult> + 'static, 

Registers a callback when the given event is ignored by the child.

This is an advanced method to get more control. on_event may be easier to use.

If the child view ignores the event, cb will be called with the child view as argument. If the result is not None, it will be processed as well.

Chainable variant.

Examples

let view = OnEventView::new(DummyView)
    .on_event_inner(
        EventTrigger::mouse(),
        |d: &mut DummyView, e: &Event| {
            if let &Event::Mouse { event: MouseEvent::Press(_), .. } = e {
                // Do something on mouse press
                Some(EventResult::with_cb(|s| {
                    s.pop_layer();
                }))
            } else {
                // Otherwise, don't do anything
                None
            }
        }
    );

pub fn set_on_event<F, E>(&mut self, trigger: E, cb: F) where
    E: Into<EventTrigger>,
    F: Fn(&mut Cursive) + 'static, 

Registers a callback when the given event is ignored by the child.

pub fn set_on_pre_event<F, E>(&mut self, trigger: E, cb: F) where
    E: Into<EventTrigger>,
    F: 'static + Fn(&mut Cursive), 

Registers a callback when the given event is received.

The child will never receive this event.

pub fn set_on_pre_event_inner<F, E>(&mut self, trigger: E, cb: F) where
    E: Into<EventTrigger>,
    F: Fn(&mut T, &Event) -> Option<EventResult> + 'static, 

Registers a callback when the given event is received.

The given callback will be run before the child view sees the event.

• If the result is None, then the child view is given the event as usual.
• Otherwise, it bypasses the child view and directly processes the result.

pub fn set_on_event_inner<F, E>(&mut self, trigger: E, cb: F) where
    E: Into<EventTrigger>,
    F: Fn(&mut T, &Event) -> Option<EventResult> + 'static, 

Registers a callback when the given event is ignored by the child.

If the child view ignores the event, cb will be called with the child view as argument. If the result is not None, it will be processed as well.

pub fn clear_callbacks(&mut self)

Remove any callbacks defined for this view.

pub fn get_inner(&self) -> &T

Gets access to the inner view.

pub fn get_inner_mut(&mut self) -> &mut T

Gets mutable access to the inner view.

Trait Implementations

impl<T> ViewWrapper for OnEventView<T> where
    T: View, 

type V = T

Type that this view wraps.

fn with_view<F, R>(&self, f: F) -> Option<R> where
    F: FnOnce(&<OnEventView<T> as ViewWrapper>::V) -> R, 

Runs a function on the inner view, returning the result.

fn with_view_mut<F, R>(&mut self, f: F) -> Option<R> where
    F: FnOnce(&mut <OnEventView<T> as ViewWrapper>::V) -> R, 

Runs a function on the inner view, returning the result.

fn into_inner(
    self
) -> Result<<OnEventView<T> as ViewWrapper>::V, OnEventView<T>> where
    <OnEventView<T> as ViewWrapper>::V: Sized, 

Attempts to retrieve the inner view.

fn wrap_on_event(&mut self, event: Event) -> EventResult

Wraps the on_event method.

fn wrap_draw(&self, printer: &Printer)

Wraps the draw method.

fn wrap_required_size(&mut self, req: XY<usize>) -> XY<usize>

Wraps the required_size method.

fn wrap_layout(&mut self, size: XY<usize>)

Wraps the layout method.

fn wrap_take_focus(&mut self, source: Direction) -> bool

Wraps the take_focus method.

fn wrap_call_on_any(
    &mut self,
    selector: &Selector,
    callback: &'a mut (dyn FnMut(&mut (dyn View + 'static)) + 'a)
)

Wraps the find method.

fn wrap_focus_view(&mut self, selector: &Selector) -> Result<(), ()>

Wraps the focus_view method.

fn wrap_needs_relayout(&self) -> bool

Wraps the needs_relayout method.

fn wrap_important_area(&self, size: XY<usize>) -> Rect

Wraps the important_area method.