Struct runa_orbiter::objects::compositor::Subsurface

pub struct Subsurface<S: Shell>(_);

Implementation of the wl_subsurface interface

Trait Implementations

impl<S: Shell> Debug for Subsurface<S>

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

Formats the value using the given formatter.

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

type SingletonState = ()

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_subsurface::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 Subsurface<S>where Ctx::ServerContext: HasShell<Shell = S>,

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<(), <Subsurface<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 as Client>::ServerContext, _state: &mut (dyn Any + 'static) )

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 Subsurface<S>where Ctx::ServerContext: HasShell<Shell = S>,

type Error = Error

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

Type of future returned by destroy

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

Type of future returned by place_above

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

Type of future returned by place_below

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

Type of future returned by set_desync

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

Type of future returned by set_position

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

Type of future returned by set_sync

fn set_sync(_ctx: &mut Ctx, object_id: u32) -> Self::SetSyncFut<'_>

set sub-surface to synchronized mode

fn set_desync(_ctx: &mut Ctx, object_id: u32) -> Self::SetDesyncFut<'_>

set sub-surface to desynchronized mode

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

remove sub-surface interface

fn place_above( _ctx: &mut Ctx, object_id: u32, sibling: Object ) -> Self::PlaceAboveFut<'_>

restack the sub-surface

fn place_below( _ctx: &mut Ctx, object_id: u32, sibling: Object ) -> Self::PlaceBelowFut<'_>

restack the sub-surface

fn set_position( ctx: &mut Ctx, object_id: u32, x: i32, y: i32 ) -> Self::SetPositionFut<'_>

reposition the sub-surface