Struct XWayland 

pub struct XWayland { /* private fields */ }

Available on crate feature xwayland only.

A handle to a running XWayland process. Using XWayland as an xserver for X11-based clients requires two connections: one wayland socket, where XWayland creates surfaces for its clients, and one X11 socket, where a compositor’s implementation of an X11 window manager connects and handles X11 events.

           ┌───────────────────┐
           │                   │
           │                   │ X11 Clients
           │     Xwayland      │ ◄─────
           │                   │
           │                   │
           └──┬──────────────▲─┘
              │              │
Wayland Socket│              │ X11 Socket
              │              │
              │              │
 ┌────────────▼──────────────┼────────────┐
 │  Compositor               │            │
 │                         ┌─┴───────┐    │
 │                         │ XWM     │    │
 │                         │         │    │
 │                         └─────────┘    │
 │                                        │
 └────────────────────────────────────────┘

This struct handles integrating the XWayland process itself into the event loop, but a separate X11 window manager implementation is needed as well to support X11 clients.

To shut down the instance, dropping this handle is generally sufficient, along with the X11 connection that was passed to the window manager implementation, if any. The process will die once the connections to it are closed.

Implementations

impl XWayland

pub fn spawn<K, V, I, F>( dh: &DisplayHandle, display: impl Into<Option<u32>>, envs: I, open_abstract_socket: bool, stdout: impl Into<Stdio>, stderr: impl Into<Stdio>, user_data: F, ) -> Result<(Self, Client)>

where I: IntoIterator<Item = (K, V)>, K: AsRef<OsStr>, V: AsRef<OsStr>, F: FnOnce(&UserDataMap),

Spawns an XWayland server instance. Xwayland must be on the PATH and executable.

Arguments

• display - if provided, only the given display number will be tested. If you wish smithay to choose a display for you, pass None.
• envs - Allows additionally environment variables to be set when launching XWayland.
• open_abstract_socket - Open an abstract socket as well as filesystem sockets (only on available on Linux).
• stdout, stderr - Allows redirecting stdout and stderr of the XWayland process. XWayland output is rarely useful, so Stdio::null() is a good choice if you’re not sure.
• user_data - Allows mutating the XWaylandClientData::user_data-map before the client is added to the wayland display. Useful for initializing state for global filters.

Returns a handle to the XWayland instance and the Client representing the XWayland server. The handle can be inserted in your event loop, and If everything goes well, you’ll eventually receive an XWaylandEvent::Ready, indicating that it’s time to start the X11 window manager.

pub fn display_number(&self) -> u32

Returns the X11 display used by the instance, suitable for setting the DISPLAY environment variable.

pub fn poll_fd(&self) -> BorrowedFd<'_>

Returns a file descriptor which can be polled for readiness. When the fd is readable, the XWayland server’s readiness can be checked with take_socket.

pub fn take_socket(&mut self) -> Result<Option<UnixStream>>

Checks if the XWayland instance is ready. If XWayland has fully started, this will return the X11 socket connected to the running instance.

Calling take_socket successfully transfers ownership of the connection to the caller. After returning Some the first time, it will always return None.

An Err result is only returned if the XWayland instance has exited unexpectedly.

This is a low-level method. Using the instance as an event source is the recommended way to interact with it.

Trait Implementations

impl Debug for XWayland

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for XWayland

fn drop(&mut self)

Executes the destructor for this type.

impl EventSource for XWayland

type Event = XWaylandEvent

The type of events generated by your source.

type Metadata = ()

Some metadata of your event source

type Ret = ()

The return type of the user callback

type Error = Error

The error type returned from process_events() (not the user callback!).

fn process_events<F>( &mut self, readiness: Readiness, token: Token, callback: F, ) -> Result<PostAction>

where F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,

Process any relevant events

fn register( &mut self, poll: &mut Poll, factory: &mut TokenFactory, ) -> Result<()>

Register yourself to this poll instance

fn reregister( &mut self, poll: &mut Poll, factory: &mut TokenFactory, ) -> Result<()>

Re-register your file descriptors

fn unregister(&mut self, poll: &mut Poll) -> Result<()>

Unregister your file descriptors

const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = false

Whether this source needs to be sent the EventSource::before_sleep and EventSource::before_handle_events notifications. These are opt-in because they require more expensive checks, and almost all sources will not need these notifications

fn before_sleep(&mut self) -> Result<Option<(Readiness, Token)>, Error>

Notification that a single poll is about to begin

fn before_handle_events(&mut self, events: EventIterator<'_>)

Notification that polling is complete, and EventSource::process_events will be called with the given events for this source. The iterator may be empty, which indicates that no events were generated for this source