Struct wayland_server::NewResource

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

A newly-created resource that needs implementation

Whenever a new wayland object is created, you will receive it as a NewResource. 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 Rust object.

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

Methods

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

pub fn implement<T, Dest, UD>(
    self,
    handler: T,
    destructor: Option<Dest>,
    user_data: UD
) -> I where
    T: 'static,
    Dest: FnMut(I) + 'static,
    UD: 'static,
    I: HandledBy<T> + From<Resource<I>>,
    I::Request: MessageGroup<Map = ResourceMap>, 

Implement this resource using a handler, destructor and user data.

The handler is a struct implementing the RequestHandler trait for the corresponding interface.

This must be called from the thread hosting the wayland event loop, otherwise it will panic.

pub fn implement_closure<F, Dest, UD>(
    self,
    implementation: F,
    destructor: Option<Dest>,
    user_data: UD
) -> I where
    F: FnMut(I::Request, I) + 'static,
    Dest: FnMut(I) + 'static,
    UD: 'static,
    I: From<Resource<I>>,
    I::Request: MessageGroup<Map = ResourceMap>, 

Implement this resource using given function, destructor, and user data.

This must be called from the thread hosting the wayland event loop, otherwise it will panic.

pub fn implement_dummy(self) -> I where
    I: From<Resource<I>>,
    I::Request: MessageGroup<Map = ResourceMap>, 

Implement this resource using a dummy handler which does nothing.

pub fn implement_threadsafe<T, Dest, UD>(
    self,
    handler: T,
    destructor: Option<Dest>,
    user_data: UD
) -> I where
    T: Send + 'static,
    Dest: FnMut(I) + Send + 'static,
    UD: Send + Sync + 'static,
    I: HandledBy<T> + From<Resource<I>>,
    I::Request: MessageGroup<Map = ResourceMap>, 

Implement this resource using a handler, destructor and user data.

The handler is a struct implementing the RequestHandler trait for the corresponding interface.

This method allows you to implement from any thread with the constraint that the implementation and user-data must be threadsafe.

pub fn implement_closure_threadsafe<F, Dest, UD>(
    self,
    implementation: F,
    destructor: Option<Dest>,
    user_data: UD
) -> I where
    F: FnMut(I::Request, I) + Send + 'static,
    Dest: FnMut(I) + Send + 'static,
    UD: Send + Sync + 'static,
    I: From<Resource<I>>,
    I::Request: MessageGroup<Map = ResourceMap>, 

Implement this resource using given function, destructor, and user data.

This method allows you to implement from any thread with the constraint that the implementation and user-data must be threadsafe.