Function set_event_handler 

pub fn set_event_handler<P, H>(proxy: &P, handler: H)
where
    P: OwnedProxy,
    P::Api: CreateEventHandler<H>,
    <P::Api as CreateEventHandler<H>>::EventHandler: Send + 'static,

Sets the event handler of the proxy.

This function can only be called once for each proxy. This function cannot be called on wrappers.

The event handler must implement Send. Use set_event_handler_local if your event handler does not implement Send.

Panic

This function panics if

• the proxy has already been destroyed,
• the proxy is a wrapper,
• the proxy is attached to a local queue and the current thread is not the thread in which the queue was created,
• the proxy already has an event handler, or
• the event handler accepts a &mut T, T != (), and the queue that the proxy is attached to was not created with this data type.

This function also panics if the interface of the created handler is not the same as the interface of the proxy. However, this cannot happen if you’re using the bindings generated by wl-client-builder.

Example

let lib = Libwayland::open().unwrap();
let con = lib.connect_to_default_display().unwrap();
let queue = con.create_queue(c"");
let display: WlDisplay = queue.display();
let sync = display.sync();
let done = Arc::new(AtomicBool::new(false));

// Attach the event handler.
let done2 = done.clone();
proxy::set_event_handler(&sync, WlCallback::on_done(move |_, _| {
    done2.store(true, Relaxed);
}));

// Wait for the compositor to send the `done` message.
queue.dispatch_roundtrip_blocking().unwrap();

// The event handler sets the value to `true`.
assert!(done.load(Relaxed));

Examples found in repository

examples/async-wait/main.rs (lines 25-32)

fn create_sync(queue: &Queue, n: u64) {
    let sync = queue.display::<WlDisplay>().sync();
    proxy::set_event_handler(
        &sync.clone(),
        WlCallback::on_done(move |_, _| {
            println!("done! ({n})");
            proxy::destroy(&sync);
            create_sync(proxy::queue(&sync), n + 1);
        }),
    );
}

examples/poll-integration/main.rs (lines 50-57)

fn create_sync(queue: &Queue, n: u64) {
    let sync = queue.display::<WlDisplay>().sync();
    proxy::set_event_handler(
        &sync.clone(),
        WlCallback::on_done(move |_, _| {
            println!("done! ({n})");
            proxy::destroy(&sync);
            create_sync(proxy::queue(&sync), n + 1);
        }),
    );
}

examples/get-registry-with-data/main.rs (lines 37-46)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let (_queue, queue) = con.create_queue_with_data::<State>(c"get-registry");

    // Create a new registry that will receive the globals and can later be used to
    // bind them.
    let mut state = State {
        registry: queue.display::<WlDisplay>().get_registry(),
        globals: vec![],
    };

    // Since we only want to create a snapshot, we don't care about
    // global_remove events. This allows us to use the functional event handler
    // form.
    proxy::set_event_handler(
        &state.registry,
        WlRegistry::on_global(|state: &mut State, _, name, interface, version| {
            state.globals.push(Global {
                name,
                interface: interface.to_string(),
                version,
            });
        }),
    );
    queue.dispatch_roundtrip_blocking(&mut state).unwrap();

    println!("{:#?}", state.globals);
}

examples/hello-wayland/main.rs (lines 24-30)

fn main() {
    // Load the `libwayland-client.so` dynamic library.
    let lib = Libwayland::open().unwrap();
    // Connect to the default display determined by the `WAYLAND_DISPLAY` env var.
    let con = lib.connect_to_default_display().unwrap();
    // Create a new event queue with the name `hello-wayland`. This name will show up
    // when debugging applications with `WAYLAND_DEBUG=1`.
    let queue = con.create_queue(c"hello-wayland");
    // Get a reference to the `wl_display` singleton. This type was generated with the
    // `wl-client-builder` crate.
    let display: WlDisplay = queue.display();
    // Create a `wl_callback` object. The compositor will immediately respond with a
    // `wl_callback.done` event.
    let sync = display.sync();
    // Set the event handler of the proxy.
    proxy::set_event_handler(
        &sync,
        // When only handling a single event, the following functional form can be used.
        // In general, and when handling more than one event, the event handler trait must
        // be implemented. In this case, `WlCallbackEventHandler`.
        WlCallback::on_done(|_, _| println!("Hello wayland!")),
    );
    // Perform a roundtrip to ensure that the `done` event has been dispatched.
    queue.dispatch_roundtrip_blocking().unwrap();
}