alien-everywhere/shimming/alienkeyboardservice/protocols/wayland/wl_subsurface.py

271 lines
11 KiB
Python
Raw Normal View History

2023-12-20 10:44:46 +00:00
# This file has been autogenerated by the pywayland scanner
# Copyright © 2008-2011 Kristian Høgsberg
# Copyright © 2010-2011 Intel Corporation
# Copyright © 2012-2013 Collabora, Ltd.
#
# 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 (including the
# next paragraph) 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 .wl_surface import WlSurface
class WlSubsurface(Interface):
"""Sub-surface interface to a :class:`~pywayland.protocol.wayland.WlSurface`
An additional interface to a :class:`~pywayland.protocol.wayland.WlSurface`
object, which has been made a sub-surface. A sub-surface has one parent
surface. A sub-surface's size and position are not limited to that of the
parent. Particularly, a sub-surface is not automatically clipped to its
parent's area.
A sub-surface becomes mapped, when a non-NULL
:class:`~pywayland.protocol.wayland.WlBuffer` is applied and the parent
surface is mapped. The order of which one happens first is irrelevant. A
sub-surface is hidden if the parent becomes hidden, or if a NULL
:class:`~pywayland.protocol.wayland.WlBuffer` is applied. These rules apply
recursively through the tree of surfaces.
The behaviour of a :func:`WlSurface.commit()
<pywayland.protocol.wayland.WlSurface.commit>` request on a sub-surface
depends on the sub-surface's mode. The possible modes are synchronized and
desynchronized, see methods :func:`WlSubsurface.set_sync()` and
:func:`WlSubsurface.set_desync()`. Synchronized mode caches the
:class:`~pywayland.protocol.wayland.WlSurface` state to be applied when the
parent's state gets applied, and desynchronized mode applies the pending
:class:`~pywayland.protocol.wayland.WlSurface` state directly. A sub-
surface is initially in the synchronized mode.
Sub-surfaces also have another kind of state, which is managed by
:class:`WlSubsurface` requests, as opposed to
:class:`~pywayland.protocol.wayland.WlSurface` requests. This state
includes the sub-surface position relative to the parent surface
(:func:`WlSubsurface.set_position()`), and the stacking order of the parent
and its sub-surfaces (:func:`WlSubsurface.place_above()` and .place_below).
This state is applied when the parent surface's
:class:`~pywayland.protocol.wayland.WlSurface` state is applied, regardless
of the sub-surface's mode. As the exception, set_sync and set_desync are
effective immediately.
The main surface can be thought to be always in desynchronized mode, since
it does not have a parent in the sub-surfaces sense.
Even if a sub-surface is in desynchronized mode, it will behave as in
synchronized mode, if its parent surface behaves as in synchronized mode.
This rule is applied recursively throughout the tree of surfaces. This
means, that one can set a sub-surface into synchronized mode, and then
assume that all its child and grand-child sub-surfaces are synchronized,
too, without explicitly setting them.
Destroying a sub-surface takes effect immediately. If you need to
synchronize the removal of a sub-surface to the parent surface update,
unmap the sub-surface first by attaching a NULL
:class:`~pywayland.protocol.wayland.WlBuffer`, update parent, and then
destroy the sub-surface.
If the parent :class:`~pywayland.protocol.wayland.WlSurface` object is
destroyed, the sub-surface is unmapped.
"""
name = "wl_subsurface"
version = 1
class error(enum.IntEnum):
bad_surface = 0
class WlSubsurfaceProxy(Proxy[WlSubsurface]):
interface = WlSubsurface
@WlSubsurface.request()
def destroy(self) -> None:
"""Remove sub-surface interface
The sub-surface interface is removed from the
:class:`~pywayland.protocol.wayland.WlSurface` object that was turned
into a sub-surface with a :func:`WlSubcompositor.get_subsurface()
<pywayland.protocol.wayland.WlSubcompositor.get_subsurface>` request.
The wl_surface's association to the parent is deleted. The
:class:`~pywayland.protocol.wayland.WlSurface` is unmapped immediately.
"""
self._marshal(0)
self._destroy()
@WlSubsurface.request(
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
)
def set_position(self, x: int, y: int) -> None:
"""Reposition the sub-surface
This schedules a sub-surface position change. The sub-surface will be
moved so that its origin (top left corner pixel) will be at the
location x, y of the parent surface coordinate system. The coordinates
are not restricted to the parent surface area. Negative values are
allowed.
The scheduled coordinates will take effect whenever the state of the
parent surface is applied. When this happens depends on whether the
parent surface is in synchronized mode or not. See
:func:`WlSubsurface.set_sync()` and :func:`WlSubsurface.set_desync()`
for details.
If more than one set_position request is invoked by the client before
the commit of the parent surface, the position of a new request always
replaces the scheduled position from any previous request.
The initial position is 0, 0.
:param x:
x coordinate in the parent surface
:type x:
`ArgumentType.Int`
:param y:
y coordinate in the parent surface
:type y:
`ArgumentType.Int`
"""
self._marshal(1, x, y)
@WlSubsurface.request(
Argument(ArgumentType.Object, interface=WlSurface),
)
def place_above(self, sibling: WlSurface) -> None:
"""Restack the sub-surface
This sub-surface is taken from the stack, and put back just above the
reference surface, changing the z-order of the sub-surfaces. The
reference surface must be one of the sibling surfaces, or the parent
surface. Using any other surface, including this sub-surface, will
cause a protocol error.
The z-order is double-buffered. Requests are handled in order and
applied immediately to a pending state. The final pending state is
copied to the active state the next time the state of the parent
surface is applied. When this happens depends on whether the parent
surface is in synchronized mode or not. See
:func:`WlSubsurface.set_sync()` and :func:`WlSubsurface.set_desync()`
for details.
A new sub-surface is initially added as the top-most in the stack of
its siblings and parent.
:param sibling:
the reference surface
:type sibling:
:class:`~pywayland.protocol.wayland.WlSurface`
"""
self._marshal(2, sibling)
@WlSubsurface.request(
Argument(ArgumentType.Object, interface=WlSurface),
)
def place_below(self, sibling: WlSurface) -> None:
"""Restack the sub-surface
The sub-surface is placed just below the reference surface. See
:func:`WlSubsurface.place_above()`.
:param sibling:
the reference surface
:type sibling:
:class:`~pywayland.protocol.wayland.WlSurface`
"""
self._marshal(3, sibling)
@WlSubsurface.request()
def set_sync(self) -> None:
"""Set sub-surface to synchronized mode
Change the commit behaviour of the sub-surface to synchronized mode,
also described as the parent dependent mode.
In synchronized mode, :func:`WlSurface.commit()
<pywayland.protocol.wayland.WlSurface.commit>` on a sub-surface will
accumulate the committed state in a cache, but the state will not be
applied and hence will not change the compositor output. The cached
state is applied to the sub-surface immediately after the parent
surface's state is applied. This ensures atomic updates of the parent
and all its synchronized sub-surfaces. Applying the cached state will
invalidate the cache, so further parent surface commits do not
(re-)apply old state.
See :class:`WlSubsurface` for the recursive effect of this mode.
"""
self._marshal(4)
@WlSubsurface.request()
def set_desync(self) -> None:
"""Set sub-surface to desynchronized mode
Change the commit behaviour of the sub-surface to desynchronized mode,
also described as independent or freely running mode.
In desynchronized mode, :func:`WlSurface.commit()
<pywayland.protocol.wayland.WlSurface.commit>` on a sub-surface will
apply the pending state directly, without caching, as happens normally
with a :class:`~pywayland.protocol.wayland.WlSurface`. Calling
:func:`WlSurface.commit()
<pywayland.protocol.wayland.WlSurface.commit>` on the parent surface
has no effect on the sub-surface's
:class:`~pywayland.protocol.wayland.WlSurface` state. This mode allows
a sub-surface to be updated on its own.
If cached state exists when :func:`WlSurface.commit()
<pywayland.protocol.wayland.WlSurface.commit>` is called in
desynchronized mode, the pending state is added to the cached state,
and applied as a whole. This invalidates the cache.
Note: even if a sub-surface is set to desynchronized, a parent sub-
surface may override it to behave as synchronized. For details, see
:class:`WlSubsurface`.
If a surface's parent surface behaves as desynchronized, then the
cached state is applied on set_desync.
"""
self._marshal(5)
class WlSubsurfaceResource(Resource):
interface = WlSubsurface
class WlSubsurfaceGlobal(Global):
interface = WlSubsurface
WlSubsurface._gen_c()
WlSubsurface.proxy_class = WlSubsurfaceProxy
WlSubsurface.resource_class = WlSubsurfaceResource
WlSubsurface.global_class = WlSubsurfaceGlobal