# This file has been autogenerated by the pywayland scanner

# Copyright 2021 Isaac Freund
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

from __future__ import annotations

import enum

from pywayland.protocol_core import Argument, ArgumentType, Global, Interface, Proxy, Resource

from .wayland import WlOutput
from .wayland import WlOutputProxy
from .wayland import WlSurface
from .wayland import WlSurfaceProxy


class ExtSessionLockManagerV1(Interface):
    """Used to lock the session

    This interface is used to request that the session be locked.
    """

    name = "ext_session_lock_manager_v1"
    version = 1


class ExtSessionLockSurfaceV1(Interface):
    """A surface displayed while the session is locked

    The client may use lock surfaces to display a screensaver, render a dialog
    to enter a password and unlock the session, or however else it sees fit.

    On binding this interface the compositor will immediately send the first
    configure event. After making the ack_configure request in response to this
    event the client should attach and commit the first buffer. Committing the
    surface before acking the first configure is a protocol error. Committing
    the surface with a null buffer at any time is a protocol error.

    The compositor is free to handle keyboard/pointer focus for lock surfaces
    however it chooses. A reasonable way to do this would be to give the first
    lock surface created keyboard focus and change keyboard focus if the user
    clicks on other surfaces.
    """

    name = "ext_session_lock_surface_v1"
    version = 1

    class error(enum.IntEnum):
        commit_before_first_ack = 0
        null_buffer = 1
        dimensions_mismatch = 2
        invalid_serial = 3


class ExtSessionLockV1(Interface):
    """Manage lock state and create lock surfaces

    In response to the creation of this object the compositor must send either
    the locked or finished event.

    The locked event indicates that the session is locked. This means that the
    compositor must stop rendering and providing input to normal clients.
    Instead the compositor must 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.

    The locked event must not be sent until a new "locked" frame (either from a
    session lock surface or the compositor blanking the output) has been
    presented on all outputs and no security sensitive normal/unlocked content
    is possibly visible.

    The finished event should be sent immediately on creation of this object if
    the compositor decides that the locked event will not be sent.

    The compositor may wait for the client to create and render session lock
    surfaces before sending the locked event to avoid displaying intermediate
    blank frames. However, it must impose a reasonable time limit if waiting
    and send the locked event as soon as the hard requirements described above
    can be met if the time limit expires. Clients should immediately create
    lock surfaces for all outputs on creation of this object to make this
    possible.

    This behavior of the locked event is required in order to prevent possible
    race conditions with clients that wish to suspend the system or similar
    after locking the session. Without these semantics, clients triggering a
    suspend after receiving the locked event would race with the first "locked"
    frame being presented and normal/unlocked frames might be briefly visible
    as the system is resumed if the suspend operation wins the race.

    If the client dies while the session is locked, the compositor must 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 :class:`ExtSessionLockV1` object and take responsibility for unlocking
    the session, they may even start a new lock client instance automatically.
    """

    name = "ext_session_lock_v1"
    version = 1

    class error(enum.IntEnum):
        invalid_destroy = 0
        invalid_unlock = 1
        role = 2
        duplicate_output = 3
        already_constructed = 4


class ExtSessionLockManagerV1Resource(Resource[ExtSessionLockManagerV1]):
    interface = ExtSessionLockManagerV1


class ExtSessionLockSurfaceV1Resource(Resource[ExtSessionLockSurfaceV1]):
    interface = ExtSessionLockSurfaceV1

    @ExtSessionLockSurfaceV1.event(
        Argument(ArgumentType.Uint),
        Argument(ArgumentType.Uint),
        Argument(ArgumentType.Uint),
    )
    def configure(self, serial: int, width: int, height: int) -> None:
        """The client should resize its surface

        This event is sent once on binding the interface and may be sent again
        at the compositor's discretion, for example if output geometry changes.

        The width and height are in surface-local coordinates and are exact
        requirements. Failing to match these surface dimensions in the next
        commit after acking a configure is a protocol error.

        :param serial:
            serial for use in ack_configure
        :type serial:
            `ArgumentType.Uint`
        :param width:
        :type width:
            `ArgumentType.Uint`
        :param height:
        :type height:
            `ArgumentType.Uint`
        """
        self._post_event(0, serial, width, height)


