alien-everywhere/shimming/alienkeyboardservice/protocols/xdg_shell/xdg_positioner.py

359 lines
12 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-2013 Kristian Høgsberg
# Copyright © 2013 Rafael Antognolli
# Copyright © 2013 Jasper St. Pierre
# Copyright © 2010-2013 Intel Corporation
# Copyright © 2015-2017 Samsung Electronics Co., Ltd
# Copyright © 2015-2017 Red Hat Inc.
#
# 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,
)
class XdgPositioner(Interface):
"""Child surface positioner
The :class:`XdgPositioner` provides a collection of rules for the placement
of a child surface relative to a parent surface. Rules can be defined to
ensure the child surface remains within the visible area's borders, and to
specify how the child surface changes its position, such as sliding along
an axis, or flipping around a rectangle. These positioner-created rules are
constrained by the requirement that a child surface must intersect with or
be at least partially adjacent to its parent surface.
See the various requests for details about possible rules.
At the time of the request, the compositor makes a copy of the rules
specified by the :class:`XdgPositioner`. Thus, after the request is
complete the :class:`XdgPositioner` object can be destroyed or reused;
further changes to the object will have no effect on previous usages.
For an :class:`XdgPositioner` object to be considered complete, it must
have a non-zero size set by set_size, and a non-zero anchor rectangle set
by set_anchor_rect. Passing an incomplete :class:`XdgPositioner` object
when positioning a surface raises an invalid_positioner error.
"""
name = "xdg_positioner"
version = 5
class error(enum.IntEnum):
invalid_input = 0
class anchor(enum.IntEnum):
none = 0
top = 1
bottom = 2
left = 3
right = 4
top_left = 5
bottom_left = 6
top_right = 7
bottom_right = 8
class gravity(enum.IntEnum):
none = 0
top = 1
bottom = 2
left = 3
right = 4
top_left = 5
bottom_left = 6
top_right = 7
bottom_right = 8
class constraint_adjustment(enum.IntFlag):
none = 0
slide_x = 1
slide_y = 2
flip_x = 4
flip_y = 8
resize_x = 16
resize_y = 32
class XdgPositionerProxy(Proxy[XdgPositioner]):
interface = XdgPositioner
@XdgPositioner.request()
def destroy(self) -> None:
"""Destroy the :class:`XdgPositioner` object
Notify the compositor that the :class:`XdgPositioner` will no longer be
used.
"""
self._marshal(0)
self._destroy()
@XdgPositioner.request(
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
)
def set_size(self, width: int, height: int) -> None:
"""Set the size of the to-be positioned rectangle
Set the size of the surface that is to be positioned with the
positioner object. The size is in surface-local coordinates and
corresponds to the window geometry. See
:func:`XdgSurface.set_window_geometry()
<pywayland.protocol.xdg_shell.XdgSurface.set_window_geometry>`.
If a zero or negative size is set the invalid_input error is raised.
:param width:
width of positioned rectangle
:type width:
`ArgumentType.Int`
:param height:
height of positioned rectangle
:type height:
`ArgumentType.Int`
"""
self._marshal(1, width, height)
@XdgPositioner.request(
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
)
def set_anchor_rect(self, x: int, y: int, width: int, height: int) -> None:
"""Set the anchor rectangle within the parent surface
Specify the anchor rectangle within the parent surface that the child
surface will be placed relative to. The rectangle is relative to the
window geometry as defined by :func:`XdgSurface.set_window_geometry()
<pywayland.protocol.xdg_shell.XdgSurface.set_window_geometry>` of the
parent surface.
When the :class:`XdgPositioner` object is used to position a child
surface, the anchor rectangle may not extend outside the window
geometry of the positioned child's parent surface.
If a negative size is set the invalid_input error is raised.
:param x:
x position of anchor rectangle
:type x:
`ArgumentType.Int`
:param y:
y position of anchor rectangle
:type y:
`ArgumentType.Int`
:param width:
width of anchor rectangle
:type width:
`ArgumentType.Int`
:param height:
height of anchor rectangle
:type height:
`ArgumentType.Int`
"""
self._marshal(2, x, y, width, height)
@XdgPositioner.request(
Argument(ArgumentType.Uint),
)
def set_anchor(self, anchor: int) -> None:
"""Set anchor rectangle anchor
Defines the anchor point for the anchor rectangle. The specified anchor
is used derive an anchor point that the child surface will be
positioned relative to. If a corner anchor is set (e.g. 'top_left' or
'bottom_right'), the anchor point will be at the specified corner;
otherwise, the derived anchor point will be centered on the specified
edge, or in the center of the anchor rectangle if no edge is specified.
:param anchor:
anchor
:type anchor:
`ArgumentType.Uint`
"""
self._marshal(3, anchor)
@XdgPositioner.request(
Argument(ArgumentType.Uint),
)
def set_gravity(self, gravity: int) -> None:
"""Set child surface gravity
Defines in what direction a surface should be positioned, relative to
the anchor point of the parent surface. If a corner gravity is
specified (e.g. 'bottom_right' or 'top_left'), then the child surface
will be placed towards the specified gravity; otherwise, the child
surface will be centered over the anchor point on any axis that had no
gravity specified. If the gravity is not in the gravity enum, an
invalid_input error is raised.
:param gravity:
gravity direction
:type gravity:
`ArgumentType.Uint`
"""
self._marshal(4, gravity)
@XdgPositioner.request(
Argument(ArgumentType.Uint),
)
def set_constraint_adjustment(self, constraint_adjustment: int) -> None:
"""Set the adjustment to be done when constrained
Specify how the window should be positioned if the originally intended
position caused the surface to be constrained, meaning at least
partially outside positioning boundaries set by the compositor. The
adjustment is set by constructing a bitmask describing the adjustment
to be made when the surface is constrained on that axis.
If no bit for one axis is set, the compositor will assume that the
child surface should not change its position on that axis when
constrained.
If more than one bit for one axis is set, the order of how adjustments
are applied is specified in the corresponding adjustment descriptions.
The default adjustment is none.
:param constraint_adjustment:
bit mask of constraint adjustments
:type constraint_adjustment:
`ArgumentType.Uint`
"""
self._marshal(5, constraint_adjustment)
@XdgPositioner.request(
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
)
def set_offset(self, x: int, y: int) -> None:
"""Set surface position offset
Specify the surface position offset relative to the position of the
anchor on the anchor rectangle and the anchor on the surface. For
example if the anchor of the anchor rectangle is at (x, y), the surface
has the gravity bottom|right, and the offset is (ox, oy), the
calculated surface position will be (x + ox, y + oy). The offset
position of the surface is the one used for constraint testing. See
set_constraint_adjustment.
An example use case is placing a popup menu on top of a user interface
element, while aligning the user interface element of the parent
surface with some user interface element placed somewhere in the popup
surface.
:param x:
surface position x offset
:type x:
`ArgumentType.Int`
:param y:
surface position y offset
:type y:
`ArgumentType.Int`
"""
self._marshal(6, x, y)
@XdgPositioner.request(version=3)
def set_reactive(self) -> None:
"""Continuously reconstrain the surface
When set reactive, the surface is reconstrained if the conditions used
for constraining changed, e.g. the parent window moved.
If the conditions changed and the popup was reconstrained, an
:func:`XdgPopup.configure()
<pywayland.protocol.xdg_shell.XdgPopup.configure>` event is sent with
updated geometry, followed by an :func:`XdgSurface.configure()
<pywayland.protocol.xdg_shell.XdgSurface.configure>` event.
"""
self._marshal(7)
@XdgPositioner.request(
Argument(ArgumentType.Int),
Argument(ArgumentType.Int),
version=3,
)
def set_parent_size(self, parent_width: int, parent_height: int) -> None:
"""
Set the parent window geometry the compositor should use when
positioning the popup. The compositor may use this information to
determine the future state the popup should be constrained using. If
this doesn't match the dimension of the parent the popup is eventually
positioned against, the behavior is undefined.
The arguments are given in the surface-local coordinate space.
:param parent_width:
future window geometry width of parent
:type parent_width:
`ArgumentType.Int`
:param parent_height:
future window geometry height of parent
:type parent_height:
`ArgumentType.Int`
"""
self._marshal(8, parent_width, parent_height)
@XdgPositioner.request(
Argument(ArgumentType.Uint),
version=3,
)
def set_parent_configure(self, serial: int) -> None:
"""Set parent configure this is a response to
Set the serial of an :func:`XdgSurface.configure()
<pywayland.protocol.xdg_shell.XdgSurface.configure>` event this
positioner will be used in response to. The compositor may use this
information together with set_parent_size to determine what future
state the popup should be constrained using.
:param serial:
serial of parent configure event
:type serial:
`ArgumentType.Uint`
"""
self._marshal(9, serial)
class XdgPositionerResource(Resource):
interface = XdgPositioner
class XdgPositionerGlobal(Global):
interface = XdgPositioner
XdgPositioner._gen_c()
XdgPositioner.proxy_class = XdgPositionerProxy
XdgPositioner.resource_class = XdgPositionerResource
XdgPositioner.global_class = XdgPositionerGlobal