Struct smithay_client_toolkit::Environment

pub struct Environment {
    pub manager: GlobalManager,
    pub compositor: WlCompositor,
    pub subcompositor: WlSubcompositor,
    pub shell: Shell,
    pub shm: WlShm,
    pub data_device_manager: WlDataDeviceManager,
    pub outputs: OutputMgr,
    pub decorations_mgr: Option<ZxdgDecorationManagerV1>,
    // some fields omitted
}

A convenience for global management

This type provides convenience utilities for writing wayland client apps, by auto-binding a large portion of the global objects you'll likely need to write your app. This is mostly provided as a mean to factor a consequent amount of dumb, redundant code.

Fields

manager: GlobalManager

The underlying GlobalManager wrapping your registry

compositor: WlCompositor

The compositor global, used to create surfaces

subcompositor: WlSubcompositor

The subcompositor global, used to create subsurfaces

shell: Shell

The shell global, used make your surfaces into windows

This tries to bind using the xdg_shell protocol, and fallbacks to wl_shell if it fails

shm: WlShm

The SHM global, to create shared memory buffers

data_device_manager: WlDataDeviceManager

The data device manager, used to handle drag&drop and selection copy/paste

outputs: OutputMgr

A manager for handling the advertised outputs

decorations_mgr: Option<ZxdgDecorationManagerV1>

The decoration manager, if the server supports server-side decorations

Implementations

impl Environment

pub fn from_display(
    display: &WlDisplay,
    evq: &mut EventQueue
) -> Result<Environment>

Create an environment wrapping a new registry

It requires you to provide the EventQueue as well because the initialization process does a few roundtrip to the server to initialize all the globals.

pub fn from_display_with_cb<Impl>(
    display: &WlDisplay,
    evq: &mut EventQueue,
    cb: Impl
) -> Result<Environment> where
    Impl: FnMut(GlobalEvent, WlRegistry) + 'static, 

Create an environment wrapping a new registry

Additionally to from_display, this allows you to provide a callback to be notified of global events, just like GlobalManager::new_with_cb. Note that you will still receive events even if they are processed by this Environment.

pub fn shm_formats(&self) -> Vec<Format>

Retrieve the accepted SHM formats of the server

pub fn create_surface<F>(&self, dpi_change: F) -> WlSurface where
    F: FnMut(i32, WlSurface) + Send + 'static, 

Create a new dpi aware surface

The provided callback will be fired whenever the DPI factor associated to it changes.

The DPI factor associated to a surface is defined as the maximum of the DPI factors of the outputs it is displayed on.

pub fn create_shell_surface<Impl>(
    &self,
    surface: &WlSurface,
    shell_impl: Impl
) -> Box<dyn ShellSurface> where
    Impl: FnMut(Event) + Send + 'static, 

Create a new shell surface