Struct wayland_client::protocol::wl_shm_pool::WlShmPool

pub struct WlShmPool { /* private fields */ }

a shared memory pool

The wl_shm_pool object encapsulates a piece of memory shared between the compositor and client. Through the wl_shm_pool object, the client can allocate shared memory wl_buffer objects. All objects created through the same pool share the same underlying mapped memory. Reusing the mapped memory avoids the setup/teardown overhead and is useful when interactively resizing a surface or for many small buffers.

This interface has no events.

Implementations

impl WlShmPool

pub fn create_buffer<U: Send + Sync + 'static, D: Dispatch<WlBuffer, U> + 'static>(
    &self,
    offset: i32,
    width: i32,
    height: i32,
    stride: i32,
    format: Format,
    qh: &QueueHandle<D>,
    udata: U
) -> WlBuffer

create a buffer from the pool

Create a wl_buffer object from the pool.

The buffer is created offset bytes into the pool and has width and height as specified. The stride argument specifies the number of bytes from the beginning of one row to the beginning of the next. The format is the pixel format of the buffer and must be one of those advertised through the wl_shm.format event.

A buffer will keep a reference to the pool it was created from so it is valid to destroy the pool immediately after creating a buffer from it.

pub fn destroy(&self)

destroy the pool

Destroy the shared memory pool.

The mmapped memory will be released when all buffers that have been created from this pool are gone.

pub fn resize(&self, size: i32)

change the size of the pool mapping

This request will cause the server to remap the backing memory for the pool from the file descriptor passed when the pool was created, but using the new size. This request can only be used to make the pool bigger.

This request only changes the amount of bytes that are mmapped by the server and does not touch the file corresponding to the file descriptor passed at creation time. It is the client’s responsibility to ensure that the file is at least as big as the new pool size.

Trait Implementations

impl Clone for WlShmPool

fn clone(&self) -> WlShmPool

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WlShmPool

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

Formats the value using the given formatter.

impl PartialEq<Weak<WlShmPool>> for WlShmPool

fn eq(&self, other: &Weak<WlShmPool>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<WlShmPool> for WlShmPool

fn eq(&self, other: &WlShmPool) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Proxy for WlShmPool

type Request = Request

The request enum for this interface

type Event = Event

The event enum for this interface

fn interface() -> &'static Interface

The interface description

fn id(&self) -> ObjectId

The ID of this object

fn version(&self) -> u32

The version of this object

fn data<U: Send + Sync + 'static>(&self) -> Option<&U>

Access the user-data associated with this object

fn object_data(&self) -> Option<&Arc<dyn ObjectData>>

Access the raw data associated with this object.

fn backend(&self) -> &WeakBackend

Access the backend associated with this object

fn send_request(&self, req: Self::Request) -> Result<(), InvalidId>

Send a request for this object.

fn send_constructor<I: Proxy>(
    &self,
    req: Self::Request,
    data: Arc<dyn ObjectData>
) -> Result<I, InvalidId>

Send a request for this object that creates another object.

fn from_id(conn: &Connection, id: ObjectId) -> Result<Self, InvalidId>

Create an object proxy from its ID

fn inert(backend: WeakBackend) -> Self

Create an inert object proxy

fn parse_event(
    conn: &Connection,
    msg: Message<ObjectId, OwnedFd>
) -> Result<(Self, Self::Event), DispatchError>

Parse a event for this object

fn write_request(
    &self,
    conn: &Connection,
    msg: Self::Request
) -> Result<(Message<ObjectId, RawFd>, Option<(&'static Interface, u32)>), InvalidId>

Serialize a request for this object

fn is_alive(&self) -> bool

Checks if the Wayland object associated with this proxy is still alive

fn downgrade(&self) -> Weak<Self>

Creates a weak handle to this object

impl Eq for WlShmPool