Struct wayland_protocols::ext::session_lock::v1::server::ext_session_lock_v1::ExtSessionLockV1

pub struct ExtSessionLockV1 { /* private fields */ }

Available on crate features staging and server only.

manage lock state and create lock surfaces

On creation of this object either the locked or finished event will immediately be sent.

The locked event indicates that the session is locked. This means that the compositor should stop rendering and providing input to normal clients. Instead the compositor should blank all outputs with an opaque color such that their normal content is fully hidden.

The only surfaces that should be rendered while the session is locked are the lock surfaces created through this interface and optionally, at the compositor’s discretion, special privileged surfaces such as input methods or portions of desktop shell UIs.

If the client dies while the session is locked, the compositor should not unlock the session in response. It is acceptable for the session to be permanently locked if this happens. The compositor may choose to continue to display the lock surfaces the client had mapped before it died or alternatively fall back to a solid color, this is compositor policy.

Compositors may also allow a secure way to recover the session, the details of this are compositor policy. Compositors may allow a new client to create a ext_session_lock_v1 object and take responsibility for unlocking the session, they may even start a new lock client instance automatically.

See also the Request enum for this interface.

Implementations

impl ExtSessionLockV1

pub fn locked(&self)

session successfully locked

This client is now responsible for displaying graphics while the session is locked and deciding when to unlock the session.

Either this event or the finished event will be sent immediately on creation of this object.

If this event is sent, making the destroy request is a protocol error, the lock object may only be destroyed using the unlock_and_destroy request.

pub fn finished(&self)

the session lock object should be destroyed

The compositor has decided that the session lock should be destroyed. Exactly when this event is sent is compositor policy, but it will never be sent more than once for a given session lock object.

This might be sent because there is already another ext_session_lock_v1 object held by a client, or the compositor has decided to deny the request to lock the session for some other reason. This might also be sent because the compositor implements some alternative, secure way to authenticate and unlock the session.

Either this event or the locked event will be sent exactly once on creation of this object. If the locked event is sent on creation of this object, the finished event may still be sent at some later time in this object’s lifetime, this is compositor policy.

Upon receiving this event, the client should make either the destroy request or the unlock_and_destroy request, depending on whether or not the locked event was received on this object.

Trait Implementations

impl Clone for ExtSessionLockV1

fn clone(&self) -> ExtSessionLockV1

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExtSessionLockV1

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

Formats the value using the given formatter.

impl PartialEq<ExtSessionLockV1> for ExtSessionLockV1

fn eq(&self, other: &ExtSessionLockV1) -> 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 !=.

impl Resource for ExtSessionLockV1

type Request = Request

type Event = Event

fn interface() -> &'static Interface

fn id(&self) -> ObjectId

fn version(&self) -> u32

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

fn object_data(&self) -> Option<&Arc<dyn Any + Send + Sync>>

fn handle(&self) -> &WeakHandle

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

fn send_event(&self, evt: Self::Event) -> Result<(), InvalidId>

fn parse_request(
    conn: &DisplayHandle,
    msg: Message<ObjectId>
) -> Result<(Self, Self::Request), DispatchError>

fn write_event(
    &self,
    conn: &DisplayHandle,
    msg: Self::Event
) -> Result<Message<ObjectId>, InvalidId>

fn client_id(&self) -> Option<ClientId>

fn post_error(&self, code: impl Into<u32>, error: impl Into<String>)

impl Eq for ExtSessionLockV1