Struct wayland_client::NewProxy

pub struct NewProxy<I: Interface> { /* fields omitted */ }

A newly-created proxy that needs implementation

Whenever a new wayland object is created, you will receive it as a NewProxy. You then have to provide an implementation for it, in order to process the incoming events it may receive. Once this done you will be able to use it as a regular Proxy.

Implementations are structs implementing the appropriate variant of the Implementation trait. They can also be closures.

Methods

impl<I: Interface + 'static> NewProxy<I>

pub fn implement<Impl>(self, implementation: Impl) -> Proxy<I> where     Impl: Implementation<Proxy<I>, I::Event> + Send + 'static,

Implement this proxy using given function and implementation data.

pub unsafe fn implement_nonsend<Impl>(     self,     implementation: Impl,     queue: &QueueToken ) -> Proxy<I> where     Impl: Implementation<Proxy<I>, I::Event> + 'static,

Implement this proxy using given function and implementation data.

This method allows the implementation to not be Send, but requires for safety that you provide a token to the event queue this proxy will be implemented on. This method will then ensure that this proxy is registered on this event queue, so that it cannot be dispatched from an other thread.

Unsafety:

This call can be racy if the proxy is not already registered on this event queue and its old queue is being dispatched from an other thread.

To ensure safety, see Proxy::make_wrapper.

pub fn c_ptr(&self) -> *mut wl_proxy

Get a raw pointer to the underlying wayland object

Retrieve a pointer to the object from the libwayland-client.so library. You will mostly need it to interface with C libraries needing access to wayland objects (to initialize an opengl context for example).

Use this if you need to pass an unimplemented object to the C library you are interfacing with.

pub unsafe fn from_c_ptr(ptr: *mut wl_proxy) -> Self

Create a NewProxy instance from a C pointer.

By doing so, you assert that this wayland object was newly created and can be safely implemented. As implementing it will overwrite any previously associated data or implementation, this can cause weird errors akin to memory corruption if it was not the case.