Struct wayland_client::GlobalManager

pub struct GlobalManager { /* fields omitted */ }

An utility to manage global objects

This utility provides an implemenation for the registry that track the list of globals for you, as well as utilities to bind them.

Implementations

impl GlobalManager

pub fn new(display: &WlDisplay) -> GlobalManager

Create a global manager handling a registry

In order to use GlobalManager from a different thread than the one display was created on, wrap the display to an EventQueue on the appropriate thread using Proxy::make_wrapper() before calling this function.

pub fn new_with_cb<F>(display: &WlDisplay, callback: F) -> GlobalManager where
    F: FnMut(GlobalEvent, WlRegistry) + 'static, 

Create a global manager handling a registry with a callback

This global manager will track globals as a simple one, but will also forward the registry events to your callback.

This can be used if you want to handle specially certain globals, but want to use the default mechanism for the rest.

In order to use GlobalManager from a different thread than the one display was created on, wrap the display to an EventQueue on the appropriate thread using Proxy::make_wrapper() before calling this function.

pub fn instantiate_exact<I, F>(
    &self,
    version: u32,
    implementor: F
) -> Result<I, GlobalError> where
    I: Interface + From<Proxy<I>>,
    F: FnOnce(NewProxy<I>) -> I, 

Instantiate a global with a specific version

Meaning of requests and events can change depending on the object version you use, as such unless you specifically want to support several versions of a protocol, it is recommended to use this method with an hardcoded value for the version (the one you'll use a as reference for your implementation). Notably you should not use I::VERSION as a version, as this value can change when the protocol files are updated.

This method is only appropriate for globals that are expected to not exist with multiplicity (such as wl_compositor or wl_shm), as it will always bind the first one that was advertized.

pub fn instantiate_range<I, F>(
    &self,
    min_version: u32,
    max_version: u32,
    implementor: F
) -> Result<I, GlobalError> where
    I: Interface + From<Proxy<I>>,
    F: FnOnce(NewProxy<I>) -> I, 

Instantiate a global from a version range

If you want to support several versions of a particular global, this method allows you to specify a range of versions that you accept. It'll bind the highest possible version that is between min_version and max_version inclusive, and return an error if the highest version supported by the compositor is lower than min_version. As for instantiate_exact, you should not use I::VERSION here: the versions your code support do not change when the protocol files are updated.

When trying to support several versions of a protocol, you can check which version has actually been used on any object using the Proxy::version() method.

As instantiate_exact, it should only be used for singleton globals, for the same reasons.

pub fn list(&self) -> Vec<(u32, String, u32)>

Retrieve the list of currently known globals

Trait Implementations

impl Clone for GlobalManager

fn clone(&self) -> GlobalManager

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.