class ExtSessionLockV1Resource(Resource[ExtSessionLockV1]):
    interface = ExtSessionLockV1

    @ExtSessionLockV1.event()
    def locked(self) -> None:
        """Session successfully locked

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

        The locked event must not be sent until a new "locked" frame has been
        presented on all outputs and no security sensitive normal/unlocked
        content is possibly visible.

        If this event is sent, making the destroy request is a protocol error,
        the lock object must be destroyed using the unlock_and_destroy request.
        """
        self._post_event(0)

    @ExtSessionLockV1.event()
    def finished(self) -> None:
        """The session lock object should be destroyed

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

        This might be sent because there is already another
        :class:`ExtSessionLockV1` 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.

        The finished event should be sent immediately on creation of this
        object if the compositor decides that the locked event will not be
        sent.

        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.
        """
        self._post_event(1)


class ExtSessionLockManagerV1Proxy(Proxy[ExtSessionLockManagerV1]):
    interface = ExtSessionLockManagerV1

    @ExtSessionLockManagerV1.request()
    def destroy(self) -> None:
        """Destroy the session lock manager object

        This informs the compositor that the session lock manager object will
        no longer be used. Existing objects created through this interface
        remain valid.
        """
        self._marshal(0)
        self._destroy()

    @ExtSessionLockManagerV1.request(
        Argument(ArgumentType.NewId, interface=ExtSessionLockV1),
    )
    def lock(self) -> ExtSessionLockV1Proxy:
        """Attempt to lock the session

        This request creates a session lock and asks the compositor to lock the
        session. The compositor will send either the
        :func:`ExtSessionLockV1.locked()
        <pywayland.protocol.ext_session_lock_v1.ExtSessionLockV1.locked>` or
        :func:`ExtSessionLockV1.finished()
        <pywayland.protocol.ext_session_lock_v1.ExtSessionLockV1.finished>`
        event on the created object in response to this request.

        :returns:
            :class:`~pywayland.protocol.ext_session_lock_v1.ExtSessionLockV1`
        """
        id = self._marshal_constructor(1, ExtSessionLockV1)
        return id


class ExtSessionLockSurfaceV1Proxy(Proxy[ExtSessionLockSurfaceV1]):
    interface = ExtSessionLockSurfaceV1

    @ExtSessionLockSurfaceV1.request()
    def destroy(self) -> None:
        """Destroy the lock surface object

        This informs the compositor that the lock surface object will no longer
        be used.

        It is recommended for a lock client to destroy lock surfaces if their
        corresponding :class:`~pywayland.protocol.wayland.WlOutput` global is
        removed.

        If a lock surface on an active output is destroyed before the
        :func:`ExtSessionLockV1.unlock_and_destroy()
        <pywayland.protocol.ext_session_lock_v1.ExtSessionLockV1.unlock_and_destroy>`
        event is sent, the compositor must fall back to rendering a solid
        color.
        """
        self._marshal(0)
        self._destroy()

    @ExtSessionLockSurfaceV1.request(
        Argument(ArgumentType.Uint),
    )
    def ack_configure(self, serial: int) -> None:
        """Ack a configure event

        When a configure event is received, if a client commits the surface in
        response to the configure event, then the client must make an
        ack_configure request sometime before the commit request, passing along
        the serial of the configure event.

        If the client receives multiple configure events before it can respond
        to one, it only has to ack the last configure event.

        A client is not required to commit immediately after sending an
        ack_configure request - it may even ack_configure several times before
        its next surface commit.

        A client may send multiple ack_configure requests before committing,
        but only the last request sent before a commit indicates which
        configure event the client really is responding to.

        Sending an ack_configure request consumes the configure event
        referenced by the given serial, as well as all older configure events
        sent on this object.

        It is a protocol error to issue multiple ack_configure requests
        referencing the same configure event or to issue an ack_configure
        request referencing a configure event older than the last configure
        event acked for a given lock surface.

        :param serial:
            serial from the configure event
        :type serial:
            `ArgumentType.Uint`
        """
        self._marshal(1, serial)


