Struct Callback

pub struct Callback<'a, FN, T: 'a>
where
    FN: FnMut(&dyn Component, Option<&T>) + 'a,
{ /* private fields */ }

A callback called when a newt Component is activated.

Example

extern crate newt;
use newt::Callback;
use newt::prelude::*;

pub fn main() {
    // Receives the new value when the Callback is activated.
    let mut value: i32 = 0;

    newt::init().unwrap();
    newt::cls();
    newt::centered_window(20, 6, Some("Callback Test")).unwrap();

    let cb1 = Checkbox::new(3, 1, "Check 1", None, None);
    let cb2 = Checkbox::new(3, 2, "Check 2", None, None);
    let ok = CompactButton::new(7, 4, "Ok");

    let mut form = Form::new(None, 0);
    form.add_components(&[&cb1, &cb2, &ok]).unwrap();

    // Closure `f` borrows `value` as mutable so create a new subscope here
    // allowing `value` to be borrowed immutably when printing the result
    // later.
    {
        // Create closure to be called by Callback
        let mut f = |_c: &dyn Component, data: Option<&i32>| {
            value = *data.unwrap();
        };

        // Create Callback with first Checkbox using `5` as data.
        let mut callback = Callback::new(&cb1, Some(5), &mut f);
        // Add second Checkbox using `10` as data.
        callback.add_component(&cb2, Some(10));

        form.run().unwrap();
        newt::finished();
    }

    // `value` will be 0, 5, or 10 depending on the last Checkbox "clicked".
    println!("value = {}", value);
}

Implementations

impl<'a, FN, T: 'a> Callback<'a, FN, T>

where FN: FnMut(&dyn Component, Option<&T>) + 'a,

pub fn new( component: &'a dyn Component, data: Option<T>, function: FN, ) -> Box<Callback<'a, FN, T>>

Create a new Callback using the function or closure function and associate it with component.

• component - The Component associated with the callback.
• data - Optional user data to pass to the function.
• function - The function or closure to call when the Component is activated.

pub fn add_component(&mut self, component: &'a dyn Component, data: Option<T>)

Associate another component with the Callback.

• component - Another Component to associate with the callback.
• data - Optional user data to pass to the function.

Trait Implementations

impl<'a, FN, T: 'a> Drop for Callback<'a, FN, T>

where FN: FnMut(&dyn Component, Option<&T>) + 'a,

fn drop(&mut self)

Executes the destructor for this type.