Function destroy 

pub fn destroy(proxy: &impl UntypedOwnedProxyWrapper)

Destroys a proxy without sending a wayland message.

This function only destroys the proxy in libwayland without sending a message to the compositor. You might use this function in the following situations:

• The type does not provide a destructor request.
• In an event handler that destroys the object, e.g. wl_callback.done.
• You want to deliberately leak the wayland object without leaking memory.

This function does nothing if the proxy is already destroyed.

Panic

This function might panic if the proxy is attached to a local queue and the current thread is not the thread in which the queue was created.

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 sync2 = sync.clone();
proxy::set_event_handler(&sync, WlCallback::on_done(move |_, _| {
    proxy::destroy(&sync2);
}));

queue.dispatch_roundtrip_blocking().unwrap();
assert!(proxy::wl_proxy(&*sync).is_none());

Examples found in repository

examples/simple-window/../common/singletons.rs (line 52)

    fn drop(&mut self) {
        if let Some(fixes) = self.get_opt::<WlFixes>(1, 1) {
            fixes.destroy_registry(&self.wl_registry);
            fixes.destroy();
        }
        proxy::destroy(&self.wl_registry);
    }

examples/async-wait/main.rs (line 29)

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 (line 54)

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/simple-window/../common/simple_window.rs (line 163)

    fn global_remove(&self, _slf: &WlRegistryRef, name: u32) {
        let seats = &mut *self.seats.borrow_mut();
        let Some(seat) = seats.remove(&name) else {
            return;
        };
        let data = &mut *seat.borrow_mut();
        data.destroy_pointer();
        if proxy::version(&*data.seat) >= WlSeat::REQ__RELEASE__SINCE {
            data.seat.release();
        } else {
            proxy::destroy(&data.seat);
        }
    }
}

struct SeatEventHandler {
    wp_cursor_shape_manager_v1: WpCursorShapeManagerV1,
    data: Rc<RefCell<SeatData>>,
}

struct SeatData {
    seat: WlSeat,
    pointer: Option<WlPointer>,
    shape: Option<WpCursorShapeDeviceV1>,
}

impl SeatData {
    fn destroy_pointer(&mut self) {
        if let Some(shape) = self.shape.take() {
            shape.destroy();
        }
        if let Some(pointer) = self.pointer.take() {
            if proxy::version(&*pointer) >= WlPointer::REQ__RELEASE__SINCE {
                pointer.release();
            } else {
                proxy::destroy(&pointer);
            }
        }
    }

examples/keyboard-events/main.rs (line 79)

    fn global_remove(&self, _slf: &WlRegistryRef, name: u32) {
        if let Some(seat) = self.seats.borrow_mut().remove(&name) {
            if let Some(kb) = seat.wl_keyboard.take() {
                if proxy::version(&*kb) >= WlKeyboard::REQ__RELEASE__SINCE {
                    kb.release();
                } else {
                    proxy::destroy(&kb);
                }
            }
            if proxy::version(&*seat.wl_seat) >= WlSeat::REQ__RELEASE__SINCE {
                seat.wl_seat.release();
            } else {
                proxy::destroy(&seat.wl_seat);
            }
        }
    }
}

impl WlSeatEventHandler for SeatEventHandler {
    fn capabilities(&self, _slf: &WlSeatRef, capabilities: WlSeatCapability) {
        let kb = &mut *self.0.wl_keyboard.borrow_mut();
        if capabilities.contains(WlSeatCapability::KEYBOARD) {
            if kb.is_none() {
                let wl_keyboard = self.0.wl_seat.get_keyboard();
                proxy::set_event_handler_local(&wl_keyboard, self.clone());
                *kb = Some(wl_keyboard);
            }
        } else {
            if let Some(kb) = kb.take() {
                if proxy::version(&*kb) >= WlKeyboard::REQ__RELEASE__SINCE {
                    kb.release();
                } else {
                    proxy::destroy(&kb);
                }
            }
        }
    }