class ExtSessionLockV1Proxy(Proxy[ExtSessionLockV1]):
    interface = ExtSessionLockV1

    @ExtSessionLockV1.request()
    def destroy(self) -> None:
        """Destroy the session lock

        This informs the compositor that the lock object will no longer be
        used. Existing objects created through this interface remain valid.

        After this request is made, lock surfaces created through this object
        should be destroyed by the client as they will no longer be used by the
        compositor.

        It is a protocol error to make this request if the locked event was
        sent, the unlock_and_destroy request must be used instead.
        """
        self._marshal(0)
        self._destroy()

    @ExtSessionLockV1.request(
        Argument(ArgumentType.NewId, interface=ExtSessionLockSurfaceV1),
        Argument(ArgumentType.Object, interface=WlSurface),
        Argument(ArgumentType.Object, interface=WlOutput),
    )
    def get_lock_surface(self, surface: WlSurfaceProxy, output: WlOutputProxy) -> ExtSessionLockSurfaceV1Proxy:
        """Create a lock surface for a given output

        The client is expected to create lock surfaces for all outputs
        currently present and any new outputs as they are advertised. These
        won't be displayed by the compositor unless the lock is successful and
        the locked event is sent.

        Providing a :class:`~pywayland.protocol.wayland.WlSurface` which
        already has a role or already has a buffer attached or committed is a
        protocol error, as is attaching/committing a buffer before the first
        :func:`ExtSessionLockSurfaceV1.configure()
        <pywayland.protocol.ext_session_lock_v1.ExtSessionLockSurfaceV1.configure>`
        event.

        Attempting to create more than one lock surface for a given output is a
        duplicate_output protocol error.

        :param surface:
        :type surface:
            :class:`~pywayland.protocol.wayland.WlSurface`
        :param output:
        :type output:
            :class:`~pywayland.protocol.wayland.WlOutput`
        :returns:
            :class:`~pywayland.protocol.ext_session_lock_v1.ExtSessionLockSurfaceV1`
        """
        id = self._marshal_constructor(1, ExtSessionLockSurfaceV1, surface, output)
        return id

    @ExtSessionLockV1.request()
    def unlock_and_destroy(self) -> None:
        """Unlock the session, destroying the object

        This request indicates that the session should be unlocked, for example
        because the user has entered their password and it has been verified by
        the client.

        This request also informs the compositor that the lock object will no
        longer be used and should be destroyed. Existing objects created
        through this interface remain valid.

        After this request is made, lock surfaces created through this object
        should be destroyed by the client as they will no longer be used by the
        compositor.

        It is a protocol error to make this request if the locked event has not
        been sent. In that case, the lock object must be destroyed using the
        destroy request.

        Note that a correct client that wishes to exit directly after unlocking
        the session must use the :func:`WlDisplay.sync()
        <pywayland.protocol.wayland.WlDisplay.sync>` request to ensure the
        server receives and processes the unlock_and_destroy request. Otherwise
        there is no guarantee that the server has unlocked the session due to
        the asynchronous nature of the Wayland protocol. For example, the
        server might terminate the client with a protocol error before it
        processes the unlock_and_destroy request.
        """
        self._marshal(2)
        self._destroy()


class ExtSessionLockManagerV1Global(Global[ExtSessionLockManagerV1]):
    interface = ExtSessionLockManagerV1


class ExtSessionLockSurfaceV1Global(Global[ExtSessionLockSurfaceV1]):
    interface = ExtSessionLockSurfaceV1


class ExtSessionLockV1Global(Global[ExtSessionLockV1]):
    interface = ExtSessionLockV1


ExtSessionLockManagerV1._gen_c()
ExtSessionLockManagerV1.proxy_class = ExtSessionLockManagerV1Proxy
ExtSessionLockManagerV1.resource_class = ExtSessionLockManagerV1Resource
ExtSessionLockManagerV1.global_class = ExtSessionLockManagerV1Global


ExtSessionLockSurfaceV1._gen_c()
ExtSessionLockSurfaceV1.proxy_class = ExtSessionLockSurfaceV1Proxy
ExtSessionLockSurfaceV1.resource_class = ExtSessionLockSurfaceV1Resource
ExtSessionLockSurfaceV1.global_class = ExtSessionLockSurfaceV1Global


ExtSessionLockV1._gen_c()
ExtSessionLockV1.proxy_class = ExtSessionLockV1Proxy
ExtSessionLockV1.resource_class = ExtSessionLockV1Resource
ExtSessionLockV1.global_class = ExtSessionLockV1Global
