Struct runa_orbiter::objects::compositor::Surface

pub struct Surface<Shell: Shell> { /* private fields */ }

Implementation of the wl_surface interface.

Trait Implementations

impl<Shell: Shell> Debug for Surface<Shell>

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

Formats the value using the given formatter.

impl<S: Shell> MonoObject for Surface<S>

type SingletonState = SurfaceState<<S as Shell>::Token>

A singleton state associated with the object type. This state is associated with the type, so there is only one instance of the state for all objects of the same type. The lifetime of this state is managed by the object store, and it will be dropped when the last object of the type is dropped.

const INTERFACE: &'static str = wl_surface::NAME

The wayland interface implemented by this object.

fn new_singleton_state() -> Self::SingletonState

Create a new instance of the singleton state.

impl<Ctx: Client, S: Shell> Object<Ctx> for Surface<S>where Ctx::ServerContext: HasShell<Shell = S> + HasBuffer<Buffer = S::Buffer>, Ctx::Object: From<Callback>,

type Request<'a> where Ctx: 'a = Request

The type of wayland messages that this object can receive. This is what the dispatch method accepts.

type Error = Error

Error returned by the dispatch method.

type Fut<'a> where Ctx: 'a = impl Future<Output = (Result<(), <Surface<S> as Object<Ctx>>::Error>, usize, usize)> + 'a

The future type returned by the dispatch method.

fn dispatch<'a>( ctx: &'a mut Ctx, object_id: u32, msg: Self::Request<'a> ) -> Self::Fut<'a>

Dispatch a wayland request to this object. Returns a future, that resolves to (Result, usize, usize), which are the result of the request, the number of bytes and file descriptors in the request, respectively.

fn on_disconnect( &mut self, server_ctx: &mut Ctx::ServerContext, state: &mut dyn Any )

A function that will be called when the client disconnects. It should free up allocated resources if any. This function only gets reference to the server context, because:

impl<Ctx: Client, S: Shell> RequestDispatch<Ctx> for Surface<S>where Ctx::ServerContext: HasShell<Shell = S> + HasBuffer<Buffer = S::Buffer>, Ctx::Object: From<Callback>,

type Error = Error

type AttachFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by attach

type CommitFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by commit

type DamageBufferFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by damage_buffer

type DamageFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by damage

type DestroyFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by destroy

type FrameFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by frame

type OffsetFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by offset

type SetBufferScaleFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by set_buffer_scale

type SetBufferTransformFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by set_buffer_transform

type SetInputRegionFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by set_input_region

type SetOpaqueRegionFut<'a> = impl Future<Output = Result<(), <Surface<S> as RequestDispatch<Ctx>>::Error>> + 'a

Type of future returned by set_opaque_region

fn frame(ctx: &mut Ctx, object_id: u32, callback: NewId) -> Self::FrameFut<'_>

request a frame throttling hint

fn attach( ctx: &mut Ctx, object_id: u32, buffer: Object, x: i32, y: i32 ) -> Self::AttachFut<'_>

set the surface contents

fn damage( ctx: &mut Ctx, object_id: u32, _x: i32, _y: i32, _width: i32, _height: i32 ) -> Self::DamageFut<'_>

mark part of the surface damaged

fn damage_buffer( ctx: &mut Ctx, object_id: u32, _x: i32, _y: i32, _width: i32, _height: i32 ) -> Self::DamageBufferFut<'_>

mark part of the surface damaged using buffer coordinates

fn commit(ctx: &mut Ctx, object_id: u32) -> Self::CommitFut<'_>

commit pending surface state

fn set_buffer_scale( ctx: &mut Ctx, object_id: u32, scale: i32 ) -> Self::SetBufferScaleFut<'_>

sets the buffer scaling factor

fn set_input_region( _ctx: &mut Ctx, object_id: u32, region: Object ) -> Self::SetInputRegionFut<'_>

set input region

fn set_opaque_region( _ctx: &mut Ctx, object_id: u32, region: Object ) -> Self::SetOpaqueRegionFut<'_>

set opaque region

fn set_buffer_transform( _ctx: &mut Ctx, object_id: u32, transform: Transform ) -> Self::SetBufferTransformFut<'_>

sets the buffer transformation

fn offset(_ctx: &mut Ctx, object_id: u32, x: i32, y: i32) -> Self::OffsetFut<'_>

set the surface contents offset

fn destroy(ctx: &mut Ctx, object_id: u32) -> Self::DestroyFut<'_>

delete surface