capture: an in-process Wayland backend, and the measurements that justify it
The frame server could only capture by running a program once per frame
(grim). That works, but ~95% of a grim frame is waiting -- fork, connect,
handshake, round trip -- not encoding, and grim makes the compositor import
a *new* shared-memory buffer for every single frame.
This adds `--capture wayland[:OUTPUT]`: one long-lived zwlr-screencopy-v1
client per server, with one shm buffer reused for the whole run, capturing
inside the process. Measured here at 1280x720 (spike capture-speed, 200
frames; live re-check on Virtual-1, 60 frames):
grim (subprocess) 117.3 ms/frame 8.1 fps compositor 116.4 ms
grim-rs (Rust crate) 124.6 ms/frame 7.5 fps compositor 123.1 ms
this backend 78.0 ms/frame 13.9 fps compositor 67.5 ms
live, PNG both sides: this 128.5 ms/frame against grim's 389.3 ms (3.0x)
Three findings, each of which shaped the code:
* The win is buffer reuse, not language. grim and grim-rs both hand the
compositor a fresh buffer per frame, which is why their compositor CPU is
nearly double ours. The per-frame allocate-copy-swizzle that grim-rs pays
was measured in isolation at 2.4 ms of *client* time; the rest of its
deficit lands inside the compositor.
* ext-image-copy-capture-v1 is no faster (78.0 vs 77.7 ms) and its
create_frame path appears in a Hyprland segfault stack, so this keeps the
deprecated protocol grim uses. The switch is one constant when that crash
is fixed.
* PNG only, deliberately: PNG is the one encoding this package produces
without a dependency, so --format jpeg is refused rather than publishing a
Hello whose MIME type the frames do not have. A PNG frame is ~2.1 MB
against ~120 KB for JPEG q80, which is why the command backend stays the
default and why a libjpeg-turbo encoder (1.7 ms/frame, measured) is the
obvious follow-up.
The timeout is the load-bearing part of the client: pywayland only reads
events from read()/dispatch(block=True), neither of which takes a timeout,
and the server captures in a worker thread where SIGALRM is unavailable. It
therefore polls the display fd itself, so a compositor that stops answering
produces a CaptureError instead of a capture thread that never returns.
The protocol bindings are vendored under src/hhstream/_protocol/ exactly the
way hhstream_pointer already vendors its two, with regenerate.py recording
where each XML came from. No new dependency: pywayland was already required
by the input driver.
Contract: the new server flag and the two new module options are documented
in docs/CONTRACT.md, and docs/ARCHITECTURE.md's prediction that a native
screencopy client would be "a swap rather than a rewrite" is now the record
of what the swap cost.
Unit suite: 977 passed, 2 skipped, 0 failed (nix build -L .#checks.unit).
The live numbers were taken on this VM against the real compositor.
This commit is contained in:
1 parent
f3ac9ada27
commit
a7d9357b43
37 files changed
+7556
-10
No files matched your search
+22
-2
@@ -87,8 +87,28 @@ Capturing is a separate program (by default `grim`, a wlr-screencopy client) run
|
||||
inside the compositor's session and pointed at stdout. That choice is what keeps
|
||||
`hhstream` free of Wayland and GPU code — the awkward part lives in a tool that
|
||||
already exists and is already tested — and it is why the capture command is a
|
||||
module option: tests inject a fake, and a future backend (a native screencopy
|
||||
client, a hardware encoder) is a command-line swap rather than a rewrite.
|
||||
module option: tests inject a fake, and a different backend is a swap rather than
|
||||
a rewrite.
|
||||
|
||||
That swap has now happened once. `captureBackend = "wayland"` captures in-process
|
||||
(`src/hhstream/wayland_capture.py`): one long-lived `zwlr-screencopy-v1` client
|
||||
with **one shared-memory buffer reused for every frame**, instead of a `grim`
|
||||
process per frame. Measured at 1280×720 over 200 frames, that is ~1.5× the frame
|
||||
rate (78 ms against 117 ms per frame) and — the number that matters on this
|
||||
machine — roughly **half the compositor's CPU per frame** (67 ms against 116 ms),
|
||||
because `grim` makes the compositor import a new buffer every time. It is
|
||||
deliberately the *deprecated* protocol: `ext-image-copy-capture-v1` measured
|
||||
identically and appears in a Hyprland segfault stack (`create_frame` →
|
||||
`CScreenshareFrame::transform`). The price of the in-process route is that the
|
||||
package now carries Wayland protocol bindings of its own (`src/hhstream/_protocol/`,
|
||||
vendored the same way `hhstream_pointer` already vendors its two) and that it can
|
||||
only publish **PNG**, since PNG is the one format it can encode without a
|
||||
dependency. Both costs are why `command` is still the default.
|
||||
|
||||
Comments in the spike that produced these numbers live in the branch's
|
||||
`capture-speed` worktree; the honest caveat that came with them is that this box
|
||||
is saturated by *rendering* whatever is on screen, so the win is in how much room
|
||||
the compositor keeps, not in headroom that did not exist.
|
||||
|
||||
## The hardware requirement, stated plainly
|
||||
|
||||
|
||||
+11
-2
@@ -93,7 +93,9 @@ Namespace: `services.hyprland-headless-stream`
|
||||
| `extraConfig` | str | `""` | extra lines appended to `hyprland.conf` |
|
||||
| `hyprlandPackage` | package | `pkgs.hyprland` | which compositor |
|
||||
| `package` | package | the flake's own build | the frame server/client |
|
||||
| `captureCommand` | list of str | `[ "grim" … ]` | override the capture backend — used by tests |
|
||||
| `captureCommand` | list of str | `[ "grim" … ]` | override the capture *command* — used by tests |
|
||||
| `captureBackend` | `"command"` \| `"wayland"` | `"command"` | capture by command or in-process (`zwlr-screencopy-v1`); `wayland` needs `format = "png"` |
|
||||
| `captureOutput` | str or null | `null` | output to capture by name when `captureBackend = "wayland"`; null = the first one |
|
||||
|
||||
Services (names are part of the contract, tests refer to them):
|
||||
|
||||
@@ -109,7 +111,7 @@ status as the wire format. Exactly this shape, and no others:
|
||||
|
||||
```
|
||||
hhstream-server --socket <socketPath> --fps <frameRate> --format <png|jpeg> \
|
||||
[--capture-command <token> ...]
|
||||
[--capture-command <token> ...] [--capture wayland[:NAME]]
|
||||
```
|
||||
|
||||
- `--format` takes the **short name** (`png`, `jpeg`), not a MIME type; the
|
||||
@@ -119,6 +121,13 @@ hhstream-server --socket <socketPath> --fps <frameRate> --format <png|jpeg> \
|
||||
--capture-command -`. A single shell string cannot carry a leading `-`
|
||||
unambiguously. The `--capture-command=<token>` form is accepted as well, and
|
||||
the two may be mixed. When absent, the server derives `grim -t <format> -`.
|
||||
- `--capture` selects a **named backend** instead of a program: `wayland`
|
||||
captures the compositor's first output in-process, `wayland:NAME` the output
|
||||
Hyprland calls `NAME`. It is exclusive with `--capture-command` (the backend
|
||||
replaces the command; passing both is a caller error). It requires
|
||||
`--format png`, and the server refuses `jpeg` rather than publish a Hello whose
|
||||
MIME type the frames do not have — the in-process client can encode PNG without
|
||||
a dependency and nothing else.
|
||||
- There is deliberately **no** `--width` / `--height`: the Hello reports the
|
||||
captured frame's real size (see above).
|
||||
- The socket's **mode** (0660) is the server's business; its **ownership** is
|
||||
|
||||
+53
-1
@@ -244,7 +244,13 @@ let
|
||||
# shape that survives that without inventing a quoting convention.
|
||||
# `hhstream.server.build_parser()` is still a stub, so this is the one
|
||||
# place the module guesses at the server's CLI rather than reading it.
|
||||
++ lib.concatMap (word: ["--capture-command" word]) cfg.captureCommand;
|
||||
++ (
|
||||
if cfg.captureBackend == "wayland"
|
||||
then ["--capture" (
|
||||
if cfg.captureOutput == null then "wayland" else "wayland:${cfg.captureOutput}"
|
||||
)]
|
||||
else lib.concatMap (word: ["--capture-command" word]) cfg.captureCommand
|
||||
);
|
||||
|
||||
# Shared by both units: a private session, no parent display to nest in.
|
||||
sessionEnvironment = {
|
||||
@@ -398,6 +404,38 @@ in {
|
||||
description = "Command that writes one frame to stdout; overridable for tests.";
|
||||
};
|
||||
|
||||
captureBackend = lib.mkOption {
|
||||
type = lib.types.enum ["command" "wayland"];
|
||||
default = "command";
|
||||
description = ''
|
||||
How frames are obtained: `command` runs {option}`captureCommand` once per
|
||||
frame; `wayland` captures in-process, over the compositor's own
|
||||
`zwlr-screencopy-v1`, with no subprocess at all.
|
||||
|
||||
Measured on a 1280x720 output (spike `capture-speed`, 200 frames), the
|
||||
in-process backend is ~1.5x the frame rate of `grim` and -- the figure
|
||||
that matters on a small machine -- roughly half the *compositor's* CPU
|
||||
per frame, because it reuses one shared-memory buffer instead of making
|
||||
`grim` build a new one per frame.
|
||||
|
||||
It publishes **PNG only**: PNG is the one encoding this package can do
|
||||
without a dependency, so {option}`format` must be `png` when this is set.
|
||||
That is a real trade -- a JPEG frame is ~105-130 KB against ~580 KB for
|
||||
the same frame as PNG -- and it is the reason the default is still
|
||||
`command`.
|
||||
'';
|
||||
};
|
||||
|
||||
captureOutput = lib.mkOption {
|
||||
type = lib.types.nullOr lib.types.str;
|
||||
default = null;
|
||||
description = ''
|
||||
Which output to capture by name (Hyprland's monitor name, e.g.
|
||||
`Virtual-1`) when {option}`captureBackend` is `wayland`. `null` means the
|
||||
compositor's first output, which is what `grim` with no `-o` uses.
|
||||
'';
|
||||
};
|
||||
|
||||
sessions = {
|
||||
enable = lib.mkOption {
|
||||
type = lib.types.bool;
|
||||
@@ -784,6 +822,20 @@ in {
|
||||
assertion = lib.hasPrefix "/" cfg.socketPath;
|
||||
message = "services.hyprland-headless-stream.socketPath must be an absolute path.";
|
||||
}
|
||||
# The Hello carries the frame's MIME type, and the in-process backend can
|
||||
# only produce PNG. A jpeg setting here would publish a format the frames
|
||||
# do not have, so it is refused at build time rather than mis-decoded by
|
||||
# every client at run time.
|
||||
{
|
||||
assertion = cfg.captureBackend != "wayland" || cfg.format == "png";
|
||||
message = ''
|
||||
services.hyprland-headless-stream.captureBackend = "wayland" publishes
|
||||
PNG only, but format = "${cfg.format}".
|
||||
|
||||
JPEG in-process would need an encoder this package does not carry yet.
|
||||
Set format = "png", or go back to captureBackend = "command".
|
||||
'';
|
||||
}
|
||||
# Structural, not cosmetic: see the `runtimeDirName` comment above. The
|
||||
# ceiling exists so the compositor's *event* socket still fits in
|
||||
# `sun_path`, and the symptom of breaking it is silent -- the request
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
"""Vendored Wayland protocol bindings for the frame server.
|
||||
|
||||
Generated, not written by hand: see regenerate.py in this directory for
|
||||
where each XML came from and how to rebuild. The package is the import
|
||||
root, which is why `wayland` sits beside `wlr_screencopy_unstable_v1`.
|
||||
"""
|
||||
@@ -0,0 +1,104 @@
|
||||
"""Regenerate the vendored protocol packages for the frame server.
|
||||
|
||||
nix shell --impure --expr 'with (builtins.getFlake "nixpkgs").legacyPackages.${builtins.currentSystem}; [ (python3.withPackages (p: [ p.pywayland ])) wayland-scanner pkgs.wayland ]' \\
|
||||
--command env HHSTREAM_PROTOCOL_DIR="$(nix eval --raw nixpkgs#hyprland.src)/protocols" \\
|
||||
python3 -m hhstream._protocol.regenerate
|
||||
|
||||
Run by hand after a bump, exactly like ``hhstream_pointer._protocol.regenerate`` —
|
||||
same reasoning, same two moving parts, and the same warning that pywayland's own
|
||||
``python -m pywayland.scanner`` cannot do this on its own: it builds its import
|
||||
map only from the files it is handed, so scanning one XML alone fails on the core
|
||||
interfaces (``KeyError: 'wl_seat'``). Both XMLs go in together.
|
||||
|
||||
**The core** ``wayland.xml`` ships in ``pkgs.wayland-scanner`` — not in
|
||||
``pkgs.wayland``, whose output is ``lib`` only — and not through pkg-config in a
|
||||
plain ``mkShell``, where ``packages`` does not put dev outputs on
|
||||
``PKG_CONFIG_PATH``. That path is named directly in the shell used above.
|
||||
|
||||
**wlr-screencopy** is ``protocols/wlr-screencopy-unstable-v1.xml`` in
|
||||
``pkgs.hyprland.src`` — the compositor's own copy, the same choice
|
||||
``hhstream_pointer`` makes for ``virtual-keyboard-unstable-v1`` and for the same
|
||||
reason: it is the copy that matches the compositor this runs against. It is
|
||||
deprecated upstream in favour of ``ext-image-copy-capture-v1``, and that protocol
|
||||
was measured in the capture-speed spike and deliberately not adopted: it was no
|
||||
faster than this one, and its ``create_frame`` path appears in a Hyprland
|
||||
segfault stack. When that crash is fixed the switch is a one-line change here
|
||||
plus the module's protocol constant.
|
||||
|
||||
The generated modules are relative-import packages rooted at the directory they
|
||||
are written to, so this package directory *is* the root: ``hhstream._protocol``
|
||||
holds ``wayland`` beside ``wlr_screencopy_unstable_v1``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
#: Where this package lives; the generated files land beside this one.
|
||||
ROOT = Path(__file__).resolve().parent
|
||||
|
||||
|
||||
def main() -> int:
|
||||
protocols_dir = os.environ.get("HHSTREAM_PROTOCOL_DIR")
|
||||
if not protocols_dir:
|
||||
print(
|
||||
"HHSTREAM_PROTOCOL_DIR must point at the directory holding "
|
||||
"wlr-screencopy-unstable-v1.xml (see this module's docstring).",
|
||||
file=sys.stderr,
|
||||
)
|
||||
return 2
|
||||
screencopy = Path(protocols_dir) / "wlr-screencopy-unstable-v1.xml"
|
||||
if not screencopy.is_file():
|
||||
print(f"no such file: {screencopy}", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
core = os.environ.get("HHSTREAM_WAYLAND_XML")
|
||||
if not core or not Path(core).is_file():
|
||||
print(
|
||||
"HHSTREAM_WAYLAND_XML must point at wayland.xml "
|
||||
"(in pkgs.wayland-scanner: share/wayland/wayland.xml).",
|
||||
file=sys.stderr,
|
||||
)
|
||||
return 2
|
||||
|
||||
outputs = {name for name in os.listdir(ROOT) if name not in {"__init__.py", "regenerate.py"}}
|
||||
for name in outputs:
|
||||
target = ROOT / name
|
||||
if target.is_dir():
|
||||
for child in target.iterdir():
|
||||
child.unlink()
|
||||
target.rmdir()
|
||||
else:
|
||||
target.unlink()
|
||||
|
||||
result = subprocess.run(
|
||||
[sys.executable, "-m", "pywayland.scanner", "-o", str(ROOT), "-i", core, str(screencopy)],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
sys.stdout.write(result.stdout)
|
||||
sys.stderr.write(result.stderr)
|
||||
if result.returncode != 0:
|
||||
return result.returncode
|
||||
|
||||
# The packages the scanner writes need no __init__.py to import as namespace
|
||||
# packages, but the *relative* imports between them require the parent to be a
|
||||
# real package, so this one is created if it is missing.
|
||||
init = ROOT / "__init__.py"
|
||||
if not init.exists():
|
||||
init.write_text(
|
||||
'"""Vendored Wayland protocol bindings for the frame server.\n\n'
|
||||
"Generated, not written by hand: see regenerate.py in this directory for\n"
|
||||
"where each XML came from and how to rebuild. The package is the import\n"
|
||||
"root, which is why `wayland` sits beside `wlr_screencopy_unstable_v1`.\n"
|
||||
'"""\n'
|
||||
)
|
||||
print(f"regenerated under {ROOT}: {sorted(name for name in os.listdir(ROOT) if not name.endswith('.py'))}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,50 @@
|
||||
# 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 .wl_buffer import WlBuffer # noqa: F401
|
||||
from .wl_callback import WlCallback # noqa: F401
|
||||
from .wl_compositor import WlCompositor # noqa: F401
|
||||
from .wl_data_device import WlDataDevice # noqa: F401
|
||||
from .wl_data_device_manager import WlDataDeviceManager # noqa: F401
|
||||
from .wl_data_offer import WlDataOffer # noqa: F401
|
||||
from .wl_data_source import WlDataSource # noqa: F401
|
||||
from .wl_display import WlDisplay # noqa: F401
|
||||
from .wl_fixes import WlFixes # noqa: F401
|
||||
from .wl_keyboard import WlKeyboard # noqa: F401
|
||||
from .wl_output import WlOutput # noqa: F401
|
||||
from .wl_pointer import WlPointer # noqa: F401
|
||||
from .wl_region import WlRegion # noqa: F401
|
||||
from .wl_registry import WlRegistry # noqa: F401
|
||||
from .wl_seat import WlSeat # noqa: F401
|
||||
from .wl_shell import WlShell # noqa: F401
|
||||
from .wl_shell_surface import WlShellSurface # noqa: F401
|
||||
from .wl_shm import WlShm # noqa: F401
|
||||
from .wl_shm_pool import WlShmPool # noqa: F401
|
||||
from .wl_subcompositor import WlSubcompositor # noqa: F401
|
||||
from .wl_subsurface import WlSubsurface # noqa: F401
|
||||
from .wl_surface import WlSurface # noqa: F401
|
||||
from .wl_touch import WlTouch # noqa: F401
|
||||
@@ -0,0 +1,112 @@
|
||||
# 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
|
||||
|
||||
from pywayland.protocol_core import Global, Interface, Proxy, Resource
|
||||
|
||||
|
||||
class WlBuffer(Interface):
|
||||
"""Content for a :class:`~pywayland.protocol.wayland.WlSurface`
|
||||
|
||||
A buffer provides the content for a
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`. Buffers are created through
|
||||
factory interfaces such as :class:`~pywayland.protocol.wayland.WlShm`,
|
||||
wp_linux_buffer_params (from the linux-dmabuf protocol extension) or
|
||||
similar. It has a width and a height and can be attached to a
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`, but the mechanism by which
|
||||
a client provides and updates the contents is defined by the buffer factory
|
||||
interface.
|
||||
|
||||
Color channels are assumed to be electrical rather than optical (in other
|
||||
words, encoded with a transfer function) unless otherwise specified. If the
|
||||
buffer uses a format that has an alpha channel, the alpha channel is
|
||||
assumed to be premultiplied into the electrical color channel values (after
|
||||
transfer function encoding) unless otherwise specified.
|
||||
|
||||
Note, because :class:`WlBuffer` objects are created from multiple
|
||||
independent factory interfaces, the :class:`WlBuffer` interface is frozen
|
||||
at version 1.
|
||||
"""
|
||||
|
||||
name = "wl_buffer"
|
||||
version = 1
|
||||
|
||||
|
||||
class WlBufferProxy(Proxy[WlBuffer]):
|
||||
interface = WlBuffer
|
||||
|
||||
@WlBuffer.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroy a buffer
|
||||
|
||||
Destroy a buffer. If and how you need to release the backing storage is
|
||||
defined by the buffer factory interface.
|
||||
|
||||
For possible side-effects to a surface, see :func:`WlSurface.attach()
|
||||
<pywayland.protocol.wayland.WlSurface.attach>`.
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlBufferResource(Resource):
|
||||
interface = WlBuffer
|
||||
|
||||
@WlBuffer.event()
|
||||
def release(self) -> None:
|
||||
"""Compositor releases buffer
|
||||
|
||||
Sent when this :class:`WlBuffer` is no longer used by the compositor.
|
||||
|
||||
For more information on when release events may or may not be sent, and
|
||||
what consequences it has, please see the description of
|
||||
:func:`WlSurface.attach()
|
||||
<pywayland.protocol.wayland.WlSurface.attach>`.
|
||||
|
||||
If a client receives a release event before the frame callback
|
||||
requested in the same :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` that attaches this
|
||||
:class:`WlBuffer` to a surface, then the client is immediately free to
|
||||
reuse the buffer and its backing storage, and does not need a second
|
||||
buffer for the next surface content update. Typically this is possible,
|
||||
when the compositor maintains a copy of the
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` contents, e.g. as a GL
|
||||
texture. This is an important optimization for GL(ES) compositors with
|
||||
:class:`~pywayland.protocol.wayland.WlShm` clients.
|
||||
"""
|
||||
self._post_event(0)
|
||||
|
||||
|
||||
class WlBufferGlobal(Global):
|
||||
interface = WlBuffer
|
||||
|
||||
|
||||
WlBuffer._gen_c()
|
||||
WlBuffer.proxy_class = WlBufferProxy
|
||||
WlBuffer.resource_class = WlBufferResource
|
||||
WlBuffer.global_class = WlBufferGlobal
|
||||
@@ -0,0 +1,85 @@
|
||||
# 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
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
|
||||
class WlCallback(Interface):
|
||||
"""Callback object
|
||||
|
||||
Clients can handle the 'done' event to get notified when the related
|
||||
request is done.
|
||||
|
||||
Note, because :class:`WlCallback` objects are created from multiple
|
||||
independent factory interfaces, the :class:`WlCallback` interface is frozen
|
||||
at version 1.
|
||||
"""
|
||||
|
||||
name = "wl_callback"
|
||||
version = 1
|
||||
|
||||
|
||||
class WlCallbackProxy(Proxy[WlCallback]):
|
||||
interface = WlCallback
|
||||
|
||||
|
||||
class WlCallbackResource(Resource):
|
||||
interface = WlCallback
|
||||
|
||||
@WlCallback.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def done(self, callback_data: int) -> None:
|
||||
"""Done event
|
||||
|
||||
Notify the client when the related request is done.
|
||||
|
||||
:param callback_data:
|
||||
request-specific data for the callback
|
||||
:type callback_data:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, callback_data)
|
||||
|
||||
|
||||
class WlCallbackGlobal(Global):
|
||||
interface = WlCallback
|
||||
|
||||
|
||||
WlCallback._gen_c()
|
||||
WlCallback.proxy_class = WlCallbackProxy
|
||||
WlCallback.resource_class = WlCallbackResource
|
||||
WlCallback.global_class = WlCallbackGlobal
|
||||
@@ -0,0 +1,108 @@
|
||||
# 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
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
from .wl_region import WlRegion
|
||||
from .wl_surface import WlSurface
|
||||
|
||||
|
||||
class WlCompositor(Interface):
|
||||
"""The compositor singleton
|
||||
|
||||
A compositor. This object is a singleton global. The compositor is in
|
||||
charge of combining the contents of multiple surfaces into one displayable
|
||||
output.
|
||||
"""
|
||||
|
||||
name = "wl_compositor"
|
||||
version = 7
|
||||
|
||||
|
||||
class WlCompositorProxy(Proxy[WlCompositor]):
|
||||
interface = WlCompositor
|
||||
|
||||
@WlCompositor.request(
|
||||
Argument(ArgumentType.NewId, interface=WlSurface),
|
||||
)
|
||||
def create_surface(self) -> Proxy[WlSurface]:
|
||||
"""Create new surface
|
||||
|
||||
Ask the compositor to create a new surface.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` -- the new surface
|
||||
"""
|
||||
id = self._marshal_constructor(0, WlSurface)
|
||||
return id
|
||||
|
||||
@WlCompositor.request(
|
||||
Argument(ArgumentType.NewId, interface=WlRegion),
|
||||
)
|
||||
def create_region(self) -> Proxy[WlRegion]:
|
||||
"""Create new region
|
||||
|
||||
Ask the compositor to create a new region.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlRegion` -- the new region
|
||||
"""
|
||||
id = self._marshal_constructor(1, WlRegion)
|
||||
return id
|
||||
|
||||
@WlCompositor.request(version=7)
|
||||
def release(self) -> None:
|
||||
"""Destroy :class:`WlCompositor`
|
||||
|
||||
This request destroys the :class:`WlCompositor`. This has no effect on
|
||||
any other objects.
|
||||
"""
|
||||
self._marshal(2)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlCompositorResource(Resource):
|
||||
interface = WlCompositor
|
||||
|
||||
|
||||
class WlCompositorGlobal(Global):
|
||||
interface = WlCompositor
|
||||
|
||||
|
||||
WlCompositor._gen_c()
|
||||
WlCompositor.proxy_class = WlCompositorProxy
|
||||
WlCompositor.resource_class = WlCompositorResource
|
||||
WlCompositor.global_class = WlCompositorGlobal
|
||||
@@ -0,0 +1,320 @@
|
||||
# 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_data_offer import WlDataOffer
|
||||
from .wl_data_source import WlDataSource
|
||||
from .wl_surface import WlSurface
|
||||
|
||||
|
||||
class WlDataDevice(Interface):
|
||||
"""Data transfer device
|
||||
|
||||
There is one :class:`WlDataDevice` per seat which can be obtained from the
|
||||
global :class:`~pywayland.protocol.wayland.WlDataDeviceManager` singleton.
|
||||
|
||||
A :class:`WlDataDevice` provides access to inter-client data transfer
|
||||
mechanisms such as copy-and-paste and drag-and-drop.
|
||||
"""
|
||||
|
||||
name = "wl_data_device"
|
||||
version = 4
|
||||
|
||||
class error(enum.IntEnum):
|
||||
role = 0
|
||||
used_source = 1
|
||||
|
||||
|
||||
class WlDataDeviceProxy(Proxy[WlDataDevice]):
|
||||
interface = WlDataDevice
|
||||
|
||||
@WlDataDevice.request(
|
||||
Argument(ArgumentType.Object, interface=WlDataSource, nullable=True),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Object, interface=WlSurface, nullable=True),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def start_drag(self, source: WlDataSource | None, origin: WlSurface, icon: WlSurface | None, serial: int) -> None:
|
||||
"""Start drag-and-drop operation
|
||||
|
||||
This request asks the compositor to start a drag-and-drop operation on
|
||||
behalf of the client.
|
||||
|
||||
The source argument is the data source that provides the data for the
|
||||
eventual data transfer. If source is NULL, enter, leave and motion
|
||||
events are sent only to the client that initiated the drag and the
|
||||
client is expected to handle the data passing internally. If source is
|
||||
destroyed, the drag-and-drop session will be cancelled.
|
||||
|
||||
The origin surface is the surface where the drag originates and the
|
||||
client must have an active implicit grab that matches the serial.
|
||||
|
||||
The icon surface is an optional (can be NULL) surface that provides an
|
||||
icon to be moved around with the cursor. Initially, the top-left
|
||||
corner of the icon surface is placed at the cursor hotspot, but
|
||||
subsequent :func:`WlSurface.offset()
|
||||
<pywayland.protocol.wayland.WlSurface.offset>` requests can move the
|
||||
relative position. Attach requests must be confirmed with
|
||||
:func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` as usual. The icon
|
||||
surface is given the role of a drag-and-drop icon. If the icon surface
|
||||
already has another role, it raises a protocol error.
|
||||
|
||||
The input region is ignored for wl_surfaces with the role of a drag-
|
||||
and-drop icon.
|
||||
|
||||
The given source may not be used in any further set_selection or
|
||||
start_drag requests. Attempting to reuse a previously-used source may
|
||||
send a used_source error.
|
||||
|
||||
:param source:
|
||||
data source for the eventual transfer
|
||||
:type source:
|
||||
:class:`~pywayland.protocol.wayland.WlDataSource` or `None`
|
||||
:param origin:
|
||||
surface where the drag originates
|
||||
:type origin:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param icon:
|
||||
drag-and-drop icon surface
|
||||
:type icon:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` or `None`
|
||||
:param serial:
|
||||
serial number of the implicit grab on the origin
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(0, source, origin, icon, serial)
|
||||
|
||||
@WlDataDevice.request(
|
||||
Argument(ArgumentType.Object, interface=WlDataSource, nullable=True),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def set_selection(self, source: WlDataSource | None, serial: int) -> None:
|
||||
"""Copy data to the selection
|
||||
|
||||
This request asks the compositor to set the selection to the data from
|
||||
the source on behalf of the client.
|
||||
|
||||
To unset the selection, set the source to NULL.
|
||||
|
||||
The given source may not be used in any further set_selection or
|
||||
start_drag requests. Attempting to reuse a previously-used source may
|
||||
send a used_source error.
|
||||
|
||||
:param source:
|
||||
data source for the selection
|
||||
:type source:
|
||||
:class:`~pywayland.protocol.wayland.WlDataSource` or `None`
|
||||
:param serial:
|
||||
serial number of the event that triggered this request
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(1, source, serial)
|
||||
|
||||
@WlDataDevice.request(version=2)
|
||||
def release(self) -> None:
|
||||
"""Destroy data device
|
||||
|
||||
This request destroys the data device.
|
||||
"""
|
||||
self._marshal(2)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlDataDeviceResource(Resource):
|
||||
interface = WlDataDevice
|
||||
|
||||
@WlDataDevice.event(
|
||||
Argument(ArgumentType.NewId, interface=WlDataOffer),
|
||||
)
|
||||
def data_offer(self, id: WlDataOffer) -> None:
|
||||
"""Introduce a new :class:`~pywayland.protocol.wayland.WlDataOffer`
|
||||
|
||||
The data_offer event introduces a new
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer` object, which will
|
||||
subsequently be used in either the data_device.enter event (for drag-
|
||||
and-drop) or the data_device.selection event (for selections).
|
||||
Immediately following the data_device.data_offer event, the new
|
||||
data_offer object will send out data_offer.offer events to describe the
|
||||
mime types it offers.
|
||||
|
||||
:param id:
|
||||
the new data_offer object
|
||||
:type id:
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer`
|
||||
"""
|
||||
self._post_event(0, id)
|
||||
|
||||
@WlDataDevice.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Object, interface=WlDataOffer, nullable=True),
|
||||
)
|
||||
def enter(self, serial: int, surface: WlSurface, x: float, y: float, id: WlDataOffer | None) -> None:
|
||||
"""Initiate drag-and-drop session
|
||||
|
||||
This event is sent when an active drag-and-drop pointer enters a
|
||||
surface owned by the client. The position of the pointer at enter time
|
||||
is provided by the x and y arguments, in surface-local coordinates.
|
||||
|
||||
:param serial:
|
||||
serial number of the enter event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
client surface entered
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Fixed`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Fixed`
|
||||
:param id:
|
||||
source data_offer object
|
||||
:type id:
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer` or `None`
|
||||
"""
|
||||
self._post_event(1, serial, surface, x, y, id)
|
||||
|
||||
@WlDataDevice.event()
|
||||
def leave(self) -> None:
|
||||
"""End drag-and-drop session
|
||||
|
||||
This event is sent when the drag-and-drop pointer leaves the surface
|
||||
and the session ends. The client must destroy the
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer` introduced at enter
|
||||
time at this point.
|
||||
"""
|
||||
self._post_event(2)
|
||||
|
||||
@WlDataDevice.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
)
|
||||
def motion(self, time: int, x: float, y: float) -> None:
|
||||
"""Drag-and-drop session motion
|
||||
|
||||
This event is sent when the drag-and-drop pointer moves within the
|
||||
currently focused surface. The new position of the pointer is provided
|
||||
by the x and y arguments, in surface-local coordinates.
|
||||
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Fixed`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(3, time, x, y)
|
||||
|
||||
@WlDataDevice.event()
|
||||
def drop(self) -> None:
|
||||
"""End drag-and-drop session successfully
|
||||
|
||||
The event is sent when a drag-and-drop operation is ended because the
|
||||
implicit grab is removed.
|
||||
|
||||
The drag-and-drop destination is expected to honor the last action
|
||||
received through :func:`WlDataOffer.action()
|
||||
<pywayland.protocol.wayland.WlDataOffer.action>`, if the resulting
|
||||
action is "copy" or "move", the destination can still perform
|
||||
:func:`WlDataOffer.receive()
|
||||
<pywayland.protocol.wayland.WlDataOffer.receive>` requests, and is
|
||||
expected to end all transfers with a :func:`WlDataOffer.finish()
|
||||
<pywayland.protocol.wayland.WlDataOffer.finish>` request.
|
||||
|
||||
If the resulting action is "ask", the action will not be considered
|
||||
final. The drag-and-drop destination is expected to perform one last
|
||||
:func:`WlDataOffer.set_actions()
|
||||
<pywayland.protocol.wayland.WlDataOffer.set_actions>` request, or
|
||||
:func:`WlDataOffer.destroy()
|
||||
<pywayland.protocol.wayland.WlDataOffer.destroy>` in order to cancel
|
||||
the operation.
|
||||
"""
|
||||
self._post_event(4)
|
||||
|
||||
@WlDataDevice.event(
|
||||
Argument(ArgumentType.Object, interface=WlDataOffer, nullable=True),
|
||||
)
|
||||
def selection(self, id: WlDataOffer | None) -> None:
|
||||
"""Advertise new selection
|
||||
|
||||
The selection event is sent out to notify the client of a new
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer` for the selection for
|
||||
this device. The data_device.data_offer and the data_offer.offer
|
||||
events are sent out immediately before this event to introduce the data
|
||||
offer object. The selection event is sent to a client immediately
|
||||
before receiving keyboard focus and when a new selection is set while
|
||||
the client has keyboard focus. The data_offer is valid until a new
|
||||
data_offer or NULL is received or until the client loses keyboard
|
||||
focus. Switching surface with keyboard focus within the same client
|
||||
doesn't mean a new selection will be sent. The client must destroy the
|
||||
previous selection data_offer, if any, upon receiving this event.
|
||||
|
||||
:param id:
|
||||
selection data_offer object
|
||||
:type id:
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer` or `None`
|
||||
"""
|
||||
self._post_event(5, id)
|
||||
|
||||
|
||||
class WlDataDeviceGlobal(Global):
|
||||
interface = WlDataDevice
|
||||
|
||||
|
||||
WlDataDevice._gen_c()
|
||||
WlDataDevice.proxy_class = WlDataDeviceProxy
|
||||
WlDataDevice.resource_class = WlDataDeviceResource
|
||||
WlDataDevice.global_class = WlDataDeviceGlobal
|
||||
@@ -0,0 +1,136 @@
|
||||
# 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_data_device import WlDataDevice
|
||||
from .wl_data_source import WlDataSource
|
||||
from .wl_seat import WlSeat
|
||||
|
||||
|
||||
class WlDataDeviceManager(Interface):
|
||||
"""Data transfer interface
|
||||
|
||||
The :class:`WlDataDeviceManager` is a singleton global object that provides
|
||||
access to inter-client data transfer mechanisms such as copy-and-paste and
|
||||
drag-and-drop. These mechanisms are tied to a
|
||||
:class:`~pywayland.protocol.wayland.WlSeat` and this interface lets a
|
||||
client get a :class:`~pywayland.protocol.wayland.WlDataDevice`
|
||||
corresponding to a :class:`~pywayland.protocol.wayland.WlSeat`.
|
||||
|
||||
Depending on the version bound, the objects created from the bound
|
||||
:class:`WlDataDeviceManager` object will have different requirements for
|
||||
functioning properly. See :func:`WlDataSource.set_actions()
|
||||
<pywayland.protocol.wayland.WlDataSource.set_actions>`,
|
||||
:func:`WlDataOffer.accept()
|
||||
<pywayland.protocol.wayland.WlDataOffer.accept>` and
|
||||
:func:`WlDataOffer.finish()
|
||||
<pywayland.protocol.wayland.WlDataOffer.finish>` for details.
|
||||
"""
|
||||
|
||||
name = "wl_data_device_manager"
|
||||
version = 4
|
||||
|
||||
class dnd_action(enum.IntFlag):
|
||||
none = 0
|
||||
copy = 1
|
||||
move = 2
|
||||
ask = 4
|
||||
|
||||
|
||||
class WlDataDeviceManagerProxy(Proxy[WlDataDeviceManager]):
|
||||
interface = WlDataDeviceManager
|
||||
|
||||
@WlDataDeviceManager.request(
|
||||
Argument(ArgumentType.NewId, interface=WlDataSource),
|
||||
)
|
||||
def create_data_source(self) -> Proxy[WlDataSource]:
|
||||
"""Create a new data source
|
||||
|
||||
Create a new data source.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlDataSource` -- data source to
|
||||
create
|
||||
"""
|
||||
id = self._marshal_constructor(0, WlDataSource)
|
||||
return id
|
||||
|
||||
@WlDataDeviceManager.request(
|
||||
Argument(ArgumentType.NewId, interface=WlDataDevice),
|
||||
Argument(ArgumentType.Object, interface=WlSeat),
|
||||
)
|
||||
def get_data_device(self, seat: WlSeat) -> Proxy[WlDataDevice]:
|
||||
"""Create a new data device
|
||||
|
||||
Create a new data device for a given seat.
|
||||
|
||||
:param seat:
|
||||
seat associated with the data device
|
||||
:type seat:
|
||||
:class:`~pywayland.protocol.wayland.WlSeat`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlDataDevice` -- data device to
|
||||
create
|
||||
"""
|
||||
id = self._marshal_constructor(1, WlDataDevice, seat)
|
||||
return id
|
||||
|
||||
@WlDataDeviceManager.request(version=4)
|
||||
def release(self) -> None:
|
||||
"""Destroy :class:`WlDataDeviceManager`
|
||||
|
||||
This request destroys the :class:`WlDataDeviceManager`. This has no
|
||||
effect on any other objects.
|
||||
"""
|
||||
self._marshal(2)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlDataDeviceManagerResource(Resource):
|
||||
interface = WlDataDeviceManager
|
||||
|
||||
|
||||
class WlDataDeviceManagerGlobal(Global):
|
||||
interface = WlDataDeviceManager
|
||||
|
||||
|
||||
WlDataDeviceManager._gen_c()
|
||||
WlDataDeviceManager.proxy_class = WlDataDeviceManagerProxy
|
||||
WlDataDeviceManager.resource_class = WlDataDeviceManagerResource
|
||||
WlDataDeviceManager.global_class = WlDataDeviceManagerGlobal
|
||||
@@ -0,0 +1,325 @@
|
||||
# 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,
|
||||
)
|
||||
|
||||
|
||||
class WlDataOffer(Interface):
|
||||
"""Offer to transfer data
|
||||
|
||||
A :class:`WlDataOffer` represents a piece of data offered for transfer by
|
||||
another client (the source client). It is used by the copy-and-paste and
|
||||
drag-and-drop mechanisms. The offer describes the different mime types
|
||||
that the data can be converted to and provides the mechanism for
|
||||
transferring the data directly from the source client.
|
||||
"""
|
||||
|
||||
name = "wl_data_offer"
|
||||
version = 4
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_finish = 0
|
||||
invalid_action_mask = 1
|
||||
invalid_action = 2
|
||||
invalid_offer = 3
|
||||
|
||||
|
||||
class WlDataOfferProxy(Proxy[WlDataOffer]):
|
||||
interface = WlDataOffer
|
||||
|
||||
@WlDataOffer.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.String, nullable=True),
|
||||
)
|
||||
def accept(self, serial: int, mime_type: str | None) -> None:
|
||||
"""Accept one of the offered mime types
|
||||
|
||||
Indicate that the client can accept the given mime type, or NULL for
|
||||
not accepted.
|
||||
|
||||
For objects of version 2 or older, this request is used by the client
|
||||
to give feedback whether the client can receive the given mime type, or
|
||||
NULL if none is accepted; the feedback does not determine whether the
|
||||
drag-and-drop operation succeeds or not.
|
||||
|
||||
For objects of version 3 or newer, this request determines the final
|
||||
result of the drag-and-drop operation. If the end result is that no
|
||||
mime types were accepted, the drag-and-drop operation will be cancelled
|
||||
and the corresponding drag source will receive
|
||||
:func:`WlDataSource.cancelled()
|
||||
<pywayland.protocol.wayland.WlDataSource.cancelled>`. Clients may still
|
||||
use this event in conjunction with :func:`WlDataSource.action()
|
||||
<pywayland.protocol.wayland.WlDataSource.action>` for feedback.
|
||||
|
||||
:param serial:
|
||||
serial number of the accept request
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param mime_type:
|
||||
mime type accepted by the client
|
||||
:type mime_type:
|
||||
`ArgumentType.String` or `None`
|
||||
"""
|
||||
self._marshal(0, serial, mime_type)
|
||||
|
||||
@WlDataOffer.request(
|
||||
Argument(ArgumentType.String),
|
||||
Argument(ArgumentType.FileDescriptor),
|
||||
)
|
||||
def receive(self, mime_type: str, fd: int) -> None:
|
||||
"""Request that the data is transferred
|
||||
|
||||
To transfer the offered data, the client issues this request and
|
||||
indicates the mime type it wants to receive. The transfer happens
|
||||
through the passed file descriptor (typically created with the pipe
|
||||
system call). The source client writes the data in the mime type
|
||||
representation requested and then closes the file descriptor.
|
||||
|
||||
The receiving client reads from the read end of the pipe until EOF and
|
||||
then closes its end, at which point the transfer is complete.
|
||||
|
||||
This request may happen multiple times for different mime types, both
|
||||
before and after :func:`WlDataDevice.drop()
|
||||
<pywayland.protocol.wayland.WlDataDevice.drop>`. Drag-and-drop
|
||||
destination clients may preemptively fetch data or examine it more
|
||||
closely to determine acceptance.
|
||||
|
||||
:param mime_type:
|
||||
mime type desired by receiver
|
||||
:type mime_type:
|
||||
`ArgumentType.String`
|
||||
:param fd:
|
||||
file descriptor for data transfer
|
||||
:type fd:
|
||||
`ArgumentType.FileDescriptor`
|
||||
"""
|
||||
self._marshal(1, mime_type, fd)
|
||||
|
||||
@WlDataOffer.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroy data offer
|
||||
|
||||
Destroy the data offer.
|
||||
"""
|
||||
self._marshal(2)
|
||||
self._destroy()
|
||||
|
||||
@WlDataOffer.request(version=3)
|
||||
def finish(self) -> None:
|
||||
"""The offer will no longer be used
|
||||
|
||||
Notifies the compositor that the drag destination successfully finished
|
||||
the drag-and-drop operation.
|
||||
|
||||
Upon receiving this request, the compositor will emit
|
||||
:func:`WlDataSource.dnd_finished()
|
||||
<pywayland.protocol.wayland.WlDataSource.dnd_finished>` on the drag
|
||||
source client.
|
||||
|
||||
It is a client error to perform other requests than
|
||||
:func:`WlDataOffer.destroy()` after this one. It is also an error to
|
||||
perform this request after a NULL mime type has been set in
|
||||
:func:`WlDataOffer.accept()` or no action was received through
|
||||
:func:`WlDataOffer.action()`.
|
||||
|
||||
If :func:`WlDataOffer.finish()` request is received for a non drag and
|
||||
drop operation, the invalid_finish protocol error is raised.
|
||||
"""
|
||||
self._marshal(3)
|
||||
|
||||
@WlDataOffer.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
version=3,
|
||||
)
|
||||
def set_actions(self, dnd_actions: int, preferred_action: int) -> None:
|
||||
"""Set the available/preferred drag-and-drop actions
|
||||
|
||||
Sets the actions that the destination side client supports for this
|
||||
operation. This request may trigger the emission of
|
||||
:func:`WlDataSource.action()
|
||||
<pywayland.protocol.wayland.WlDataSource.action>` and
|
||||
:func:`WlDataOffer.action()` events if the compositor needs to change
|
||||
the selected action.
|
||||
|
||||
This request can be called multiple times throughout the drag-and-drop
|
||||
operation, typically in response to :func:`WlDataDevice.enter()
|
||||
<pywayland.protocol.wayland.WlDataDevice.enter>` or
|
||||
:func:`WlDataDevice.motion()
|
||||
<pywayland.protocol.wayland.WlDataDevice.motion>` events.
|
||||
|
||||
This request determines the final result of the drag-and-drop
|
||||
operation. If the end result is that no action is accepted, the drag
|
||||
source will receive :func:`WlDataSource.cancelled()
|
||||
<pywayland.protocol.wayland.WlDataSource.cancelled>`.
|
||||
|
||||
The dnd_actions argument must contain only values expressed in the
|
||||
:func:`WlDataDeviceManager.dnd_actions()
|
||||
<pywayland.protocol.wayland.WlDataDeviceManager.dnd_actions>` enum, and
|
||||
the preferred_action argument must only contain one of those values
|
||||
set, otherwise it will result in a protocol error.
|
||||
|
||||
While managing an "ask" action, the destination drag-and-drop client
|
||||
may perform further :func:`WlDataOffer.receive()` requests, and is
|
||||
expected to perform one last :func:`WlDataOffer.set_actions()` request
|
||||
with a preferred action other than "ask" (and optionally
|
||||
:func:`WlDataOffer.accept()`) before requesting
|
||||
:func:`WlDataOffer.finish()`, in order to convey the action selected by
|
||||
the user. If the preferred action is not in the
|
||||
:func:`WlDataOffer.source_actions()` mask, an error will be raised.
|
||||
|
||||
If the "ask" action is dismissed (e.g. user cancellation), the client
|
||||
is expected to perform :func:`WlDataOffer.destroy()` right away.
|
||||
|
||||
This request can only be made on drag-and-drop offers, a protocol error
|
||||
will be raised otherwise.
|
||||
|
||||
:param dnd_actions:
|
||||
actions supported by the destination client
|
||||
:type dnd_actions:
|
||||
`ArgumentType.Uint`
|
||||
:param preferred_action:
|
||||
action preferred by the destination client
|
||||
:type preferred_action:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(4, dnd_actions, preferred_action)
|
||||
|
||||
|
||||
class WlDataOfferResource(Resource):
|
||||
interface = WlDataOffer
|
||||
|
||||
@WlDataOffer.event(
|
||||
Argument(ArgumentType.String),
|
||||
)
|
||||
def offer(self, mime_type: str) -> None:
|
||||
"""Advertise offered mime type
|
||||
|
||||
Sent immediately after creating the :class:`WlDataOffer` object. One
|
||||
event per offered mime type.
|
||||
|
||||
:param mime_type:
|
||||
offered mime type
|
||||
:type mime_type:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._post_event(0, mime_type)
|
||||
|
||||
@WlDataOffer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
version=3,
|
||||
)
|
||||
def source_actions(self, source_actions: int) -> None:
|
||||
"""Notify the source-side available actions
|
||||
|
||||
This event indicates the actions offered by the data source. It will be
|
||||
sent immediately after creating the :class:`WlDataOffer` object, or
|
||||
anytime the source side changes its offered actions through
|
||||
:func:`WlDataSource.set_actions()
|
||||
<pywayland.protocol.wayland.WlDataSource.set_actions>`.
|
||||
|
||||
:param source_actions:
|
||||
actions offered by the data source
|
||||
:type source_actions:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(1, source_actions)
|
||||
|
||||
@WlDataOffer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
version=3,
|
||||
)
|
||||
def action(self, dnd_action: int) -> None:
|
||||
"""Notify the selected action
|
||||
|
||||
This event indicates the action selected by the compositor after
|
||||
matching the source/destination side actions. Only one action (or none)
|
||||
will be offered here.
|
||||
|
||||
This event can be emitted multiple times during the drag-and-drop
|
||||
operation in response to destination side action changes through
|
||||
:func:`WlDataOffer.set_actions()`.
|
||||
|
||||
This event will no longer be emitted after :func:`WlDataDevice.drop()
|
||||
<pywayland.protocol.wayland.WlDataDevice.drop>` happened on the drag-
|
||||
and-drop destination, the client must honor the last action received,
|
||||
or the last preferred one set through :func:`WlDataOffer.set_actions()`
|
||||
when handling an "ask" action.
|
||||
|
||||
Compositors may also change the selected action on the fly, mainly in
|
||||
response to keyboard modifier changes during the drag-and-drop
|
||||
operation.
|
||||
|
||||
The most recent action received is always the valid one. Prior to
|
||||
receiving :func:`WlDataDevice.drop()
|
||||
<pywayland.protocol.wayland.WlDataDevice.drop>`, the chosen action may
|
||||
change (e.g. due to keyboard modifiers being pressed). At the time of
|
||||
receiving :func:`WlDataDevice.drop()
|
||||
<pywayland.protocol.wayland.WlDataDevice.drop>` the drag-and-drop
|
||||
destination must honor the last action received.
|
||||
|
||||
Action changes may still happen after :func:`WlDataDevice.drop()
|
||||
<pywayland.protocol.wayland.WlDataDevice.drop>`, especially on "ask"
|
||||
actions, where the drag-and-drop destination may choose another action
|
||||
afterwards. Action changes happening at this stage are always the
|
||||
result of inter-client negotiation, the compositor shall no longer be
|
||||
able to induce a different action.
|
||||
|
||||
Upon "ask" actions, it is expected that the drag-and-drop destination
|
||||
may potentially choose a different action and/or mime type, based on
|
||||
:func:`WlDataOffer.source_actions()` and finally chosen by the user
|
||||
(e.g. popping up a menu with the available options). The final
|
||||
:func:`WlDataOffer.set_actions()` and :func:`WlDataOffer.accept()`
|
||||
requests must happen before the call to :func:`WlDataOffer.finish()`.
|
||||
|
||||
:param dnd_action:
|
||||
action selected by the compositor
|
||||
:type dnd_action:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(2, dnd_action)
|
||||
|
||||
|
||||
class WlDataOfferGlobal(Global):
|
||||
interface = WlDataOffer
|
||||
|
||||
|
||||
WlDataOffer._gen_c()
|
||||
WlDataOffer.proxy_class = WlDataOfferProxy
|
||||
WlDataOffer.resource_class = WlDataOfferResource
|
||||
WlDataOffer.global_class = WlDataOfferGlobal
|
||||
@@ -0,0 +1,272 @@
|
||||
# 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,
|
||||
)
|
||||
|
||||
|
||||
class WlDataSource(Interface):
|
||||
"""Offer to transfer data
|
||||
|
||||
The :class:`WlDataSource` object is the source side of a
|
||||
:class:`~pywayland.protocol.wayland.WlDataOffer`. It is created by the
|
||||
source client in a data transfer and provides a way to describe the offered
|
||||
data and a way to respond to requests to transfer the data.
|
||||
"""
|
||||
|
||||
name = "wl_data_source"
|
||||
version = 4
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_action_mask = 0
|
||||
invalid_source = 1
|
||||
|
||||
|
||||
class WlDataSourceProxy(Proxy[WlDataSource]):
|
||||
interface = WlDataSource
|
||||
|
||||
@WlDataSource.request(
|
||||
Argument(ArgumentType.String),
|
||||
)
|
||||
def offer(self, mime_type: str) -> None:
|
||||
"""Add an offered mime type
|
||||
|
||||
This request adds a mime type to the set of mime types advertised to
|
||||
targets. Can be called several times to offer multiple types.
|
||||
|
||||
:param mime_type:
|
||||
mime type offered by the data source
|
||||
:type mime_type:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._marshal(0, mime_type)
|
||||
|
||||
@WlDataSource.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroy the data source
|
||||
|
||||
Destroy the data source.
|
||||
"""
|
||||
self._marshal(1)
|
||||
self._destroy()
|
||||
|
||||
@WlDataSource.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
version=3,
|
||||
)
|
||||
def set_actions(self, dnd_actions: int) -> None:
|
||||
"""Set the available drag-and-drop actions
|
||||
|
||||
Sets the actions that the source side client supports for this
|
||||
operation. This request may trigger :func:`WlDataSource.action()` and
|
||||
:func:`WlDataOffer.action()
|
||||
<pywayland.protocol.wayland.WlDataOffer.action>` events if the
|
||||
compositor needs to change the selected action.
|
||||
|
||||
The dnd_actions argument must contain only values expressed in the
|
||||
:func:`WlDataDeviceManager.dnd_actions()
|
||||
<pywayland.protocol.wayland.WlDataDeviceManager.dnd_actions>` enum,
|
||||
otherwise it will result in a protocol error.
|
||||
|
||||
This request must be made once only, and can only be made on sources
|
||||
used in drag-and-drop, so it must be performed before
|
||||
:func:`WlDataDevice.start_drag()
|
||||
<pywayland.protocol.wayland.WlDataDevice.start_drag>`. Attempting to
|
||||
use the source other than for drag-and-drop will raise a protocol
|
||||
error.
|
||||
|
||||
:param dnd_actions:
|
||||
actions supported by the data source
|
||||
:type dnd_actions:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(2, dnd_actions)
|
||||
|
||||
|
||||
class WlDataSourceResource(Resource):
|
||||
interface = WlDataSource
|
||||
|
||||
@WlDataSource.event(
|
||||
Argument(ArgumentType.String, nullable=True),
|
||||
)
|
||||
def target(self, mime_type: str | None) -> None:
|
||||
"""A target accepts an offered mime type
|
||||
|
||||
Sent when a target accepts pointer_focus or motion events. If a target
|
||||
does not accept any of the offered types, type is NULL.
|
||||
|
||||
Used for feedback during drag-and-drop.
|
||||
|
||||
:param mime_type:
|
||||
mime type accepted by the target
|
||||
:type mime_type:
|
||||
`ArgumentType.String` or `None`
|
||||
"""
|
||||
self._post_event(0, mime_type)
|
||||
|
||||
@WlDataSource.event(
|
||||
Argument(ArgumentType.String),
|
||||
Argument(ArgumentType.FileDescriptor),
|
||||
)
|
||||
def send(self, mime_type: str, fd: int) -> None:
|
||||
"""Send the data
|
||||
|
||||
Request for data from the client. Send the data as the specified mime
|
||||
type over the passed file descriptor, then close it.
|
||||
|
||||
:param mime_type:
|
||||
mime type for the data
|
||||
:type mime_type:
|
||||
`ArgumentType.String`
|
||||
:param fd:
|
||||
file descriptor for the data
|
||||
:type fd:
|
||||
`ArgumentType.FileDescriptor`
|
||||
"""
|
||||
self._post_event(1, mime_type, fd)
|
||||
|
||||
@WlDataSource.event()
|
||||
def cancelled(self) -> None:
|
||||
"""Selection was cancelled
|
||||
|
||||
This data source is no longer valid. There are several reasons why this
|
||||
could happen:
|
||||
|
||||
- The data source has been replaced by another data source.
|
||||
|
||||
- The drag-and-drop operation was performed, but the drop destination
|
||||
did not accept any of the mime types offered through
|
||||
:func:`WlDataSource.target()`.
|
||||
|
||||
- The drag-and-drop operation was performed, but the drop destination
|
||||
did not select any of the actions present in the mask offered through
|
||||
:func:`WlDataSource.action()`.
|
||||
|
||||
- The drag-and-drop operation was performed but didn't happen over a
|
||||
surface.
|
||||
|
||||
- The compositor cancelled the drag-and-drop operation (e.g. compositor
|
||||
dependent timeouts to avoid stale drag-and-drop transfers).
|
||||
|
||||
The client should clean up and destroy this data source.
|
||||
|
||||
For objects of version 2 or older, :func:`WlDataSource.cancelled()`
|
||||
will only be emitted if the data source was replaced by another data
|
||||
source.
|
||||
"""
|
||||
self._post_event(2)
|
||||
|
||||
@WlDataSource.event(version=3)
|
||||
def dnd_drop_performed(self) -> None:
|
||||
"""The drag-and-drop operation physically finished
|
||||
|
||||
The user performed the drop action. This event does not indicate
|
||||
acceptance, :func:`WlDataSource.cancelled()` may still be emitted
|
||||
afterwards if the drop destination does not accept any mime type.
|
||||
|
||||
However, this event might not be received if the compositor cancelled
|
||||
the drag-and-drop operation before this event could happen.
|
||||
|
||||
Note that the data_source may still be used in the future and should
|
||||
not be destroyed here.
|
||||
"""
|
||||
self._post_event(3)
|
||||
|
||||
@WlDataSource.event(version=3)
|
||||
def dnd_finished(self) -> None:
|
||||
"""The drag-and-drop operation concluded
|
||||
|
||||
The drop destination finished interoperating with this data source, so
|
||||
the client is now free to destroy this data source and free all
|
||||
associated data.
|
||||
|
||||
If the action used to perform the operation was "move", the source can
|
||||
now delete the transferred data.
|
||||
"""
|
||||
self._post_event(4)
|
||||
|
||||
@WlDataSource.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
version=3,
|
||||
)
|
||||
def action(self, dnd_action: int) -> None:
|
||||
"""Notify the selected action
|
||||
|
||||
This event indicates the action selected by the compositor after
|
||||
matching the source/destination side actions. Only one action (or none)
|
||||
will be offered here.
|
||||
|
||||
This event can be emitted multiple times during the drag-and-drop
|
||||
operation, mainly in response to destination side changes through
|
||||
:func:`WlDataOffer.set_actions()
|
||||
<pywayland.protocol.wayland.WlDataOffer.set_actions>`, and as the data
|
||||
device enters/leaves surfaces.
|
||||
|
||||
It is only possible to receive this event after
|
||||
:func:`WlDataSource.dnd_drop_performed()` if the drag-and-drop
|
||||
operation ended in an "ask" action, in which case the final
|
||||
:func:`WlDataSource.action()` event will happen immediately before
|
||||
:func:`WlDataSource.dnd_finished()`.
|
||||
|
||||
Compositors may also change the selected action on the fly, mainly in
|
||||
response to keyboard modifier changes during the drag-and-drop
|
||||
operation.
|
||||
|
||||
The most recent action received is always the valid one. The chosen
|
||||
action may change alongside negotiation (e.g. an "ask" action can turn
|
||||
into a "move" operation), so the effects of the final action must
|
||||
always be applied in :func:`WlDataSource.dnd_finished()`.
|
||||
|
||||
Clients can trigger cursor surface changes from this point, so they
|
||||
reflect the current action.
|
||||
|
||||
:param dnd_action:
|
||||
action selected by the compositor
|
||||
:type dnd_action:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(5, dnd_action)
|
||||
|
||||
|
||||
class WlDataSourceGlobal(Global):
|
||||
interface = WlDataSource
|
||||
|
||||
|
||||
WlDataSource._gen_c()
|
||||
WlDataSource.proxy_class = WlDataSourceProxy
|
||||
WlDataSource.resource_class = WlDataSourceResource
|
||||
WlDataSource.global_class = WlDataSourceGlobal
|
||||
@@ -0,0 +1,180 @@
|
||||
# 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 typing import Any
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
from .wl_callback import WlCallback
|
||||
from .wl_registry import WlRegistry
|
||||
|
||||
|
||||
class WlDisplay(Interface):
|
||||
"""Core global object
|
||||
|
||||
The core global object. This is a special singleton object. It is used
|
||||
for internal Wayland protocol features.
|
||||
"""
|
||||
|
||||
name = "wl_display"
|
||||
version = 1
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_object = 0
|
||||
invalid_method = 1
|
||||
no_memory = 2
|
||||
implementation = 3
|
||||
|
||||
|
||||
class WlDisplayProxy(Proxy[WlDisplay]):
|
||||
interface = WlDisplay
|
||||
|
||||
@WlDisplay.request(
|
||||
Argument(ArgumentType.NewId, interface=WlCallback),
|
||||
)
|
||||
def sync(self) -> Proxy[WlCallback]:
|
||||
"""Asynchronous roundtrip
|
||||
|
||||
The sync request asks the server to emit the 'done' event on the
|
||||
returned :class:`~pywayland.protocol.wayland.WlCallback` object. Since
|
||||
requests are handled in-order and events are delivered in-order, this
|
||||
can be used as a barrier to ensure all previous requests and the
|
||||
resulting events have been handled.
|
||||
|
||||
The object returned by this request will be destroyed by the compositor
|
||||
after the callback is fired and as such the client must not attempt to
|
||||
use it after that point.
|
||||
|
||||
The callback_data passed in the callback is undefined and should be
|
||||
ignored.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlCallback` -- callback object
|
||||
for the sync request
|
||||
"""
|
||||
callback = self._marshal_constructor(0, WlCallback)
|
||||
return callback
|
||||
|
||||
@WlDisplay.request(
|
||||
Argument(ArgumentType.NewId, interface=WlRegistry),
|
||||
)
|
||||
def get_registry(self) -> Proxy[WlRegistry]:
|
||||
"""Get global registry object
|
||||
|
||||
This request creates a registry object that allows the client to list
|
||||
and bind the global objects available from the compositor.
|
||||
|
||||
It should be noted that the server side resources consumed in response
|
||||
to a get_registry request can only be released when the client
|
||||
disconnects, not when the client side proxy is destroyed. Therefore,
|
||||
clients should invoke get_registry as infrequently as possible to avoid
|
||||
wasting memory.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlRegistry` -- global registry
|
||||
object
|
||||
"""
|
||||
registry = self._marshal_constructor(1, WlRegistry)
|
||||
return registry
|
||||
|
||||
|
||||
class WlDisplayResource(Resource):
|
||||
interface = WlDisplay
|
||||
|
||||
@WlDisplay.event(
|
||||
Argument(ArgumentType.Object),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.String),
|
||||
)
|
||||
def error(self, object_id: Any, code: int, message: str) -> None:
|
||||
"""Fatal error event
|
||||
|
||||
The error event is sent out when a fatal (non-recoverable) error has
|
||||
occurred. The object_id argument is the object where the error
|
||||
occurred, most often in response to a request to that object. The code
|
||||
identifies the error and is defined by the object interface. As such,
|
||||
each interface defines its own set of error codes. The message is a
|
||||
brief description of the error, for (debugging) convenience.
|
||||
|
||||
:param object_id:
|
||||
object where the error occurred
|
||||
:type object_id:
|
||||
`ArgumentType.Object`
|
||||
:param code:
|
||||
error code
|
||||
:type code:
|
||||
`ArgumentType.Uint`
|
||||
:param message:
|
||||
error description
|
||||
:type message:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._post_event(0, object_id, code, message)
|
||||
|
||||
@WlDisplay.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def delete_id(self, id: int) -> None:
|
||||
"""Acknowledge object id deletion
|
||||
|
||||
This event is used internally by the object ID management logic.
|
||||
|
||||
When the server stops using an object created by the client, the server
|
||||
sends this event. In particular, after sending this event, the server
|
||||
will no longer send any events that contain the object as the receiver
|
||||
or as an argument.
|
||||
|
||||
When the client receives this event, it knows that it can reuse the
|
||||
object ID.
|
||||
|
||||
:param id:
|
||||
deleted object ID
|
||||
:type id:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(1, id)
|
||||
|
||||
|
||||
class WlDisplayGlobal(Global):
|
||||
interface = WlDisplay
|
||||
|
||||
|
||||
WlDisplay._gen_c()
|
||||
WlDisplay.proxy_class = WlDisplayProxy
|
||||
WlDisplay.resource_class = WlDisplayResource
|
||||
WlDisplay.global_class = WlDisplayGlobal
|
||||
@@ -0,0 +1,151 @@
|
||||
# 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_registry import WlRegistry
|
||||
|
||||
|
||||
class WlFixes(Interface):
|
||||
"""Wayland protocol fixes
|
||||
|
||||
This global fixes problems with other core-protocol interfaces that cannot
|
||||
be fixed in these interfaces themselves.
|
||||
"""
|
||||
|
||||
name = "wl_fixes"
|
||||
version = 2
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_ack_remove = 0
|
||||
|
||||
|
||||
class WlFixesProxy(Proxy[WlFixes]):
|
||||
interface = WlFixes
|
||||
|
||||
@WlFixes.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroys this object
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
@WlFixes.request(
|
||||
Argument(ArgumentType.Object, interface=WlRegistry),
|
||||
)
|
||||
def destroy_registry(self, registry: WlRegistry) -> None:
|
||||
"""Destroy a :class:`~pywayland.protocol.wayland.WlRegistry`
|
||||
|
||||
This request destroys a :class:`~pywayland.protocol.wayland.WlRegistry`
|
||||
object.
|
||||
|
||||
The client should no longer use the
|
||||
:class:`~pywayland.protocol.wayland.WlRegistry` after making this
|
||||
request.
|
||||
|
||||
The compositor will emit a :func:`WlDisplay.delete_id()
|
||||
<pywayland.protocol.wayland.WlDisplay.delete_id>` event with the object
|
||||
ID of the registry and will no longer emit any events on the registry.
|
||||
The client should re-use the object ID once it receives the
|
||||
:func:`WlDisplay.delete_id()
|
||||
<pywayland.protocol.wayland.WlDisplay.delete_id>` event.
|
||||
|
||||
:param registry:
|
||||
the registry to destroy
|
||||
:type registry:
|
||||
:class:`~pywayland.protocol.wayland.WlRegistry`
|
||||
"""
|
||||
self._marshal(1, registry)
|
||||
|
||||
@WlFixes.request(
|
||||
Argument(ArgumentType.Object, interface=WlRegistry),
|
||||
Argument(ArgumentType.Uint),
|
||||
version=2,
|
||||
)
|
||||
def ack_global_remove(self, registry: WlRegistry, name: int) -> None:
|
||||
"""Acknowledge global removal
|
||||
|
||||
Acknowledge the removal of the specified global.
|
||||
|
||||
If no global with the specified name exists or the global is not
|
||||
removed, the :func:`WlFixes.invalid_ack_remove()` protocol error will
|
||||
be posted.
|
||||
|
||||
Due to the Wayland protocol being asynchronous, the wl_global objects
|
||||
cannot be destroyed immediately. For example, if a wl_global is removed
|
||||
and a client attempts to bind that global around same time, it can
|
||||
result in a protocol error due to an unknown global name in the bind
|
||||
request.
|
||||
|
||||
In order to avoid crashing clients, the compositor should remove the
|
||||
wl_global once it is guaranteed that no more bind requests will come.
|
||||
|
||||
The :func:`WlFixes.ack_global_remove()()` request is used to signal to
|
||||
the compositor that the client will not bind the given global anymore.
|
||||
After all clients acknowledge the removal of the global, the compositor
|
||||
can safely destroy it.
|
||||
|
||||
The client must call the :func:`WlFixes.ack_global_remove()()` request
|
||||
in response to a :func:`WlRegistry.global_remove()()
|
||||
<pywayland.protocol.wayland.WlRegistry.global_remove()>` event even if
|
||||
it did not bind the corresponding global.
|
||||
|
||||
:param registry:
|
||||
the registry object
|
||||
:type registry:
|
||||
:class:`~pywayland.protocol.wayland.WlRegistry`
|
||||
:param name:
|
||||
unique name of the global
|
||||
:type name:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(2, registry, name)
|
||||
|
||||
|
||||
class WlFixesResource(Resource):
|
||||
interface = WlFixes
|
||||
|
||||
|
||||
class WlFixesGlobal(Global):
|
||||
interface = WlFixes
|
||||
|
||||
|
||||
WlFixes._gen_c()
|
||||
WlFixes.proxy_class = WlFixesProxy
|
||||
WlFixes.resource_class = WlFixesResource
|
||||
WlFixes.global_class = WlFixesGlobal
|
||||
@@ -0,0 +1,326 @@
|
||||
# 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 WlKeyboard(Interface):
|
||||
"""Keyboard input device
|
||||
|
||||
The :class:`WlKeyboard` interface represents one or more keyboards
|
||||
associated with a seat.
|
||||
|
||||
Each :class:`WlKeyboard` has the following logical state:
|
||||
|
||||
- an active surface (possibly null),
|
||||
|
||||
- the keys currently logically down,
|
||||
|
||||
- the active modifiers,
|
||||
|
||||
- the active group.
|
||||
|
||||
By default, the active surface is null, the keys currently logically down
|
||||
are empty, the active modifiers and the active group are 0.
|
||||
"""
|
||||
|
||||
name = "wl_keyboard"
|
||||
version = 11
|
||||
|
||||
class keymap_format(enum.IntEnum):
|
||||
no_keymap = 0
|
||||
xkb_v1 = 1
|
||||
|
||||
class key_state(enum.IntEnum):
|
||||
released = 0
|
||||
pressed = 1
|
||||
repeated = 2
|
||||
|
||||
|
||||
class WlKeyboardProxy(Proxy[WlKeyboard]):
|
||||
interface = WlKeyboard
|
||||
|
||||
@WlKeyboard.request(version=3)
|
||||
def release(self) -> None:
|
||||
"""Release the keyboard object
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlKeyboardResource(Resource):
|
||||
interface = WlKeyboard
|
||||
|
||||
@WlKeyboard.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.FileDescriptor),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def keymap(self, format: int, fd: int, size: int) -> None:
|
||||
"""Keyboard mapping
|
||||
|
||||
This event provides a file descriptor to the client which can be
|
||||
memory-mapped in read-only mode to provide a keyboard mapping
|
||||
description.
|
||||
|
||||
From version 7 onwards, the fd must be mapped with MAP_PRIVATE by the
|
||||
recipient, as MAP_SHARED may fail.
|
||||
|
||||
:param format:
|
||||
keymap format
|
||||
:type format:
|
||||
`ArgumentType.Uint`
|
||||
:param fd:
|
||||
keymap file descriptor
|
||||
:type fd:
|
||||
`ArgumentType.FileDescriptor`
|
||||
:param size:
|
||||
keymap size, in bytes
|
||||
:type size:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, format, fd, size)
|
||||
|
||||
@WlKeyboard.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Array),
|
||||
)
|
||||
def enter(self, serial: int, surface: WlSurface, keys: list) -> None:
|
||||
"""Enter event
|
||||
|
||||
Notification that this seat's keyboard focus is on a certain surface.
|
||||
|
||||
The compositor must send the :func:`WlKeyboard.modifiers()` event after
|
||||
this event.
|
||||
|
||||
In the :class:`WlKeyboard` logical state, this event sets the active
|
||||
surface to the surface argument and the keys currently logically down
|
||||
to the keys in the keys argument. The compositor must not send this
|
||||
event if the :class:`WlKeyboard` already had an active surface
|
||||
immediately before this event.
|
||||
|
||||
Clients should not use the list of pressed keys to emulate key-press
|
||||
events. The order of keys in the list is unspecified.
|
||||
|
||||
:param serial:
|
||||
serial number of the enter event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
surface gaining keyboard focus
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param keys:
|
||||
the keys currently logically down
|
||||
:type keys:
|
||||
`ArgumentType.Array`
|
||||
"""
|
||||
self._post_event(1, serial, surface, keys)
|
||||
|
||||
@WlKeyboard.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
)
|
||||
def leave(self, serial: int, surface: WlSurface) -> None:
|
||||
"""Leave event
|
||||
|
||||
Notification that this seat's keyboard focus is no longer on a certain
|
||||
surface.
|
||||
|
||||
The leave notification is sent before the enter notification for the
|
||||
new focus.
|
||||
|
||||
In the :class:`WlKeyboard` logical state, this event resets all values
|
||||
to their defaults. The compositor must not send this event if the
|
||||
active surface of the :class:`WlKeyboard` was not equal to the surface
|
||||
argument immediately before this event.
|
||||
|
||||
:param serial:
|
||||
serial number of the leave event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
surface that lost keyboard focus
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
"""
|
||||
self._post_event(2, serial, surface)
|
||||
|
||||
@WlKeyboard.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def key(self, serial: int, time: int, key: int, state: int) -> None:
|
||||
"""Key event
|
||||
|
||||
A key was pressed or released. The time argument is a timestamp with
|
||||
millisecond granularity, with an undefined base.
|
||||
|
||||
The key is a platform-specific key code that can be interpreted by
|
||||
feeding it to the keyboard mapping (see the keymap event).
|
||||
|
||||
If this event produces a change in modifiers, then the resulting
|
||||
:func:`WlKeyboard.modifiers()` event must be sent after this event.
|
||||
|
||||
In the :class:`WlKeyboard` logical state, this event adds the key to
|
||||
the keys currently logically down (if the state argument is pressed) or
|
||||
removes the key from the keys currently logically down (if the state
|
||||
argument is released). The compositor must not send this event if the
|
||||
:class:`WlKeyboard` did not have an active surface immediately before
|
||||
this event. The compositor must not send this event if state is pressed
|
||||
(resp. released) and the key was already logically down (resp. was not
|
||||
logically down) immediately before this event.
|
||||
|
||||
Since version 10, compositors may send key events with the "repeated"
|
||||
key state when a :func:`WlKeyboard.repeat_info()` event with a rate
|
||||
argument of 0 has been received. This allows the compositor to take
|
||||
over the responsibility of key repetition.
|
||||
|
||||
:param serial:
|
||||
serial number of the key event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param key:
|
||||
key that produced the event
|
||||
:type key:
|
||||
`ArgumentType.Uint`
|
||||
:param state:
|
||||
physical state of the key
|
||||
:type state:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(3, serial, time, key, state)
|
||||
|
||||
@WlKeyboard.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def modifiers(self, serial: int, mods_depressed: int, mods_latched: int, mods_locked: int, group: int) -> None:
|
||||
"""Modifier and group state
|
||||
|
||||
Notifies clients that the modifier and/or group state has changed, and
|
||||
it should update its local state.
|
||||
|
||||
The compositor may send this event without a surface of the client
|
||||
having keyboard focus, for example to tie modifier information to
|
||||
pointer focus instead. If a modifier event with pressed modifiers is
|
||||
sent without a prior enter event, the client can assume the modifier
|
||||
state is valid until it receives the next
|
||||
:func:`WlKeyboard.modifiers()` event. In order to reset the modifier
|
||||
state again, the compositor can send a :func:`WlKeyboard.modifiers()`
|
||||
event with no pressed modifiers.
|
||||
|
||||
In the :class:`WlKeyboard` logical state, this event updates the
|
||||
modifiers and group.
|
||||
|
||||
:param serial:
|
||||
serial number of the modifiers event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param mods_depressed:
|
||||
depressed modifiers
|
||||
:type mods_depressed:
|
||||
`ArgumentType.Uint`
|
||||
:param mods_latched:
|
||||
latched modifiers
|
||||
:type mods_latched:
|
||||
`ArgumentType.Uint`
|
||||
:param mods_locked:
|
||||
locked modifiers
|
||||
:type mods_locked:
|
||||
`ArgumentType.Uint`
|
||||
:param group:
|
||||
keyboard layout
|
||||
:type group:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(4, serial, mods_depressed, mods_latched, mods_locked, group)
|
||||
|
||||
@WlKeyboard.event(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
version=4,
|
||||
)
|
||||
def repeat_info(self, rate: int, delay: int) -> None:
|
||||
"""Repeat rate and delay
|
||||
|
||||
Informs the client about the keyboard's repeat rate and delay.
|
||||
|
||||
This event is sent as soon as the :class:`WlKeyboard` object has been
|
||||
created, and is guaranteed to be received by the client before any key
|
||||
press event.
|
||||
|
||||
Negative values for either rate or delay are illegal. A rate of zero
|
||||
will disable any repeating (regardless of the value of delay).
|
||||
|
||||
This event can be sent later on as well with a new value if necessary,
|
||||
so clients should continue listening for the event past the creation of
|
||||
:class:`WlKeyboard`.
|
||||
|
||||
:param rate:
|
||||
the rate of repeating keys in characters per second
|
||||
:type rate:
|
||||
`ArgumentType.Int`
|
||||
:param delay:
|
||||
delay in milliseconds since key down until repeating starts
|
||||
:type delay:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(5, rate, delay)
|
||||
|
||||
|
||||
class WlKeyboardGlobal(Global):
|
||||
interface = WlKeyboard
|
||||
|
||||
|
||||
WlKeyboard._gen_c()
|
||||
WlKeyboard.proxy_class = WlKeyboardProxy
|
||||
WlKeyboard.resource_class = WlKeyboardResource
|
||||
WlKeyboard.global_class = WlKeyboardGlobal
|
||||
@@ -0,0 +1,353 @@
|
||||
# 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,
|
||||
)
|
||||
|
||||
|
||||
class WlOutput(Interface):
|
||||
"""Compositor output region
|
||||
|
||||
An output describes part of the compositor geometry. The compositor works
|
||||
in the 'compositor coordinate system' and an output corresponds to a
|
||||
rectangular area in that space that is actually visible. This typically
|
||||
corresponds to a monitor that displays part of the compositor space. This
|
||||
object is published as global during start up, or when a monitor is
|
||||
hotplugged.
|
||||
"""
|
||||
|
||||
name = "wl_output"
|
||||
version = 4
|
||||
|
||||
class subpixel(enum.IntEnum):
|
||||
unknown = 0
|
||||
none = 1
|
||||
horizontal_rgb = 2
|
||||
horizontal_bgr = 3
|
||||
vertical_rgb = 4
|
||||
vertical_bgr = 5
|
||||
|
||||
class transform(enum.IntEnum):
|
||||
normal = 0
|
||||
transform_90 = 1
|
||||
transform_180 = 2
|
||||
transform_270 = 3
|
||||
flipped = 4
|
||||
flipped_90 = 5
|
||||
flipped_180 = 6
|
||||
flipped_270 = 7
|
||||
|
||||
class mode(enum.IntFlag):
|
||||
current = 0x1
|
||||
preferred = 0x2
|
||||
|
||||
|
||||
class WlOutputProxy(Proxy[WlOutput]):
|
||||
interface = WlOutput
|
||||
|
||||
@WlOutput.request(version=3)
|
||||
def release(self) -> None:
|
||||
"""Release the output object
|
||||
|
||||
Using this request a client can tell the server that it is not going to
|
||||
use the output object anymore.
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlOutputResource(Resource):
|
||||
interface = WlOutput
|
||||
|
||||
@WlOutput.event(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.String),
|
||||
Argument(ArgumentType.String),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def geometry(self, x: int, y: int, physical_width: int, physical_height: int, subpixel: int, make: str, model: str, transform: int) -> None:
|
||||
"""Properties of the output
|
||||
|
||||
The geometry event describes geometric properties of the output. The
|
||||
event is sent when binding to the output object and whenever any of the
|
||||
properties change.
|
||||
|
||||
The physical size can be set to zero if it doesn't make sense for this
|
||||
output (e.g. for projectors or virtual outputs).
|
||||
|
||||
The geometry event will be followed by a done event (starting from
|
||||
version 2).
|
||||
|
||||
Clients should use :func:`WlSurface.preferred_buffer_transform()
|
||||
<pywayland.protocol.wayland.WlSurface.preferred_buffer_transform>`
|
||||
instead of the transform advertised by this event to find the preferred
|
||||
buffer transform to use for a surface.
|
||||
|
||||
Note: :class:`WlOutput` only advertises partial information about the
|
||||
output position and identification. Some compositors, for instance
|
||||
those not implementing a desktop-style output layout or those exposing
|
||||
virtual outputs, might fake this information. Instead of using x and y,
|
||||
clients should use xdg_output.logical_position. Instead of using make
|
||||
and model, clients should use name and description.
|
||||
|
||||
:param x:
|
||||
x position within the global compositor space
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
y position within the global compositor space
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param physical_width:
|
||||
width in millimeters of the output
|
||||
:type physical_width:
|
||||
`ArgumentType.Int`
|
||||
:param physical_height:
|
||||
height in millimeters of the output
|
||||
:type physical_height:
|
||||
`ArgumentType.Int`
|
||||
:param subpixel:
|
||||
subpixel orientation of the output
|
||||
:type subpixel:
|
||||
`ArgumentType.Int`
|
||||
:param make:
|
||||
textual description of the manufacturer
|
||||
:type make:
|
||||
`ArgumentType.String`
|
||||
:param model:
|
||||
textual description of the model
|
||||
:type model:
|
||||
`ArgumentType.String`
|
||||
:param transform:
|
||||
additional transformation applied to buffer contents during
|
||||
presentation
|
||||
:type transform:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(0, x, y, physical_width, physical_height, subpixel, make, model, transform)
|
||||
|
||||
@WlOutput.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def mode(self, flags: int, width: int, height: int, refresh: int) -> None:
|
||||
"""Advertise available modes for the output
|
||||
|
||||
The mode event describes an available mode for the output.
|
||||
|
||||
The event is sent when binding to the output object and there will
|
||||
always be one mode, the current mode. The event is sent again if an
|
||||
output changes mode, for the mode that is now current. In other words,
|
||||
the current mode is always the last mode that was received with the
|
||||
current flag set.
|
||||
|
||||
Non-current modes are deprecated. A compositor can decide to only
|
||||
advertise the current mode and never send other modes. Clients should
|
||||
not rely on non-current modes.
|
||||
|
||||
The size of a mode is given in physical hardware units of the output
|
||||
device. This is not necessarily the same as the output size in the
|
||||
global compositor space. For instance, the output may be scaled, as
|
||||
described in :func:`WlOutput.scale()`, or transformed, as described in
|
||||
:func:`WlOutput.transform()`. Clients willing to retrieve the output
|
||||
size in the global compositor space should use xdg_output.logical_size
|
||||
instead.
|
||||
|
||||
The vertical refresh rate can be set to zero if it doesn't make sense
|
||||
for this output (e.g. for virtual outputs).
|
||||
|
||||
The mode event will be followed by a done event (starting from version
|
||||
2).
|
||||
|
||||
Clients should not use the refresh rate to schedule frames. Instead,
|
||||
they should use the :func:`WlSurface.frame()
|
||||
<pywayland.protocol.wayland.WlSurface.frame>` event or the
|
||||
presentation-time protocol.
|
||||
|
||||
Note: this information is not always meaningful for all outputs. Some
|
||||
compositors, such as those exposing virtual outputs, might fake the
|
||||
refresh rate or the size.
|
||||
|
||||
:param flags:
|
||||
bitfield of mode flags
|
||||
:type flags:
|
||||
`ArgumentType.Uint`
|
||||
:param width:
|
||||
width of the mode in hardware units
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
height of the mode in hardware units
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
:param refresh:
|
||||
vertical refresh rate in mHz
|
||||
:type refresh:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(1, flags, width, height, refresh)
|
||||
|
||||
@WlOutput.event(version=2)
|
||||
def done(self) -> None:
|
||||
"""Sent all information about output
|
||||
|
||||
This event is sent after all other properties have been sent after
|
||||
binding to the output object and after any other property changes done
|
||||
after that. This allows changes to the output properties to be seen as
|
||||
atomic, even if they happen via multiple events.
|
||||
"""
|
||||
self._post_event(2)
|
||||
|
||||
@WlOutput.event(
|
||||
Argument(ArgumentType.Int),
|
||||
version=2,
|
||||
)
|
||||
def scale(self, factor: int) -> None:
|
||||
"""Output scaling properties
|
||||
|
||||
This event contains scaling geometry information that is not in the
|
||||
geometry event. It may be sent after binding the output object or if
|
||||
the output scale changes later. The compositor will emit a non-zero,
|
||||
positive value for scale. If it is not sent, the client should assume a
|
||||
scale of 1.
|
||||
|
||||
A scale larger than 1 means that the compositor will automatically
|
||||
scale surface buffers by this amount when rendering. This is used for
|
||||
very high resolution displays where applications rendering at the
|
||||
native resolution would be too small to be legible.
|
||||
|
||||
Clients should use :func:`WlSurface.preferred_buffer_scale()
|
||||
<pywayland.protocol.wayland.WlSurface.preferred_buffer_scale>` instead
|
||||
of this event to find the preferred buffer scale to use for a surface.
|
||||
|
||||
The scale event will be followed by a done event.
|
||||
|
||||
:param factor:
|
||||
scaling factor of output
|
||||
:type factor:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(3, factor)
|
||||
|
||||
@WlOutput.event(
|
||||
Argument(ArgumentType.String),
|
||||
version=4,
|
||||
)
|
||||
def name(self, name: str) -> None:
|
||||
"""Name of this output
|
||||
|
||||
Many compositors will assign user-friendly names to their outputs, show
|
||||
them to the user, allow the user to refer to an output, etc. The client
|
||||
may wish to know this name as well to offer the user similar behaviors.
|
||||
|
||||
The name is a UTF-8 string with no convention defined for its contents.
|
||||
Each name is unique among all :class:`WlOutput` globals. The name is
|
||||
only guaranteed to be unique for the compositor instance.
|
||||
|
||||
The same output name is used for all clients for a given
|
||||
:class:`WlOutput` global. Thus, the name can be shared across processes
|
||||
to refer to a specific :class:`WlOutput` global.
|
||||
|
||||
The name is not guaranteed to be persistent across sessions, thus
|
||||
cannot be used to reliably identify an output in e.g. configuration
|
||||
files.
|
||||
|
||||
Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do
|
||||
not assume that the name is a reflection of an underlying DRM
|
||||
connector, X11 connection, etc.
|
||||
|
||||
The name event is sent after binding the output object. This event is
|
||||
only sent once per output object, and the name does not change over the
|
||||
lifetime of the :class:`WlOutput` global.
|
||||
|
||||
Compositors may re-use the same output name if the :class:`WlOutput`
|
||||
global is destroyed and re-created later. Compositors should avoid re-
|
||||
using the same name if possible.
|
||||
|
||||
The name event will be followed by a done event.
|
||||
|
||||
:param name:
|
||||
output name
|
||||
:type name:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._post_event(4, name)
|
||||
|
||||
@WlOutput.event(
|
||||
Argument(ArgumentType.String),
|
||||
version=4,
|
||||
)
|
||||
def description(self, description: str) -> None:
|
||||
"""Human-readable description of this output
|
||||
|
||||
Many compositors can produce human-readable descriptions of their
|
||||
outputs. The client may wish to know this description as well, e.g. for
|
||||
output selection purposes.
|
||||
|
||||
The description is a UTF-8 string with no convention defined for its
|
||||
contents. The description is not guaranteed to be unique among all
|
||||
:class:`WlOutput` globals. Examples might include 'Foocorp 11" Display'
|
||||
or 'Virtual X11 output via :1'.
|
||||
|
||||
The description event is sent after binding the output object and
|
||||
whenever the description changes. The description is optional, and may
|
||||
not be sent at all.
|
||||
|
||||
The description event will be followed by a done event.
|
||||
|
||||
:param description:
|
||||
output description
|
||||
:type description:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._post_event(5, description)
|
||||
|
||||
|
||||
class WlOutputGlobal(Global):
|
||||
interface = WlOutput
|
||||
|
||||
|
||||
WlOutput._gen_c()
|
||||
WlOutput.proxy_class = WlOutputProxy
|
||||
WlOutput.resource_class = WlOutputResource
|
||||
WlOutput.global_class = WlOutputGlobal
|
||||
@@ -0,0 +1,627 @@
|
||||
# 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 WlPointer(Interface):
|
||||
"""Pointer input device
|
||||
|
||||
The :class:`WlPointer` interface represents one or more input devices, such
|
||||
as mice, which control the pointer location and pointer_focus of a seat.
|
||||
|
||||
The :class:`WlPointer` interface generates motion, enter and leave events
|
||||
for the surfaces that the pointer is located over, and button and axis
|
||||
events for button presses, button releases and scrolling.
|
||||
"""
|
||||
|
||||
name = "wl_pointer"
|
||||
version = 11
|
||||
|
||||
class error(enum.IntEnum):
|
||||
role = 0
|
||||
|
||||
class button_state(enum.IntEnum):
|
||||
released = 0
|
||||
pressed = 1
|
||||
|
||||
class axis(enum.IntEnum):
|
||||
vertical_scroll = 0
|
||||
horizontal_scroll = 1
|
||||
|
||||
class axis_source(enum.IntEnum):
|
||||
wheel = 0
|
||||
finger = 1
|
||||
continuous = 2
|
||||
wheel_tilt = 3
|
||||
|
||||
class axis_relative_direction(enum.IntEnum):
|
||||
identical = 0
|
||||
inverted = 1
|
||||
|
||||
|
||||
class WlPointerProxy(Proxy[WlPointer]):
|
||||
interface = WlPointer
|
||||
|
||||
@WlPointer.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface, nullable=True),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def set_cursor(self, serial: int, surface: WlSurface | None, hotspot_x: int, hotspot_y: int) -> None:
|
||||
"""Set the pointer surface
|
||||
|
||||
Set the pointer surface, i.e., the surface that contains the pointer
|
||||
image (cursor). This request gives the surface the role of a cursor. If
|
||||
the surface already has another role, it raises a protocol error.
|
||||
|
||||
The cursor actually changes only if the pointer focus for this device
|
||||
is one of the requesting client's surfaces or the surface parameter is
|
||||
the current pointer surface. If there was a previous surface set with
|
||||
this request it is replaced. If surface is NULL, the pointer image is
|
||||
hidden.
|
||||
|
||||
The parameters hotspot_x and hotspot_y define the position of the
|
||||
pointer surface relative to the pointer location. Its top-left corner
|
||||
is always at (x, y) - (hotspot_x, hotspot_y), where (x, y) are the
|
||||
coordinates of the pointer location, in surface-local coordinates.
|
||||
|
||||
On :func:`WlSurface.offset()
|
||||
<pywayland.protocol.wayland.WlSurface.offset>` requests to the pointer
|
||||
surface, hotspot_x and hotspot_y are decremented by the x and y
|
||||
parameters passed to the request. The offset must be applied by
|
||||
:func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` as usual.
|
||||
|
||||
The hotspot can also be updated by passing the currently set pointer
|
||||
surface to this request with new values for hotspot_x and hotspot_y.
|
||||
|
||||
The input region is ignored for wl_surfaces with the role of a cursor.
|
||||
When the use as a cursor ends, the
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` is unmapped.
|
||||
|
||||
The serial parameter must match the latest :func:`WlPointer.enter()`
|
||||
serial number sent to the client. Otherwise the request will be
|
||||
ignored.
|
||||
|
||||
:param serial:
|
||||
serial number of the enter event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
pointer surface
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` or `None`
|
||||
:param hotspot_x:
|
||||
surface-local x coordinate
|
||||
:type hotspot_x:
|
||||
`ArgumentType.Int`
|
||||
:param hotspot_y:
|
||||
surface-local y coordinate
|
||||
:type hotspot_y:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(0, serial, surface, hotspot_x, hotspot_y)
|
||||
|
||||
@WlPointer.request(version=3)
|
||||
def release(self) -> None:
|
||||
"""Release the pointer object
|
||||
|
||||
Using this request a client can tell the server that it is not going to
|
||||
use the pointer object anymore.
|
||||
|
||||
This request destroys the pointer proxy object, so clients must not
|
||||
call wl_pointer_destroy() after using this request.
|
||||
"""
|
||||
self._marshal(1)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlPointerResource(Resource):
|
||||
interface = WlPointer
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
)
|
||||
def enter(self, serial: int, surface: WlSurface, surface_x: float, surface_y: float) -> None:
|
||||
"""Enter event
|
||||
|
||||
Notification that this seat's pointer is focused on a certain surface.
|
||||
|
||||
When a seat's focus enters a surface, the pointer image is undefined
|
||||
and a client should respond to this event by setting an appropriate
|
||||
pointer image with the set_cursor request.
|
||||
|
||||
:param serial:
|
||||
serial number of the enter event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
surface entered by the pointer
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param surface_x:
|
||||
surface-local x coordinate
|
||||
:type surface_x:
|
||||
`ArgumentType.Fixed`
|
||||
:param surface_y:
|
||||
surface-local y coordinate
|
||||
:type surface_y:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(0, serial, surface, surface_x, surface_y)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
)
|
||||
def leave(self, serial: int, surface: WlSurface) -> None:
|
||||
"""Leave event
|
||||
|
||||
Notification that this seat's pointer is no longer focused on a certain
|
||||
surface.
|
||||
|
||||
The leave notification is sent before the enter notification for the
|
||||
new focus.
|
||||
|
||||
:param serial:
|
||||
serial number of the leave event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
surface left by the pointer
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
"""
|
||||
self._post_event(1, serial, surface)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
)
|
||||
def motion(self, time: int, surface_x: float, surface_y: float) -> None:
|
||||
"""Pointer motion event
|
||||
|
||||
Notification of pointer location change. The arguments surface_x and
|
||||
surface_y are the location relative to the focused surface.
|
||||
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param surface_x:
|
||||
surface-local x coordinate
|
||||
:type surface_x:
|
||||
`ArgumentType.Fixed`
|
||||
:param surface_y:
|
||||
surface-local y coordinate
|
||||
:type surface_y:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(2, time, surface_x, surface_y)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def button(self, serial: int, time: int, button: int, state: int) -> None:
|
||||
"""Pointer button event
|
||||
|
||||
Mouse button click and release notifications.
|
||||
|
||||
The location of the click is given by the last motion, warp or enter
|
||||
event. The time argument is a timestamp with millisecond granularity,
|
||||
with an undefined base.
|
||||
|
||||
The button is a button code as defined in the Linux kernel's
|
||||
linux/input-event-codes.h header file, e.g. BTN_LEFT.
|
||||
|
||||
Any 16-bit button code value is reserved for future additions to the
|
||||
kernel's event code list. All other button codes above 0xFFFF are
|
||||
currently undefined but may be used in future versions of this
|
||||
protocol.
|
||||
|
||||
:param serial:
|
||||
serial number of the button event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param button:
|
||||
button that produced the event
|
||||
:type button:
|
||||
`ArgumentType.Uint`
|
||||
:param state:
|
||||
physical state of the button
|
||||
:type state:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(3, serial, time, button, state)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Fixed),
|
||||
)
|
||||
def axis(self, time: int, axis: int, value: float) -> None:
|
||||
"""Axis event
|
||||
|
||||
Scroll and other axis notifications.
|
||||
|
||||
For scroll events (vertical and horizontal scroll axes), the value
|
||||
parameter is the length of a vector along the specified axis in a
|
||||
coordinate space identical to those of motion events, representing a
|
||||
relative movement along the specified axis.
|
||||
|
||||
For devices that support movements non-parallel to axes multiple axis
|
||||
events will be emitted.
|
||||
|
||||
When applicable, for example for touch pads, the server can choose to
|
||||
emit scroll events where the motion vector is equivalent to a motion
|
||||
event vector.
|
||||
|
||||
When applicable, a client can transform its content relative to the
|
||||
scroll distance.
|
||||
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param axis:
|
||||
axis type
|
||||
:type axis:
|
||||
`ArgumentType.Uint`
|
||||
:param value:
|
||||
length of vector in surface-local coordinate space
|
||||
:type value:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(4, time, axis, value)
|
||||
|
||||
@WlPointer.event(version=5)
|
||||
def frame(self) -> None:
|
||||
"""End of a pointer event sequence
|
||||
|
||||
Indicates the end of a set of events that logically belong together. A
|
||||
client is expected to accumulate the data in all events within the
|
||||
frame before proceeding.
|
||||
|
||||
All :class:`WlPointer` events before a :func:`WlPointer.frame()` event
|
||||
belong logically together. For example, in a diagonal scroll motion the
|
||||
compositor will send an optional :func:`WlPointer.axis_source()` event,
|
||||
two :func:`WlPointer.axis()` events (horizontal and vertical) and
|
||||
finally a :func:`WlPointer.frame()` event. The client may use this
|
||||
information to calculate a diagonal vector for scrolling.
|
||||
|
||||
When multiple :func:`WlPointer.axis()` events occur within the same
|
||||
frame, the motion vector is the combined motion of all events. When a
|
||||
:func:`WlPointer.axis()` and a :func:`WlPointer.axis_stop()` event
|
||||
occur within the same frame, this indicates that axis movement in one
|
||||
axis has stopped but continues in the other axis. When multiple
|
||||
:func:`WlPointer.axis_stop()` events occur within the same frame, this
|
||||
indicates that these axes stopped in the same instance.
|
||||
|
||||
A :func:`WlPointer.frame()` event is sent for every logical event
|
||||
group, even if the group only contains a single :class:`WlPointer`
|
||||
event. Specifically, a client may get a sequence: motion, frame,
|
||||
button, frame, axis, frame, axis_stop, frame.
|
||||
|
||||
The :func:`WlPointer.enter()` and :func:`WlPointer.leave()` events are
|
||||
logical events generated by the compositor and not the hardware. These
|
||||
events are also grouped by a :func:`WlPointer.frame()`. When a pointer
|
||||
moves from one surface to another, a compositor should group the
|
||||
:func:`WlPointer.leave()` event within the same
|
||||
:func:`WlPointer.frame()`. However, a client must not rely on
|
||||
:func:`WlPointer.leave()` and :func:`WlPointer.enter()` being in the
|
||||
same :func:`WlPointer.frame()`. Compositor-specific policies may
|
||||
require the :func:`WlPointer.leave()` and :func:`WlPointer.enter()`
|
||||
event being split across multiple :func:`WlPointer.frame()` groups.
|
||||
"""
|
||||
self._post_event(5)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
version=5,
|
||||
)
|
||||
def axis_source(self, axis_source: int) -> None:
|
||||
"""Axis source event
|
||||
|
||||
Source information for scroll and other axes.
|
||||
|
||||
This event does not occur on its own. It is sent before a
|
||||
:func:`WlPointer.frame()` event and carries the source information for
|
||||
all events within that frame.
|
||||
|
||||
The source specifies how this event was generated. If the source is
|
||||
:func:`WlPointer.axis_source()`.finger, a :func:`WlPointer.axis_stop()`
|
||||
event will be sent when the user lifts the finger off the device.
|
||||
|
||||
If the source is :func:`WlPointer.axis_source()`.wheel,
|
||||
:func:`WlPointer.axis_source()`.wheel_tilt or
|
||||
:func:`WlPointer.axis_source()`.continuous, a
|
||||
:func:`WlPointer.axis_stop()` event may or may not be sent. Whether a
|
||||
compositor sends an axis_stop event for these sources is hardware-
|
||||
specific and implementation-dependent; clients must not rely on
|
||||
receiving an axis_stop event for these scroll sources and should treat
|
||||
scroll sequences from these scroll sources as unterminated by default.
|
||||
|
||||
This event is optional. If the source is unknown for a particular axis
|
||||
event sequence, no event is sent. Only one
|
||||
:func:`WlPointer.axis_source()` event is permitted per frame.
|
||||
|
||||
The order of :func:`WlPointer.axis_discrete()` and
|
||||
:func:`WlPointer.axis_source()` is not guaranteed.
|
||||
|
||||
:param axis_source:
|
||||
source of the axis event
|
||||
:type axis_source:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(6, axis_source)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
version=5,
|
||||
)
|
||||
def axis_stop(self, time: int, axis: int) -> None:
|
||||
"""Axis stop event
|
||||
|
||||
Stop notification for scroll and other axes.
|
||||
|
||||
For some :func:`WlPointer.axis_source()` types, a
|
||||
:func:`WlPointer.axis_stop()` event is sent to notify a client that the
|
||||
axis sequence has terminated. This enables the client to implement
|
||||
kinetic scrolling. See the :func:`WlPointer.axis_source()`
|
||||
documentation for information on when this event may be generated.
|
||||
|
||||
Any :func:`WlPointer.axis()` events with the same axis_source after
|
||||
this event should be considered as the start of a new axis motion.
|
||||
|
||||
The timestamp is to be interpreted identical to the timestamp in the
|
||||
:func:`WlPointer.axis()` event. The timestamp value may be the same as
|
||||
a preceding :func:`WlPointer.axis()` event.
|
||||
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param axis:
|
||||
the axis stopped with this event
|
||||
:type axis:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(7, time, axis)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Int),
|
||||
version=5,
|
||||
)
|
||||
def axis_discrete(self, axis: int, discrete: int) -> None:
|
||||
"""Axis click event
|
||||
|
||||
Discrete step information for scroll and other axes.
|
||||
|
||||
This event carries the axis value of the :func:`WlPointer.axis()` event
|
||||
in discrete steps (e.g. mouse wheel clicks).
|
||||
|
||||
This event is deprecated with :class:`WlPointer` version 8 - this event
|
||||
is not sent to clients supporting version 8 or later.
|
||||
|
||||
This event does not occur on its own, it is coupled with a
|
||||
:func:`WlPointer.axis()` event that represents this axis value on a
|
||||
continuous scale. The protocol guarantees that each axis_discrete event
|
||||
is always followed by exactly one axis event with the same axis number
|
||||
within the same :func:`WlPointer.frame()`. Note that the protocol
|
||||
allows for other events to occur between the axis_discrete and its
|
||||
coupled axis event, including other axis_discrete or axis events. A
|
||||
:func:`WlPointer.frame()` must not contain more than one axis_discrete
|
||||
event per axis type.
|
||||
|
||||
This event is optional; continuous scrolling devices like two-finger
|
||||
scrolling on touchpads do not have discrete steps and do not generate
|
||||
this event.
|
||||
|
||||
The discrete value carries the directional information. e.g. a value of
|
||||
-2 is two steps towards the negative direction of this axis.
|
||||
|
||||
The axis number is identical to the axis number in the associated axis
|
||||
event.
|
||||
|
||||
The order of :func:`WlPointer.axis_discrete()` and
|
||||
:func:`WlPointer.axis_source()` is not guaranteed.
|
||||
|
||||
:param axis:
|
||||
axis type
|
||||
:type axis:
|
||||
`ArgumentType.Uint`
|
||||
:param discrete:
|
||||
number of steps
|
||||
:type discrete:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(8, axis, discrete)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Int),
|
||||
version=8,
|
||||
)
|
||||
def axis_value120(self, axis: int, value120: int) -> None:
|
||||
"""Axis high-resolution scroll event
|
||||
|
||||
Discrete high-resolution scroll information.
|
||||
|
||||
This event carries high-resolution wheel scroll information, with each
|
||||
multiple of 120 representing one logical scroll step (a wheel detent).
|
||||
For example, an axis_value120 of 30 is one quarter of a logical scroll
|
||||
step in the positive direction, a value120 of -240 are two logical
|
||||
scroll steps in the negative direction within the same hardware event.
|
||||
Clients that rely on discrete scrolling should accumulate the value120
|
||||
to multiples of 120 before processing the event.
|
||||
|
||||
The value120 must not be zero.
|
||||
|
||||
This event replaces the :func:`WlPointer.axis_discrete()` event in
|
||||
clients supporting :class:`WlPointer` version 8 or later.
|
||||
|
||||
Where a :func:`WlPointer.axis_source()` event occurs in the same
|
||||
:func:`WlPointer.frame()`, the axis source applies to this event.
|
||||
|
||||
The order of :class:`WlPointer`.axis_value120 and
|
||||
:func:`WlPointer.axis_source()` is not guaranteed.
|
||||
|
||||
:param axis:
|
||||
axis type
|
||||
:type axis:
|
||||
`ArgumentType.Uint`
|
||||
:param value120:
|
||||
scroll distance as fraction of 120
|
||||
:type value120:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(9, axis, value120)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
version=9,
|
||||
)
|
||||
def axis_relative_direction(self, axis: int, direction: int) -> None:
|
||||
"""Axis relative physical direction event
|
||||
|
||||
Relative directional information of the entity causing the axis motion.
|
||||
|
||||
For a :func:`WlPointer.axis()` event, the
|
||||
:func:`WlPointer.axis_relative_direction()` event specifies the
|
||||
movement direction of the entity causing the :func:`WlPointer.axis()`
|
||||
event. For example: - if a user's fingers on a touchpad move down and
|
||||
this causes a :func:`WlPointer.axis()` vertical_scroll down event,
|
||||
the physical direction is 'identical' - if a user's fingers on a
|
||||
touchpad move down and this causes a :func:`WlPointer.axis()`
|
||||
vertical_scroll up scroll up event ('natural scrolling'), the
|
||||
physical direction is 'inverted'.
|
||||
|
||||
A client may use this information to adjust scroll motion of
|
||||
components. Specifically, enabling natural scrolling causes the content
|
||||
to change direction compared to traditional scrolling. Some widgets
|
||||
like volume control sliders should usually match the physical direction
|
||||
regardless of whether natural scrolling is active. This event enables
|
||||
clients to match the scroll direction of a widget to the physical
|
||||
direction.
|
||||
|
||||
This event does not occur on its own, it is coupled with a
|
||||
:func:`WlPointer.axis()` event that represents this axis value. The
|
||||
protocol guarantees that each axis_relative_direction event is always
|
||||
followed by exactly one axis event with the same axis number within the
|
||||
same :func:`WlPointer.frame()`. Note that the protocol allows for other
|
||||
events to occur between the axis_relative_direction and its coupled
|
||||
axis event.
|
||||
|
||||
The axis number is identical to the axis number in the associated axis
|
||||
event.
|
||||
|
||||
The order of :func:`WlPointer.axis_relative_direction()`,
|
||||
:func:`WlPointer.axis_discrete()` and :func:`WlPointer.axis_source()`
|
||||
is not guaranteed.
|
||||
|
||||
:param axis:
|
||||
axis type
|
||||
:type axis:
|
||||
`ArgumentType.Uint`
|
||||
:param direction:
|
||||
physical direction relative to axis motion
|
||||
:type direction:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(10, axis, direction)
|
||||
|
||||
@WlPointer.event(
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
version=11,
|
||||
)
|
||||
def warp(self, surface_x: float, surface_y: float) -> None:
|
||||
"""Pointer warp event
|
||||
|
||||
Notification of pointer location change within a surface.
|
||||
|
||||
This location change is not due to events on the input device, but
|
||||
because either the surface under the pointer was moved and thus the
|
||||
relative position of the pointer changed, or because the compositor
|
||||
changed the pointer position in response to an event like pointer
|
||||
confinement being exited.
|
||||
|
||||
The arguments surface_x and surface_y are the location relative to the
|
||||
focused surface.
|
||||
|
||||
This event must not occur in the same :func:`WlPointer.frame()` as a
|
||||
:func:`WlPointer.enter()` or :func:`WlPointer.motion()` event.
|
||||
|
||||
:param surface_x:
|
||||
surface-local x coordinate
|
||||
:type surface_x:
|
||||
`ArgumentType.Fixed`
|
||||
:param surface_y:
|
||||
surface-local y coordinate
|
||||
:type surface_y:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(11, surface_x, surface_y)
|
||||
|
||||
|
||||
class WlPointerGlobal(Global):
|
||||
interface = WlPointer
|
||||
|
||||
|
||||
WlPointer._gen_c()
|
||||
WlPointer.proxy_class = WlPointerProxy
|
||||
WlPointer.resource_class = WlPointerResource
|
||||
WlPointer.global_class = WlPointerGlobal
|
||||
@@ -0,0 +1,137 @@
|
||||
# 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
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
|
||||
class WlRegion(Interface):
|
||||
"""Region interface
|
||||
|
||||
A region object describes an area.
|
||||
|
||||
Region objects are used to describe the opaque and input regions of a
|
||||
surface.
|
||||
"""
|
||||
|
||||
name = "wl_region"
|
||||
version = 7
|
||||
|
||||
|
||||
class WlRegionProxy(Proxy[WlRegion]):
|
||||
interface = WlRegion
|
||||
|
||||
@WlRegion.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroy region
|
||||
|
||||
Destroy the region. This will invalidate the object ID.
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
@WlRegion.request(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def add(self, x: int, y: int, width: int, height: int) -> None:
|
||||
"""Add rectangle to region
|
||||
|
||||
Add the specified rectangle to the region.
|
||||
|
||||
:param x:
|
||||
region-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
region-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param width:
|
||||
rectangle width
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
rectangle height
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(1, x, y, width, height)
|
||||
|
||||
@WlRegion.request(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def subtract(self, x: int, y: int, width: int, height: int) -> None:
|
||||
"""Subtract rectangle from region
|
||||
|
||||
Subtract the specified rectangle from the region.
|
||||
|
||||
:param x:
|
||||
region-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
region-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param width:
|
||||
rectangle width
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
rectangle height
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(2, x, y, width, height)
|
||||
|
||||
|
||||
class WlRegionResource(Resource):
|
||||
interface = WlRegion
|
||||
|
||||
|
||||
class WlRegionGlobal(Global):
|
||||
interface = WlRegion
|
||||
|
||||
|
||||
WlRegion._gen_c()
|
||||
WlRegion.proxy_class = WlRegionProxy
|
||||
WlRegion.resource_class = WlRegionResource
|
||||
WlRegion.global_class = WlRegionGlobal
|
||||
@@ -0,0 +1,167 @@
|
||||
# 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
|
||||
|
||||
from typing import TypeVar
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
T = TypeVar("T", bound=Interface)
|
||||
|
||||
|
||||
class WlRegistry(Interface):
|
||||
"""Global registry object
|
||||
|
||||
The singleton global registry object. The server has a number of global
|
||||
objects that are available to all clients. These objects typically
|
||||
represent an actual object in the server (for example, an input device) or
|
||||
they are singleton objects that provide extension functionality.
|
||||
|
||||
When a client creates a registry object, the registry object will emit a
|
||||
global event for each global currently in the registry. Globals come and
|
||||
go as a result of device or monitor hotplugs, reconfiguration or other
|
||||
events, and the registry will send out global and global_remove events to
|
||||
keep the client up to date with the changes. To mark the end of the
|
||||
initial burst of events, the client can use the :func:`WlDisplay.sync()
|
||||
<pywayland.protocol.wayland.WlDisplay.sync>` request immediately after
|
||||
calling :func:`WlDisplay.get_registry()
|
||||
<pywayland.protocol.wayland.WlDisplay.get_registry>`.
|
||||
|
||||
A client can bind to a global object by using the bind request. This
|
||||
creates a client-side handle that lets the object emit events to the client
|
||||
and lets the client invoke requests on the object.
|
||||
"""
|
||||
|
||||
name = "wl_registry"
|
||||
version = 1
|
||||
|
||||
|
||||
class WlRegistryProxy(Proxy[WlRegistry]):
|
||||
interface = WlRegistry
|
||||
|
||||
@WlRegistry.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.NewId),
|
||||
)
|
||||
def bind(self, name: int, interface: type[T], version: int) -> Proxy[T]:
|
||||
"""Bind an object to the display
|
||||
|
||||
Binds a new, client-created object to the server using the specified
|
||||
name as the identifier.
|
||||
|
||||
:param name:
|
||||
unique numeric name of the object
|
||||
:type name:
|
||||
`ArgumentType.Uint`
|
||||
:param interface:
|
||||
Interface name
|
||||
:type interface:
|
||||
`string`
|
||||
:param version:
|
||||
Interface version
|
||||
:type version:
|
||||
`int`
|
||||
:returns:
|
||||
:class:`pywayland.client.proxy.Proxy` of specified Interface --
|
||||
bound object
|
||||
"""
|
||||
id = self._marshal_constructor(0, interface, name, interface.name, version)
|
||||
return id
|
||||
|
||||
|
||||
class WlRegistryResource(Resource):
|
||||
interface = WlRegistry
|
||||
|
||||
@WlRegistry.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.String),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def global_(self, name: int, interface: str, version: int) -> None:
|
||||
"""Announce global object
|
||||
|
||||
Notify the client of global objects.
|
||||
|
||||
The event notifies the client that a global object with the given name
|
||||
is now available, and it implements the given version of the given
|
||||
interface.
|
||||
|
||||
:param name:
|
||||
numeric name of the global object
|
||||
:type name:
|
||||
`ArgumentType.Uint`
|
||||
:param interface:
|
||||
interface implemented by the object
|
||||
:type interface:
|
||||
`ArgumentType.String`
|
||||
:param version:
|
||||
interface version
|
||||
:type version:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, name, interface, version)
|
||||
|
||||
@WlRegistry.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def global_remove(self, name: int) -> None:
|
||||
"""Announce removal of global object
|
||||
|
||||
Notify the client of removed global objects.
|
||||
|
||||
This event notifies the client that the global identified by name is no
|
||||
longer available. If the client bound to the global using the bind
|
||||
request, the client should now destroy that object.
|
||||
|
||||
The object remains valid and requests to the object will be ignored
|
||||
until the client destroys it, to avoid races between the global going
|
||||
away and a client sending a request to it.
|
||||
|
||||
:param name:
|
||||
numeric name of the global object
|
||||
:type name:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(1, name)
|
||||
|
||||
|
||||
class WlRegistryGlobal(Global):
|
||||
interface = WlRegistry
|
||||
|
||||
|
||||
WlRegistry._gen_c()
|
||||
WlRegistry.proxy_class = WlRegistryProxy
|
||||
WlRegistry.resource_class = WlRegistryResource
|
||||
WlRegistry.global_class = WlRegistryGlobal
|
||||
@@ -0,0 +1,234 @@
|
||||
# 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_keyboard import WlKeyboard
|
||||
from .wl_pointer import WlPointer
|
||||
from .wl_touch import WlTouch
|
||||
|
||||
|
||||
class WlSeat(Interface):
|
||||
"""Group of input devices
|
||||
|
||||
A seat is a group of keyboards, pointer and touch devices. This object is
|
||||
published as a global during start up, or when such a device is hot
|
||||
plugged. A seat typically has a pointer and maintains a keyboard focus and
|
||||
a pointer focus.
|
||||
"""
|
||||
|
||||
name = "wl_seat"
|
||||
version = 11
|
||||
|
||||
class capability(enum.IntFlag):
|
||||
pointer = 1
|
||||
keyboard = 2
|
||||
touch = 4
|
||||
|
||||
class error(enum.IntEnum):
|
||||
missing_capability = 0
|
||||
|
||||
|
||||
class WlSeatProxy(Proxy[WlSeat]):
|
||||
interface = WlSeat
|
||||
|
||||
@WlSeat.request(
|
||||
Argument(ArgumentType.NewId, interface=WlPointer),
|
||||
)
|
||||
def get_pointer(self) -> Proxy[WlPointer]:
|
||||
"""Return pointer object
|
||||
|
||||
The ID provided will be initialized to the
|
||||
:class:`~pywayland.protocol.wayland.WlPointer` interface for this seat.
|
||||
|
||||
This request only takes effect if the seat has the pointer capability,
|
||||
or has had the pointer capability in the past. It is a protocol
|
||||
violation to issue this request on a seat that has never had the
|
||||
pointer capability. The missing_capability error will be sent in this
|
||||
case.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlPointer` -- seat pointer
|
||||
"""
|
||||
id = self._marshal_constructor(0, WlPointer)
|
||||
return id
|
||||
|
||||
@WlSeat.request(
|
||||
Argument(ArgumentType.NewId, interface=WlKeyboard),
|
||||
)
|
||||
def get_keyboard(self) -> Proxy[WlKeyboard]:
|
||||
"""Return keyboard object
|
||||
|
||||
The ID provided will be initialized to the
|
||||
:class:`~pywayland.protocol.wayland.WlKeyboard` interface for this
|
||||
seat.
|
||||
|
||||
This request only takes effect if the seat has the keyboard capability,
|
||||
or has had the keyboard capability in the past. It is a protocol
|
||||
violation to issue this request on a seat that has never had the
|
||||
keyboard capability. The missing_capability error will be sent in this
|
||||
case.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlKeyboard` -- seat keyboard
|
||||
"""
|
||||
id = self._marshal_constructor(1, WlKeyboard)
|
||||
return id
|
||||
|
||||
@WlSeat.request(
|
||||
Argument(ArgumentType.NewId, interface=WlTouch),
|
||||
)
|
||||
def get_touch(self) -> Proxy[WlTouch]:
|
||||
"""Return touch object
|
||||
|
||||
The ID provided will be initialized to the
|
||||
:class:`~pywayland.protocol.wayland.WlTouch` interface for this seat.
|
||||
|
||||
This request only takes effect if the seat has the touch capability, or
|
||||
has had the touch capability in the past. It is a protocol violation to
|
||||
issue this request on a seat that has never had the touch capability.
|
||||
The missing_capability error will be sent in this case.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlTouch` -- seat touch
|
||||
interface
|
||||
"""
|
||||
id = self._marshal_constructor(2, WlTouch)
|
||||
return id
|
||||
|
||||
@WlSeat.request(version=5)
|
||||
def release(self) -> None:
|
||||
"""Release the seat object
|
||||
|
||||
Using this request a client can tell the server that it is not going to
|
||||
use the seat object anymore.
|
||||
"""
|
||||
self._marshal(3)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlSeatResource(Resource):
|
||||
interface = WlSeat
|
||||
|
||||
@WlSeat.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def capabilities(self, capabilities: int) -> None:
|
||||
"""Seat capabilities changed
|
||||
|
||||
This is sent on binding to the seat global or whenever a seat gains or
|
||||
loses the pointer, keyboard or touch capabilities. The argument is a
|
||||
capability enum containing the complete set of capabilities this seat
|
||||
has.
|
||||
|
||||
When the pointer capability is added, a client may create a
|
||||
:class:`~pywayland.protocol.wayland.WlPointer` object using the
|
||||
:func:`WlSeat.get_pointer()` request. This object will receive pointer
|
||||
events until the capability is removed in the future.
|
||||
|
||||
When the pointer capability is removed, a client should destroy the
|
||||
:class:`~pywayland.protocol.wayland.WlPointer` objects associated with
|
||||
the seat where the capability was removed, using the
|
||||
:func:`WlPointer.release()
|
||||
<pywayland.protocol.wayland.WlPointer.release>` request. No further
|
||||
pointer events will be received on these objects.
|
||||
|
||||
In some compositors, if a seat regains the pointer capability and a
|
||||
client has a previously obtained
|
||||
:class:`~pywayland.protocol.wayland.WlPointer` object of version 4 or
|
||||
less, that object may start sending pointer events again. This behavior
|
||||
is considered a misinterpretation of the intended behavior and must not
|
||||
be relied upon by the client.
|
||||
:class:`~pywayland.protocol.wayland.WlPointer` objects of version 5 or
|
||||
later must not send events if created before the most recent event
|
||||
notifying the client of an added pointer capability.
|
||||
|
||||
The above behavior also applies to
|
||||
:class:`~pywayland.protocol.wayland.WlKeyboard` and
|
||||
:class:`~pywayland.protocol.wayland.WlTouch` with the keyboard and
|
||||
touch capabilities, respectively.
|
||||
|
||||
:param capabilities:
|
||||
capabilities of the seat
|
||||
:type capabilities:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, capabilities)
|
||||
|
||||
@WlSeat.event(
|
||||
Argument(ArgumentType.String),
|
||||
version=2,
|
||||
)
|
||||
def name(self, name: str) -> None:
|
||||
"""Unique identifier for this seat
|
||||
|
||||
In a multi-seat configuration the seat name can be used by clients to
|
||||
help identify which physical devices the seat represents.
|
||||
|
||||
The seat name is a UTF-8 string with no convention defined for its
|
||||
contents. Each name is unique among all :class:`WlSeat` globals. The
|
||||
name is only guaranteed to be unique for the current compositor
|
||||
instance.
|
||||
|
||||
The same seat names are used for all clients. Thus, the name can be
|
||||
shared across processes to refer to a specific :class:`WlSeat` global.
|
||||
|
||||
The name event is sent after binding to the seat global, and should be
|
||||
sent before announcing capabilities. This event is only sent once per
|
||||
seat object, and the name does not change over the lifetime of the
|
||||
:class:`WlSeat` global.
|
||||
|
||||
Compositors may re-use the same seat name if the :class:`WlSeat` global
|
||||
is destroyed and re-created later.
|
||||
|
||||
:param name:
|
||||
seat identifier
|
||||
:type name:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._post_event(1, name)
|
||||
|
||||
|
||||
class WlSeatGlobal(Global):
|
||||
interface = WlSeat
|
||||
|
||||
|
||||
WlSeat._gen_c()
|
||||
WlSeat.proxy_class = WlSeatProxy
|
||||
WlSeat.resource_class = WlSeatResource
|
||||
WlSeat.global_class = WlSeatGlobal
|
||||
@@ -0,0 +1,106 @@
|
||||
# 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_shell_surface import WlShellSurface
|
||||
from .wl_surface import WlSurface
|
||||
|
||||
|
||||
class WlShell(Interface):
|
||||
"""Create desktop-style surfaces
|
||||
|
||||
This interface is implemented by servers that provide desktop-style user
|
||||
interfaces.
|
||||
|
||||
It allows clients to associate a
|
||||
:class:`~pywayland.protocol.wayland.WlShellSurface` with a basic surface.
|
||||
|
||||
Note! This protocol is deprecated and not intended for production use. For
|
||||
desktop-style user interfaces, use xdg_shell. Compositors and clients
|
||||
should not implement this interface.
|
||||
"""
|
||||
|
||||
name = "wl_shell"
|
||||
version = 1
|
||||
|
||||
class error(enum.IntEnum):
|
||||
role = 0
|
||||
|
||||
|
||||
class WlShellProxy(Proxy[WlShell]):
|
||||
interface = WlShell
|
||||
|
||||
@WlShell.request(
|
||||
Argument(ArgumentType.NewId, interface=WlShellSurface),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
)
|
||||
def get_shell_surface(self, surface: WlSurface) -> Proxy[WlShellSurface]:
|
||||
"""Create a shell surface from a surface
|
||||
|
||||
Create a shell surface for an existing surface. This gives the
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` the role of a shell
|
||||
surface. If the :class:`~pywayland.protocol.wayland.WlSurface` already
|
||||
has another role, it raises a protocol error.
|
||||
|
||||
Only one shell surface can be associated with a given surface.
|
||||
|
||||
:param surface:
|
||||
surface to be given the shell surface role
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlShellSurface` -- shell
|
||||
surface to create
|
||||
"""
|
||||
id = self._marshal_constructor(0, WlShellSurface, surface)
|
||||
return id
|
||||
|
||||
|
||||
class WlShellResource(Resource):
|
||||
interface = WlShell
|
||||
|
||||
|
||||
class WlShellGlobal(Global):
|
||||
interface = WlShell
|
||||
|
||||
|
||||
WlShell._gen_c()
|
||||
WlShell.proxy_class = WlShellProxy
|
||||
WlShell.resource_class = WlShellResource
|
||||
WlShell.global_class = WlShellGlobal
|
||||
@@ -0,0 +1,463 @@
|
||||
# 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_output import WlOutput
|
||||
from .wl_seat import WlSeat
|
||||
from .wl_surface import WlSurface
|
||||
|
||||
|
||||
class WlShellSurface(Interface):
|
||||
"""Desktop-style metadata interface
|
||||
|
||||
An interface that may be implemented by a
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`, for implementations that
|
||||
provide a desktop-style user interface.
|
||||
|
||||
It provides requests to treat surfaces like toplevel, fullscreen or popup
|
||||
windows, move, resize or maximize them, associate metadata like title and
|
||||
class, etc.
|
||||
|
||||
On the server side the object is automatically destroyed when the related
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` is destroyed. On the client
|
||||
side, wl_shell_surface_destroy() must be called before destroying the
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` object.
|
||||
"""
|
||||
|
||||
name = "wl_shell_surface"
|
||||
version = 1
|
||||
|
||||
class resize(enum.IntFlag):
|
||||
none = 0
|
||||
top = 1
|
||||
bottom = 2
|
||||
left = 4
|
||||
top_left = 5
|
||||
bottom_left = 6
|
||||
right = 8
|
||||
top_right = 9
|
||||
bottom_right = 10
|
||||
|
||||
class transient(enum.IntFlag):
|
||||
inactive = 0x1
|
||||
|
||||
class fullscreen_method(enum.IntEnum):
|
||||
default = 0
|
||||
scale = 1
|
||||
driver = 2
|
||||
fill = 3
|
||||
|
||||
|
||||
class WlShellSurfaceProxy(Proxy[WlShellSurface]):
|
||||
interface = WlShellSurface
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def pong(self, serial: int) -> None:
|
||||
"""Respond to a ping event
|
||||
|
||||
A client must respond to a ping event with a pong request or the client
|
||||
may be deemed unresponsive.
|
||||
|
||||
:param serial:
|
||||
serial number of the ping event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(0, serial)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlSeat),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def move(self, seat: WlSeat, serial: int) -> None:
|
||||
"""Start an interactive move
|
||||
|
||||
Start a pointer-driven move of the surface.
|
||||
|
||||
This request must be used in response to a button press event. The
|
||||
server may ignore move requests depending on the state of the surface
|
||||
(e.g. fullscreen or maximized).
|
||||
|
||||
:param seat:
|
||||
seat whose pointer is used
|
||||
:type seat:
|
||||
:class:`~pywayland.protocol.wayland.WlSeat`
|
||||
:param serial:
|
||||
serial number of the implicit grab on the pointer
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(1, seat, serial)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlSeat),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def resize(self, seat: WlSeat, serial: int, edges: int) -> None:
|
||||
"""Start an interactive resize
|
||||
|
||||
Start a pointer-driven resizing of the surface.
|
||||
|
||||
This request must be used in response to a button press event. The
|
||||
server may ignore resize requests depending on the state of the surface
|
||||
(e.g. fullscreen or maximized).
|
||||
|
||||
:param seat:
|
||||
seat whose pointer is used
|
||||
:type seat:
|
||||
:class:`~pywayland.protocol.wayland.WlSeat`
|
||||
:param serial:
|
||||
serial number of the implicit grab on the pointer
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param edges:
|
||||
which edge or corner is being dragged
|
||||
:type edges:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(2, seat, serial, edges)
|
||||
|
||||
@WlShellSurface.request()
|
||||
def set_toplevel(self) -> None:
|
||||
"""Make the surface a toplevel surface
|
||||
|
||||
Map the surface as a toplevel surface.
|
||||
|
||||
A toplevel surface is not fullscreen, maximized or transient.
|
||||
"""
|
||||
self._marshal(3)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def set_transient(self, parent: WlSurface, x: int, y: int, flags: int) -> None:
|
||||
"""Make the surface a transient surface
|
||||
|
||||
Map the surface relative to an existing surface.
|
||||
|
||||
The x and y arguments specify the location of the upper left corner of
|
||||
the surface relative to the upper left corner of the parent surface, in
|
||||
surface-local coordinates.
|
||||
|
||||
The flags argument controls details of the transient behaviour.
|
||||
|
||||
:param parent:
|
||||
parent surface
|
||||
:type parent:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param flags:
|
||||
transient surface behavior
|
||||
:type flags:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(4, parent, x, y, flags)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlOutput, nullable=True),
|
||||
)
|
||||
def set_fullscreen(self, method: int, framerate: int, output: WlOutput | None) -> None:
|
||||
"""Make the surface a fullscreen surface
|
||||
|
||||
Map the surface as a fullscreen surface.
|
||||
|
||||
If an output parameter is given then the surface will be made
|
||||
fullscreen on that output. If the client does not specify the output
|
||||
then the compositor will apply its policy - usually choosing the output
|
||||
on which the surface has the biggest surface area.
|
||||
|
||||
The client may specify a method to resolve a size conflict between the
|
||||
output size and the surface size - this is provided through the method
|
||||
parameter.
|
||||
|
||||
The framerate parameter is used only when the method is set to
|
||||
"driver", to indicate the preferred framerate. A value of 0 indicates
|
||||
that the client does not care about framerate. The framerate is
|
||||
specified in mHz, that is framerate of 60000 is 60Hz.
|
||||
|
||||
A method of "scale" or "driver" implies a scaling operation of the
|
||||
surface, either via a direct scaling operation or a change of the
|
||||
output mode. This will override any kind of output scaling, so that
|
||||
mapping a surface with a buffer size equal to the mode can fill the
|
||||
screen independent of buffer_scale.
|
||||
|
||||
A method of "fill" means we don't scale up the buffer, however any
|
||||
output scale is applied. This means that you may run into an edge case
|
||||
where the application maps a buffer with the same size of the output
|
||||
mode but buffer_scale 1 (thus making a surface larger than the output).
|
||||
In this case it is allowed to downscale the results to fit the screen.
|
||||
|
||||
The compositor must reply to this request with a configure event with
|
||||
the dimensions for the output on which the surface will be made
|
||||
fullscreen.
|
||||
|
||||
:param method:
|
||||
method for resolving size conflict
|
||||
:type method:
|
||||
`ArgumentType.Uint`
|
||||
:param framerate:
|
||||
framerate in mHz
|
||||
:type framerate:
|
||||
`ArgumentType.Uint`
|
||||
:param output:
|
||||
output on which the surface is to be fullscreen
|
||||
:type output:
|
||||
:class:`~pywayland.protocol.wayland.WlOutput` or `None`
|
||||
"""
|
||||
self._marshal(5, method, framerate, output)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlSeat),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def set_popup(self, seat: WlSeat, serial: int, parent: WlSurface, x: int, y: int, flags: int) -> None:
|
||||
"""Make the surface a popup surface
|
||||
|
||||
Map the surface as a popup.
|
||||
|
||||
A popup surface is a transient surface with an added pointer grab.
|
||||
|
||||
An existing implicit grab will be changed to owner-events mode, and the
|
||||
popup grab will continue after the implicit grab ends (i.e. releasing
|
||||
the mouse button does not cause the popup to be unmapped).
|
||||
|
||||
The popup grab continues until the window is destroyed or a mouse
|
||||
button is pressed in any other client's window. A click in any of the
|
||||
client's surfaces is reported as normal, however, clicks in other
|
||||
clients' surfaces will be discarded and trigger the callback.
|
||||
|
||||
The x and y arguments specify the location of the upper left corner of
|
||||
the surface relative to the upper left corner of the parent surface, in
|
||||
surface-local coordinates.
|
||||
|
||||
:param seat:
|
||||
seat whose pointer is used
|
||||
:type seat:
|
||||
:class:`~pywayland.protocol.wayland.WlSeat`
|
||||
:param serial:
|
||||
serial number of the implicit grab on the pointer
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param parent:
|
||||
parent surface
|
||||
:type parent:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param flags:
|
||||
transient surface behavior
|
||||
:type flags:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._marshal(6, seat, serial, parent, x, y, flags)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlOutput, nullable=True),
|
||||
)
|
||||
def set_maximized(self, output: WlOutput | None) -> None:
|
||||
"""Make the surface a maximized surface
|
||||
|
||||
Map the surface as a maximized surface.
|
||||
|
||||
If an output parameter is given then the surface will be maximized on
|
||||
that output. If the client does not specify the output then the
|
||||
compositor will apply its policy - usually choosing the output on which
|
||||
the surface has the biggest surface area.
|
||||
|
||||
The compositor will reply with a configure event telling the expected
|
||||
new surface size. The operation is completed on the next buffer attach
|
||||
to this surface.
|
||||
|
||||
A maximized surface typically fills the entire output it is bound to,
|
||||
except for desktop elements such as panels. This is the main difference
|
||||
between a maximized shell surface and a fullscreen shell surface.
|
||||
|
||||
The details depend on the compositor implementation.
|
||||
|
||||
:param output:
|
||||
output on which the surface is to be maximized
|
||||
:type output:
|
||||
:class:`~pywayland.protocol.wayland.WlOutput` or `None`
|
||||
"""
|
||||
self._marshal(7, output)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.String),
|
||||
)
|
||||
def set_title(self, title: str) -> None:
|
||||
"""Set surface title
|
||||
|
||||
Set a short title for the surface.
|
||||
|
||||
This string may be used to identify the surface in a task bar, window
|
||||
list, or other user interface elements provided by the compositor.
|
||||
|
||||
The string must be encoded in UTF-8.
|
||||
|
||||
:param title:
|
||||
surface title
|
||||
:type title:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._marshal(8, title)
|
||||
|
||||
@WlShellSurface.request(
|
||||
Argument(ArgumentType.String),
|
||||
)
|
||||
def set_class(self, class_: str) -> None:
|
||||
"""Set surface class
|
||||
|
||||
Set a class for the surface.
|
||||
|
||||
The surface class identifies the general class of applications to which
|
||||
the surface belongs. A common convention is to use the file name (or
|
||||
the full path if it is a non-standard location) of the application's
|
||||
.desktop file as the class.
|
||||
|
||||
:param class_:
|
||||
surface class
|
||||
:type class_:
|
||||
`ArgumentType.String`
|
||||
"""
|
||||
self._marshal(9, class_)
|
||||
|
||||
|
||||
class WlShellSurfaceResource(Resource):
|
||||
interface = WlShellSurface
|
||||
|
||||
@WlShellSurface.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def ping(self, serial: int) -> None:
|
||||
"""Ping client
|
||||
|
||||
Ping a client to check if it is receiving events and sending requests.
|
||||
A client is expected to reply with a pong request.
|
||||
|
||||
:param serial:
|
||||
serial number of the ping
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, serial)
|
||||
|
||||
@WlShellSurface.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def configure(self, edges: int, width: int, height: int) -> None:
|
||||
"""Suggest resize
|
||||
|
||||
The configure event asks the client to resize its surface.
|
||||
|
||||
The size is a hint, in the sense that the client is free to ignore it
|
||||
if it doesn't resize, pick a smaller size (to satisfy aspect ratio or
|
||||
resize in steps of NxM pixels).
|
||||
|
||||
The edges parameter provides a hint about how the surface was resized.
|
||||
The client may use this information to decide how to adjust its content
|
||||
to the new size (e.g. a scrolling area might adjust its content
|
||||
position to leave the viewable content unmoved).
|
||||
|
||||
The client is free to dismiss all but the last configure event it
|
||||
received.
|
||||
|
||||
The width and height arguments specify the size of the window in
|
||||
surface-local coordinates.
|
||||
|
||||
:param edges:
|
||||
how the surface was resized
|
||||
:type edges:
|
||||
`ArgumentType.Uint`
|
||||
:param width:
|
||||
new width of the surface
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
new height of the surface
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(1, edges, width, height)
|
||||
|
||||
@WlShellSurface.event()
|
||||
def popup_done(self) -> None:
|
||||
"""Popup interaction is done
|
||||
|
||||
The popup_done event is sent out when a popup grab is broken, that is,
|
||||
when the user clicks a surface that doesn't belong to the client owning
|
||||
the popup surface.
|
||||
"""
|
||||
self._post_event(2)
|
||||
|
||||
|
||||
class WlShellSurfaceGlobal(Global):
|
||||
interface = WlShellSurface
|
||||
|
||||
|
||||
WlShellSurface._gen_c()
|
||||
WlShellSurface.proxy_class = WlShellSurfaceProxy
|
||||
WlShellSurface.resource_class = WlShellSurfaceResource
|
||||
WlShellSurface.global_class = WlShellSurfaceGlobal
|
||||
@@ -0,0 +1,292 @@
|
||||
# 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_shm_pool import WlShmPool
|
||||
|
||||
|
||||
class WlShm(Interface):
|
||||
"""Shared memory support
|
||||
|
||||
A singleton global object that provides support for shared memory.
|
||||
|
||||
Clients can create :class:`~pywayland.protocol.wayland.WlShmPool` objects
|
||||
using the create_pool request.
|
||||
|
||||
On binding the :class:`WlShm` object one or more format events are emitted
|
||||
to inform clients about the valid pixel formats that can be used for
|
||||
buffers.
|
||||
"""
|
||||
|
||||
name = "wl_shm"
|
||||
version = 3
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_format = 0
|
||||
invalid_stride = 1
|
||||
invalid_fd = 2
|
||||
|
||||
class format(enum.IntEnum):
|
||||
argb8888 = 0
|
||||
xrgb8888 = 1
|
||||
c8 = 0x20203843
|
||||
rgb332 = 0x38424752
|
||||
bgr233 = 0x38524742
|
||||
xrgb4444 = 0x32315258
|
||||
xbgr4444 = 0x32314258
|
||||
rgbx4444 = 0x32315852
|
||||
bgrx4444 = 0x32315842
|
||||
argb4444 = 0x32315241
|
||||
abgr4444 = 0x32314241
|
||||
rgba4444 = 0x32314152
|
||||
bgra4444 = 0x32314142
|
||||
xrgb1555 = 0x35315258
|
||||
xbgr1555 = 0x35314258
|
||||
rgbx5551 = 0x35315852
|
||||
bgrx5551 = 0x35315842
|
||||
argb1555 = 0x35315241
|
||||
abgr1555 = 0x35314241
|
||||
rgba5551 = 0x35314152
|
||||
bgra5551 = 0x35314142
|
||||
rgb565 = 0x36314752
|
||||
bgr565 = 0x36314742
|
||||
rgb888 = 0x34324752
|
||||
bgr888 = 0x34324742
|
||||
xbgr8888 = 0x34324258
|
||||
rgbx8888 = 0x34325852
|
||||
bgrx8888 = 0x34325842
|
||||
abgr8888 = 0x34324241
|
||||
rgba8888 = 0x34324152
|
||||
bgra8888 = 0x34324142
|
||||
xrgb2101010 = 0x30335258
|
||||
xbgr2101010 = 0x30334258
|
||||
rgbx1010102 = 0x30335852
|
||||
bgrx1010102 = 0x30335842
|
||||
argb2101010 = 0x30335241
|
||||
abgr2101010 = 0x30334241
|
||||
rgba1010102 = 0x30334152
|
||||
bgra1010102 = 0x30334142
|
||||
yuyv = 0x56595559
|
||||
yvyu = 0x55595659
|
||||
uyvy = 0x59565955
|
||||
vyuy = 0x59555956
|
||||
ayuv = 0x56555941
|
||||
nv12 = 0x3231564E
|
||||
nv21 = 0x3132564E
|
||||
nv16 = 0x3631564E
|
||||
nv61 = 0x3136564E
|
||||
yuv410 = 0x39565559
|
||||
yvu410 = 0x39555659
|
||||
yuv411 = 0x31315559
|
||||
yvu411 = 0x31315659
|
||||
yuv420 = 0x32315559
|
||||
yvu420 = 0x32315659
|
||||
yuv422 = 0x36315559
|
||||
yvu422 = 0x36315659
|
||||
yuv444 = 0x34325559
|
||||
yvu444 = 0x34325659
|
||||
r8 = 0x20203852
|
||||
r16 = 0x20363152
|
||||
rg88 = 0x38384752
|
||||
gr88 = 0x38385247
|
||||
rg1616 = 0x32334752
|
||||
gr1616 = 0x32335247
|
||||
xrgb16161616f = 0x48345258
|
||||
xbgr16161616f = 0x48344258
|
||||
argb16161616f = 0x48345241
|
||||
abgr16161616f = 0x48344241
|
||||
xyuv8888 = 0x56555958
|
||||
vuy888 = 0x34325556
|
||||
vuy101010 = 0x30335556
|
||||
y210 = 0x30313259
|
||||
y212 = 0x32313259
|
||||
y216 = 0x36313259
|
||||
y410 = 0x30313459
|
||||
y412 = 0x32313459
|
||||
y416 = 0x36313459
|
||||
xvyu2101010 = 0x30335658
|
||||
xvyu12_16161616 = 0x36335658
|
||||
xvyu16161616 = 0x38345658
|
||||
y0l0 = 0x304C3059
|
||||
x0l0 = 0x304C3058
|
||||
y0l2 = 0x324C3059
|
||||
x0l2 = 0x324C3058
|
||||
yuv420_8bit = 0x38305559
|
||||
yuv420_10bit = 0x30315559
|
||||
xrgb8888_a8 = 0x38415258
|
||||
xbgr8888_a8 = 0x38414258
|
||||
rgbx8888_a8 = 0x38415852
|
||||
bgrx8888_a8 = 0x38415842
|
||||
rgb888_a8 = 0x38413852
|
||||
bgr888_a8 = 0x38413842
|
||||
rgb565_a8 = 0x38413552
|
||||
bgr565_a8 = 0x38413542
|
||||
nv24 = 0x3432564E
|
||||
nv42 = 0x3234564E
|
||||
p210 = 0x30313250
|
||||
p010 = 0x30313050
|
||||
p012 = 0x32313050
|
||||
p016 = 0x36313050
|
||||
axbxgxrx106106106106 = 0x30314241
|
||||
nv15 = 0x3531564E
|
||||
q410 = 0x30313451
|
||||
q401 = 0x31303451
|
||||
xrgb16161616 = 0x38345258
|
||||
xbgr16161616 = 0x38344258
|
||||
argb16161616 = 0x38345241
|
||||
abgr16161616 = 0x38344241
|
||||
c1 = 0x20203143
|
||||
c2 = 0x20203243
|
||||
c4 = 0x20203443
|
||||
d1 = 0x20203144
|
||||
d2 = 0x20203244
|
||||
d4 = 0x20203444
|
||||
d8 = 0x20203844
|
||||
r1 = 0x20203152
|
||||
r2 = 0x20203252
|
||||
r4 = 0x20203452
|
||||
r10 = 0x20303152
|
||||
r12 = 0x20323152
|
||||
avuy8888 = 0x59555641
|
||||
xvuy8888 = 0x59555658
|
||||
p030 = 0x30333050
|
||||
rgb161616 = 0x38344752
|
||||
bgr161616 = 0x38344742
|
||||
r16f = 0x48202052
|
||||
gr1616f = 0x48205247
|
||||
bgr161616f = 0x48524742
|
||||
r32f = 0x46202052
|
||||
gr3232f = 0x46205247
|
||||
bgr323232f = 0x46524742
|
||||
abgr32323232f = 0x46384241
|
||||
nv20 = 0x3032564E
|
||||
nv30 = 0x3033564E
|
||||
s010 = 0x30313053
|
||||
s210 = 0x30313253
|
||||
s410 = 0x30313453
|
||||
s012 = 0x32313053
|
||||
s212 = 0x32313253
|
||||
s412 = 0x32313453
|
||||
s016 = 0x36313053
|
||||
s216 = 0x36313253
|
||||
s416 = 0x36313453
|
||||
xvuy2101010 = 0x30335958
|
||||
p230 = 0x30333250
|
||||
t430 = 0x30333454
|
||||
y8 = 0x59455247
|
||||
xyyy2101010 = 0x34415059
|
||||
|
||||
|
||||
class WlShmProxy(Proxy[WlShm]):
|
||||
interface = WlShm
|
||||
|
||||
@WlShm.request(
|
||||
Argument(ArgumentType.NewId, interface=WlShmPool),
|
||||
Argument(ArgumentType.FileDescriptor),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def create_pool(self, fd: int, size: int) -> Proxy[WlShmPool]:
|
||||
"""Create a shm pool
|
||||
|
||||
Create a new :class:`~pywayland.protocol.wayland.WlShmPool` object.
|
||||
|
||||
The pool can be used to create shared memory based buffer objects. The
|
||||
server will mmap size bytes of the passed file descriptor, to use as
|
||||
backing memory for the pool.
|
||||
|
||||
:param fd:
|
||||
file descriptor for the pool
|
||||
:type fd:
|
||||
`ArgumentType.FileDescriptor`
|
||||
:param size:
|
||||
pool size, in bytes
|
||||
:type size:
|
||||
`ArgumentType.Int`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlShmPool` -- pool to create
|
||||
"""
|
||||
id = self._marshal_constructor(0, WlShmPool, fd, size)
|
||||
return id
|
||||
|
||||
@WlShm.request(version=2)
|
||||
def release(self) -> None:
|
||||
"""Release the shm object
|
||||
|
||||
Using this request a client can tell the server that it is not going to
|
||||
use the shm object anymore.
|
||||
|
||||
Objects created via this interface remain unaffected.
|
||||
"""
|
||||
self._marshal(1)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlShmResource(Resource):
|
||||
interface = WlShm
|
||||
|
||||
@WlShm.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def format(self, format: int) -> None:
|
||||
"""Pixel format description
|
||||
|
||||
Informs the client about a valid pixel format that can be used for
|
||||
buffers. Known formats include argb8888 and xrgb8888.
|
||||
|
||||
Extensions to drm_fourcc.h (or the format enum) do not require
|
||||
increasing the :class:`WlShm` version; as a result, clients may receive
|
||||
format codes which were not in the list at the time the client was
|
||||
made.
|
||||
|
||||
:param format:
|
||||
buffer pixel format
|
||||
:type format:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, format)
|
||||
|
||||
|
||||
class WlShmGlobal(Global):
|
||||
interface = WlShm
|
||||
|
||||
|
||||
WlShm._gen_c()
|
||||
WlShm.proxy_class = WlShmProxy
|
||||
WlShm.resource_class = WlShmResource
|
||||
WlShm.global_class = WlShmGlobal
|
||||
@@ -0,0 +1,165 @@
|
||||
# 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_buffer import WlBuffer
|
||||
|
||||
|
||||
class WlShmPool(Interface):
|
||||
"""A shared memory pool
|
||||
|
||||
The :class:`WlShmPool` object encapsulates a piece of memory shared between
|
||||
the compositor and client. Through the :class:`WlShmPool` object, the
|
||||
client can allocate shared memory
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` objects. All objects created
|
||||
through the same pool share the same underlying mapped memory. Reusing the
|
||||
mapped memory avoids the setup/teardown overhead and is useful when
|
||||
interactively resizing a surface or for many small buffers.
|
||||
"""
|
||||
|
||||
name = "wl_shm_pool"
|
||||
version = 3
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_format = 0
|
||||
invalid_stride = 1
|
||||
|
||||
|
||||
class WlShmPoolProxy(Proxy[WlShmPool]):
|
||||
interface = WlShmPool
|
||||
|
||||
@WlShmPool.request(
|
||||
Argument(ArgumentType.NewId, interface=WlBuffer),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def create_buffer(self, offset: int, width: int, height: int, stride: int, format: int) -> Proxy[WlBuffer]:
|
||||
"""Create a buffer from the pool
|
||||
|
||||
Create a :class:`~pywayland.protocol.wayland.WlBuffer` object from the
|
||||
pool.
|
||||
|
||||
The buffer is created offset bytes into the pool and has width and
|
||||
height as specified. The stride argument specifies the number of bytes
|
||||
from the beginning of one row to the beginning of the next. The format
|
||||
is the pixel format of the buffer and must be one of those advertised
|
||||
through the :func:`WlShm.format()
|
||||
<pywayland.protocol.wayland.WlShm.format>` event.
|
||||
|
||||
A buffer will keep a reference to the pool it was created from so it is
|
||||
valid to destroy the pool immediately after creating a buffer from it.
|
||||
|
||||
:param offset:
|
||||
buffer byte offset within the pool
|
||||
:type offset:
|
||||
`ArgumentType.Int`
|
||||
:param width:
|
||||
buffer width, in pixels
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
buffer height, in pixels
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
:param stride:
|
||||
number of bytes from the beginning of one row to the beginning of
|
||||
the next row
|
||||
:type stride:
|
||||
`ArgumentType.Int`
|
||||
:param format:
|
||||
buffer pixel format
|
||||
:type format:
|
||||
`ArgumentType.Uint`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` -- buffer to create
|
||||
"""
|
||||
id = self._marshal_constructor(0, WlBuffer, offset, width, height, stride, format)
|
||||
return id
|
||||
|
||||
@WlShmPool.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroy the pool
|
||||
|
||||
Destroy the shared memory pool.
|
||||
|
||||
The mmapped memory will be released when all buffers that have been
|
||||
created from this pool are gone.
|
||||
"""
|
||||
self._marshal(1)
|
||||
self._destroy()
|
||||
|
||||
@WlShmPool.request(
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def resize(self, size: int) -> None:
|
||||
"""Change the size of the pool mapping
|
||||
|
||||
This request will cause the server to remap the backing memory for the
|
||||
pool from the file descriptor passed when the pool was created, but
|
||||
using the new size. This request can only be used to make the pool
|
||||
bigger.
|
||||
|
||||
This request only changes the amount of bytes that are mmapped by the
|
||||
server and does not touch the file corresponding to the file descriptor
|
||||
passed at creation time. It is the client's responsibility to ensure
|
||||
that the file is at least as big as the new pool size.
|
||||
|
||||
:param size:
|
||||
new size of the pool, in bytes
|
||||
:type size:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(2, size)
|
||||
|
||||
|
||||
class WlShmPoolResource(Resource):
|
||||
interface = WlShmPool
|
||||
|
||||
|
||||
class WlShmPoolGlobal(Global):
|
||||
interface = WlShmPool
|
||||
|
||||
|
||||
WlShmPool._gen_c()
|
||||
WlShmPool.proxy_class = WlShmPoolProxy
|
||||
WlShmPool.resource_class = WlShmPoolResource
|
||||
WlShmPool.global_class = WlShmPoolGlobal
|
||||
@@ -0,0 +1,150 @@
|
||||
# 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_subsurface import WlSubsurface
|
||||
from .wl_surface import WlSurface
|
||||
|
||||
|
||||
class WlSubcompositor(Interface):
|
||||
"""Sub-surface compositing
|
||||
|
||||
The global interface exposing sub-surface compositing capabilities. A
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`, that has sub-surfaces
|
||||
associated, is called the parent surface. Sub-surfaces can be arbitrarily
|
||||
nested and create a tree of sub-surfaces.
|
||||
|
||||
The root surface in a tree of sub-surfaces is the main surface. The main
|
||||
surface cannot be a sub-surface, because sub-surfaces must always have a
|
||||
parent.
|
||||
|
||||
A main surface with its sub-surfaces forms a (compound) window. For window
|
||||
management purposes, this set of
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` objects is to be considered
|
||||
as a single window, and it should also behave as such.
|
||||
|
||||
The aim of sub-surfaces is to offload some of the compositing work within a
|
||||
window from clients to the compositor. A prime example is a video player
|
||||
with decorations and video in separate
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` objects. This should allow
|
||||
the compositor to pass YUV video buffer processing to dedicated overlay
|
||||
hardware when possible.
|
||||
"""
|
||||
|
||||
name = "wl_subcompositor"
|
||||
version = 1
|
||||
|
||||
class error(enum.IntEnum):
|
||||
bad_surface = 0
|
||||
bad_parent = 1
|
||||
|
||||
|
||||
class WlSubcompositorProxy(Proxy[WlSubcompositor]):
|
||||
interface = WlSubcompositor
|
||||
|
||||
@WlSubcompositor.request()
|
||||
def destroy(self) -> None:
|
||||
"""Unbind from the subcompositor interface
|
||||
|
||||
Informs the server that the client will not be using this protocol
|
||||
object anymore. This does not affect any other objects,
|
||||
:class:`~pywayland.protocol.wayland.WlSubsurface` objects included.
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
@WlSubcompositor.request(
|
||||
Argument(ArgumentType.NewId, interface=WlSubsurface),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
)
|
||||
def get_subsurface(self, surface: WlSurface, parent: WlSurface) -> Proxy[WlSubsurface]:
|
||||
"""Give a surface the role sub-surface
|
||||
|
||||
Create a sub-surface interface for the given surface, and associate it
|
||||
with the given parent surface. This turns a plain
|
||||
:class:`~pywayland.protocol.wayland.WlSurface` into a sub-surface.
|
||||
|
||||
The to-be sub-surface must not already have another role, and it must
|
||||
not have an existing :class:`~pywayland.protocol.wayland.WlSubsurface`
|
||||
object. Otherwise the bad_surface protocol error is raised.
|
||||
|
||||
Adding sub-surfaces to a parent is a double-buffered operation on the
|
||||
parent (see :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>`). The effect of adding a
|
||||
sub-surface becomes visible on the next time the state of the parent
|
||||
surface is applied.
|
||||
|
||||
The parent surface must not be one of the child surface's descendants,
|
||||
and the parent must be different from the child surface, otherwise the
|
||||
bad_parent protocol error is raised.
|
||||
|
||||
This request modifies the behaviour of :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` request on the sub-
|
||||
surface, see the documentation on
|
||||
:class:`~pywayland.protocol.wayland.WlSubsurface` interface.
|
||||
|
||||
:param surface:
|
||||
the surface to be turned into a sub-surface
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param parent:
|
||||
the parent surface
|
||||
:type parent:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlSubsurface` -- the new sub-
|
||||
surface object ID
|
||||
"""
|
||||
id = self._marshal_constructor(1, WlSubsurface, surface, parent)
|
||||
return id
|
||||
|
||||
|
||||
class WlSubcompositorResource(Resource):
|
||||
interface = WlSubcompositor
|
||||
|
||||
|
||||
class WlSubcompositorGlobal(Global):
|
||||
interface = WlSubcompositor
|
||||
|
||||
|
||||
WlSubcompositor._gen_c()
|
||||
WlSubcompositor.proxy_class = WlSubcompositorProxy
|
||||
WlSubcompositor.resource_class = WlSubcompositorResource
|
||||
WlSubcompositor.global_class = WlSubcompositorGlobal
|
||||
@@ -0,0 +1,232 @@
|
||||
# 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.
|
||||
|
||||
A sub-surface can be in one of two modes. The possible modes are
|
||||
synchronized and desynchronized, see methods
|
||||
:func:`WlSubsurface.set_sync()` and :func:`WlSubsurface.set_desync()`.
|
||||
|
||||
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.
|
||||
|
||||
If a surface behaves as in synchronized mode, it is effectively
|
||||
synchronized, otherwise it is effectively desynchronized.
|
||||
|
||||
A sub-surface is initially in the synchronized mode.
|
||||
|
||||
The :class:`WlSubsurface` interface has requests which modify double-
|
||||
buffered state of the parent surface (:func:`WlSubsurface.set_position()`,
|
||||
.place_above and .place_below).
|
||||
|
||||
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.
|
||||
|
||||
A sub-surface never has the keyboard focus of any seat.
|
||||
|
||||
The :func:`WlSurface.offset()
|
||||
<pywayland.protocol.wayland.WlSurface.offset>` request is ignored: clients
|
||||
must use set_position instead to move the sub-surface.
|
||||
"""
|
||||
|
||||
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 sets the position of the sub-surface, relative to the parent
|
||||
surface.
|
||||
|
||||
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 initial position is 0, 0.
|
||||
|
||||
Position is double-buffered state on the parent surface, see
|
||||
:class:`WlSubsurface` and :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` for more information.
|
||||
|
||||
: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.
|
||||
|
||||
A new sub-surface is initially added as the top-most in the stack of
|
||||
its siblings and parent.
|
||||
|
||||
Z-order is double-buffered state on the parent surface, see
|
||||
:class:`WlSubsurface` and :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` for more information.
|
||||
|
||||
: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.
|
||||
|
||||
See :class:`WlSubsurface` and :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` for more information.
|
||||
"""
|
||||
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.
|
||||
|
||||
See :class:`WlSubsurface` and :func:`WlSurface.commit()
|
||||
<pywayland.protocol.wayland.WlSurface.commit>` for more information.
|
||||
"""
|
||||
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
|
||||
@@ -0,0 +1,792 @@
|
||||
# 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_buffer import WlBuffer
|
||||
from .wl_callback import WlCallback
|
||||
from .wl_output import WlOutput
|
||||
from .wl_region import WlRegion
|
||||
|
||||
|
||||
class WlSurface(Interface):
|
||||
"""An onscreen surface
|
||||
|
||||
A surface is a rectangular area that may be displayed on zero or more
|
||||
outputs, and shown any number of times at the compositor's discretion. They
|
||||
can present wl_buffers, receive user input, and define a local coordinate
|
||||
system.
|
||||
|
||||
The size of a surface (and relative positions on it) is described in
|
||||
surface-local coordinates, which may differ from the buffer coordinates of
|
||||
the pixel content, in case a buffer_transform or a buffer_scale is used.
|
||||
|
||||
A surface without a "role" is fairly useless: a compositor does not know
|
||||
where, when or how to present it. The role is the purpose of a
|
||||
:class:`WlSurface`. Examples of roles are a cursor for a pointer (as set by
|
||||
:func:`WlPointer.set_cursor()
|
||||
<pywayland.protocol.wayland.WlPointer.set_cursor>`), a drag icon
|
||||
(:func:`WlDataDevice.start_drag()
|
||||
<pywayland.protocol.wayland.WlDataDevice.start_drag>`), a sub-surface
|
||||
(:func:`WlSubcompositor.get_subsurface()
|
||||
<pywayland.protocol.wayland.WlSubcompositor.get_subsurface>`), and a window
|
||||
as defined by a shell protocol (e.g. :func:`WlShell.get_shell_surface()
|
||||
<pywayland.protocol.wayland.WlShell.get_shell_surface>`).
|
||||
|
||||
A surface can have only one role at a time. Initially a :class:`WlSurface`
|
||||
does not have a role. Once a :class:`WlSurface` is given a role, it is set
|
||||
permanently for the whole lifetime of the :class:`WlSurface` object. Giving
|
||||
the current role again is allowed, unless explicitly forbidden by the
|
||||
relevant interface specification.
|
||||
|
||||
Surface roles are given by requests in other interfaces such as
|
||||
:func:`WlPointer.set_cursor()
|
||||
<pywayland.protocol.wayland.WlPointer.set_cursor>`. The request should
|
||||
explicitly mention that this request gives a role to a :class:`WlSurface`.
|
||||
Often, this request also creates a new protocol object that represents the
|
||||
role and adds additional functionality to :class:`WlSurface`. When a client
|
||||
wants to destroy a :class:`WlSurface`, they must destroy this role object
|
||||
before the :class:`WlSurface`, otherwise a defunct_role_object error is
|
||||
sent.
|
||||
|
||||
Destroying the role object does not remove the role from the
|
||||
:class:`WlSurface`, but it may stop the :class:`WlSurface` from "playing
|
||||
the role". For instance, if a
|
||||
:class:`~pywayland.protocol.wayland.WlSubsurface` object is destroyed, the
|
||||
:class:`WlSurface` it was created for will be unmapped and forget its
|
||||
position and z-order. It is allowed to create a
|
||||
:class:`~pywayland.protocol.wayland.WlSubsurface` for the same
|
||||
:class:`WlSurface` again, but it is not allowed to use the
|
||||
:class:`WlSurface` as a cursor (cursor is a different role than sub-
|
||||
surface, and role switching is not allowed).
|
||||
"""
|
||||
|
||||
name = "wl_surface"
|
||||
version = 7
|
||||
|
||||
class error(enum.IntEnum):
|
||||
invalid_scale = 0
|
||||
invalid_transform = 1
|
||||
invalid_size = 2
|
||||
invalid_offset = 3
|
||||
defunct_role_object = 4
|
||||
no_buffer = 5
|
||||
|
||||
|
||||
class WlSurfaceProxy(Proxy[WlSurface]):
|
||||
interface = WlSurface
|
||||
|
||||
@WlSurface.request()
|
||||
def destroy(self) -> None:
|
||||
"""Delete surface
|
||||
|
||||
Deletes the surface and invalidates its object ID.
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlBuffer, nullable=True),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def attach(self, buffer: WlBuffer | None, x: int, y: int) -> None:
|
||||
"""Set the surface contents
|
||||
|
||||
Set a buffer as the content of this surface.
|
||||
|
||||
The new size of the surface is calculated based on the buffer size
|
||||
transformed by the inverse buffer_transform and the inverse
|
||||
buffer_scale. This means that at commit time the supplied buffer size
|
||||
must be an integer multiple of the buffer_scale. If that's not the
|
||||
case, an invalid_size error is sent.
|
||||
|
||||
The x and y arguments specify the location of the new pending buffer's
|
||||
upper left corner, relative to the current buffer's upper left corner,
|
||||
in surface-local coordinates. In other words, the x and y, combined
|
||||
with the new surface size define in which directions the surface's size
|
||||
changes. Setting anything other than 0 as x and y arguments is
|
||||
discouraged, and should instead be replaced with using the separate
|
||||
:func:`WlSurface.offset()` request.
|
||||
|
||||
When the bound :class:`WlSurface` version is 5 or higher, passing any
|
||||
non-zero x or y is a protocol violation, and will result in an
|
||||
'invalid_offset' error being raised. The x and y arguments are ignored
|
||||
and do not change the pending state. To achieve equivalent semantics,
|
||||
use :func:`WlSurface.offset()`.
|
||||
|
||||
Surface contents are double-buffered state, see
|
||||
:func:`WlSurface.commit()`.
|
||||
|
||||
The initial surface contents are void; there is no content.
|
||||
:func:`WlSurface.attach()` assigns the given
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` as the pending
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer`.
|
||||
:func:`WlSurface.commit()` makes the pending
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` the new surface contents,
|
||||
and the size of the surface becomes the size calculated from the
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer`, as described above.
|
||||
After commit, there is no pending buffer until the next attach.
|
||||
|
||||
Committing a pending :class:`~pywayland.protocol.wayland.WlBuffer`
|
||||
allows the compositor to read the pixels in the
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer`. The compositor may
|
||||
access the pixels at any time after the :func:`WlSurface.commit()`
|
||||
request. When the compositor will not access the pixels anymore, it
|
||||
will send the :func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>` event. Only after
|
||||
receiving :func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>`, the client may reuse
|
||||
the :class:`~pywayland.protocol.wayland.WlBuffer`. A
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` that has been attached
|
||||
and then replaced by another attach instead of committed will not
|
||||
receive a release event, and is not used by the compositor.
|
||||
|
||||
If a pending :class:`~pywayland.protocol.wayland.WlBuffer` has been
|
||||
committed to more than one :class:`WlSurface`, the delivery of
|
||||
:func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>` events becomes
|
||||
undefined. A well behaved client should not rely on
|
||||
:func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>` events in this case.
|
||||
Instead, clients hitting this case should use
|
||||
:func:`WlSurface.get_release()` or use a protocol extension providing
|
||||
per-commit release notifications (if none of these options are
|
||||
available, a fallback can be implemented by creating multiple
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` objects from the same
|
||||
backing storage).
|
||||
|
||||
Destroying the :class:`~pywayland.protocol.wayland.WlBuffer` after
|
||||
:func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>` does not change the
|
||||
surface contents. Destroying the
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` before
|
||||
:func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>` is allowed as long as
|
||||
the underlying buffer storage isn't re-used (this can happen e.g. on
|
||||
client process termination). However, if the client destroys the
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` before receiving the
|
||||
:func:`WlBuffer.release()
|
||||
<pywayland.protocol.wayland.WlBuffer.release>` event and mutates the
|
||||
underlying buffer storage, the surface contents become undefined
|
||||
immediately.
|
||||
|
||||
If :func:`WlSurface.attach()` is sent with a NULL
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer`, the following
|
||||
:func:`WlSurface.commit()` will remove the surface content.
|
||||
|
||||
If a pending :class:`~pywayland.protocol.wayland.WlBuffer` has been
|
||||
destroyed, the result is not specified. Many compositors are known to
|
||||
remove the surface content on the following :func:`WlSurface.commit()`,
|
||||
but this behaviour is not universal. Clients seeking to maximise
|
||||
compatibility should not destroy pending buffers and should ensure that
|
||||
they explicitly remove content from surfaces, even after destroying
|
||||
buffers.
|
||||
|
||||
:param buffer:
|
||||
buffer of surface contents
|
||||
:type buffer:
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer` or `None`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(1, buffer, x, y)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def damage(self, x: int, y: int, width: int, height: int) -> None:
|
||||
"""Mark part of the surface damaged
|
||||
|
||||
This request is used to describe the regions where the pending buffer
|
||||
is different from the current surface contents, and where the surface
|
||||
therefore needs to be repainted. The compositor ignores the parts of
|
||||
the damage that fall outside of the surface.
|
||||
|
||||
Damage is double-buffered state, see :func:`WlSurface.commit()`.
|
||||
|
||||
The damage rectangle is specified in surface-local coordinates, where x
|
||||
and y specify the upper left corner of the damage rectangle.
|
||||
|
||||
The initial value for pending damage is empty: no damage.
|
||||
:func:`WlSurface.damage()` adds pending damage: the new pending damage
|
||||
is the union of old pending damage and the given rectangle.
|
||||
|
||||
:func:`WlSurface.commit()` assigns pending damage as the current
|
||||
damage, and clears pending damage. The server will clear the current
|
||||
damage as it repaints the surface.
|
||||
|
||||
Note! New clients should not use this request. Instead damage can be
|
||||
posted with :func:`WlSurface.damage_buffer()` which uses buffer
|
||||
coordinates instead of surface coordinates.
|
||||
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param width:
|
||||
width of damage rectangle
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
height of damage rectangle
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(2, x, y, width, height)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.NewId, interface=WlCallback),
|
||||
)
|
||||
def frame(self) -> Proxy[WlCallback]:
|
||||
"""Request a frame throttling hint
|
||||
|
||||
Request a notification when it is a good time to start drawing a new
|
||||
frame, by creating a frame callback. This is useful for throttling
|
||||
redrawing operations, and driving animations.
|
||||
|
||||
When a client is animating on a :class:`WlSurface`, it can use the
|
||||
'frame' request to get notified when it is a good time to draw and
|
||||
commit the next frame of animation. If the client commits an update
|
||||
earlier than that, it is likely that some updates will not make it to
|
||||
the display, and the client is wasting resources by drawing too often.
|
||||
|
||||
The frame request will take effect on the next
|
||||
:func:`WlSurface.commit()`. The notification will only be posted for
|
||||
one frame unless requested again. For a :class:`WlSurface`, the
|
||||
notifications are posted in the order the frame requests were
|
||||
committed.
|
||||
|
||||
The server must send the notifications so that a client will not send
|
||||
excessive updates, while still allowing the highest possible update
|
||||
rate for clients that wait for the reply before drawing again. The
|
||||
server should give some time for the client to draw and commit after
|
||||
sending the frame callback events to let it hit the next output
|
||||
refresh.
|
||||
|
||||
A server should avoid signaling the frame callbacks if the surface is
|
||||
not visible in any way, e.g. the surface is off-screen, or completely
|
||||
obscured by other opaque surfaces.
|
||||
|
||||
The object returned by this request will be destroyed by the compositor
|
||||
after the callback is fired and as such the client must not attempt to
|
||||
use it after that point.
|
||||
|
||||
The callback_data passed in the callback is the current time, in
|
||||
milliseconds, with an undefined base.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlCallback` -- callback object
|
||||
for the frame request
|
||||
"""
|
||||
callback = self._marshal_constructor(3, WlCallback)
|
||||
return callback
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlRegion, nullable=True),
|
||||
)
|
||||
def set_opaque_region(self, region: WlRegion | None) -> None:
|
||||
"""Set opaque region
|
||||
|
||||
This request sets the region of the surface that contains opaque
|
||||
content.
|
||||
|
||||
The opaque region is an optimization hint for the compositor that lets
|
||||
it optimize the redrawing of content behind opaque regions. Setting an
|
||||
opaque region is not required for correct behaviour, but marking
|
||||
transparent content as opaque will result in repaint artifacts.
|
||||
|
||||
The opaque region is specified in surface-local coordinates.
|
||||
|
||||
The compositor ignores the parts of the opaque region that fall outside
|
||||
of the surface.
|
||||
|
||||
Opaque region is double-buffered state, see :func:`WlSurface.commit()`.
|
||||
|
||||
:func:`WlSurface.set_opaque_region()` changes the pending opaque
|
||||
region. :func:`WlSurface.commit()` copies the pending region to the
|
||||
current region. Otherwise, the pending and current regions are never
|
||||
changed.
|
||||
|
||||
The initial value for an opaque region is empty. Setting the pending
|
||||
opaque region has copy semantics, and the
|
||||
:class:`~pywayland.protocol.wayland.WlRegion` object can be destroyed
|
||||
immediately. A NULL :class:`~pywayland.protocol.wayland.WlRegion`
|
||||
causes the pending opaque region to be set to empty.
|
||||
|
||||
:param region:
|
||||
opaque region of the surface
|
||||
:type region:
|
||||
:class:`~pywayland.protocol.wayland.WlRegion` or `None`
|
||||
"""
|
||||
self._marshal(4, region)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Object, interface=WlRegion, nullable=True),
|
||||
)
|
||||
def set_input_region(self, region: WlRegion | None) -> None:
|
||||
"""Set input region
|
||||
|
||||
This request sets the region of the surface that can receive pointer
|
||||
and touch events.
|
||||
|
||||
Input events happening outside of this region will try the next surface
|
||||
in the server surface stack. The compositor ignores the parts of the
|
||||
input region that fall outside of the surface.
|
||||
|
||||
The input region is specified in surface-local coordinates.
|
||||
|
||||
Input region is double-buffered state, see :func:`WlSurface.commit()`.
|
||||
|
||||
:func:`WlSurface.set_input_region()` changes the pending input region.
|
||||
:func:`WlSurface.commit()` copies the pending region to the current
|
||||
region. Otherwise the pending and current regions are never changed,
|
||||
except cursor and icon surfaces are special cases, see
|
||||
:func:`WlPointer.set_cursor()
|
||||
<pywayland.protocol.wayland.WlPointer.set_cursor>` and
|
||||
:func:`WlDataDevice.start_drag()
|
||||
<pywayland.protocol.wayland.WlDataDevice.start_drag>`.
|
||||
|
||||
The initial value for an input region is infinite. That means the whole
|
||||
surface will accept input. Setting the pending input region has copy
|
||||
semantics, and the :class:`~pywayland.protocol.wayland.WlRegion` object
|
||||
can be destroyed immediately. A NULL
|
||||
:class:`~pywayland.protocol.wayland.WlRegion` causes the input region
|
||||
to be set to infinite.
|
||||
|
||||
:param region:
|
||||
input region of the surface
|
||||
:type region:
|
||||
:class:`~pywayland.protocol.wayland.WlRegion` or `None`
|
||||
"""
|
||||
self._marshal(5, region)
|
||||
|
||||
@WlSurface.request()
|
||||
def commit(self) -> None:
|
||||
"""Commit pending surface state
|
||||
|
||||
Surface state (input, opaque, and damage regions, attached buffers,
|
||||
etc.) is double-buffered. Protocol requests modify the pending state,
|
||||
as opposed to the active state in use by the compositor.
|
||||
|
||||
All requests that need a commit to become effective are documented to
|
||||
affect double-buffered state.
|
||||
|
||||
Other interfaces may add further double-buffered surface state.
|
||||
|
||||
A commit request atomically creates a Content Update (CU) from the
|
||||
pending state, even if the pending state has not been touched. The
|
||||
content update is placed at the end of a per-surface queue until it
|
||||
becomes active. After commit, the new pending state is as documented
|
||||
for each related request.
|
||||
|
||||
A CU is either a Desync Content Update (DCU) or a Sync Content Update
|
||||
(SCU). If the surface is effectively synchronized at the commit
|
||||
request, it is a SCU, otherwise a DCU.
|
||||
|
||||
When a surface transitions from effectively synchronized to effectively
|
||||
desynchronized, all SCUs in its queue which are not reachable by any
|
||||
DCU become DCUs and dependency edges from outside the queue to these
|
||||
CUs are removed.
|
||||
|
||||
See :class:`~pywayland.protocol.wayland.WlSubsurface` for the
|
||||
definition of 'effectively synchronized' and 'effectively
|
||||
desynchronized'.
|
||||
|
||||
When a CU is placed in the queue, the CU has a dependency on the CU in
|
||||
front of it and to the SCU at end of the queue of every direct child
|
||||
surface if that SCU exists and does not have another dependent. This
|
||||
can form a directed acyclic graph of CUs with dependencies as edges.
|
||||
|
||||
In addition to surface state, the CU can have constraints that must be
|
||||
satisfied before it can be applied. Other interfaces may add CU
|
||||
constraints.
|
||||
|
||||
All DCUs which do not have a SCU in front of themselves in their queue,
|
||||
are candidates. If the graph that's reachable by a candidate does not
|
||||
have any unsatisfied constraints, the entire graph must be applied
|
||||
atomically.
|
||||
|
||||
When a CU is applied, the :class:`~pywayland.protocol.wayland.WlBuffer`
|
||||
is applied before all other state. This means that all coordinates in
|
||||
double-buffered state are relative to the newly attached wl_buffers,
|
||||
except for :func:`WlSurface.attach()` itself. If there is no newly
|
||||
attached :class:`~pywayland.protocol.wayland.WlBuffer`, the coordinates
|
||||
are relative to the previous content update.
|
||||
"""
|
||||
self._marshal(6)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Int),
|
||||
version=2,
|
||||
)
|
||||
def set_buffer_transform(self, transform: int) -> None:
|
||||
"""Sets the buffer transformation
|
||||
|
||||
This request sets the transformation that the client has already
|
||||
applied to the content of the buffer. The accepted values for the
|
||||
transform parameter are the values for :func:`WlOutput.transform()
|
||||
<pywayland.protocol.wayland.WlOutput.transform>`.
|
||||
|
||||
The compositor applies the inverse of this transformation whenever it
|
||||
uses the buffer contents.
|
||||
|
||||
Buffer transform is double-buffered state, see
|
||||
:func:`WlSurface.commit()`.
|
||||
|
||||
A newly created surface has its buffer transformation set to normal.
|
||||
|
||||
:func:`WlSurface.set_buffer_transform()` changes the pending buffer
|
||||
transformation. :func:`WlSurface.commit()` copies the pending buffer
|
||||
transformation to the current one. Otherwise, the pending and current
|
||||
values are never changed.
|
||||
|
||||
The purpose of this request is to allow clients to render content
|
||||
according to the output transform, thus permitting the compositor to
|
||||
use certain optimizations even if the display is rotated. Using
|
||||
hardware overlays and scanning out a client buffer for fullscreen
|
||||
surfaces are examples of such optimizations. Those optimizations are
|
||||
highly dependent on the compositor implementation, so the use of this
|
||||
request should be considered on a case-by-case basis.
|
||||
|
||||
Note that if the transform value includes 90 or 270 degree rotation,
|
||||
the width of the buffer will become the surface height and the height
|
||||
of the buffer will become the surface width.
|
||||
|
||||
If transform is not one of the values from the
|
||||
:func:`WlOutput.transform()
|
||||
<pywayland.protocol.wayland.WlOutput.transform>` enum the
|
||||
invalid_transform protocol error is raised.
|
||||
|
||||
:param transform:
|
||||
transform for interpreting buffer contents
|
||||
:type transform:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(7, transform)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Int),
|
||||
version=3,
|
||||
)
|
||||
def set_buffer_scale(self, scale: int) -> None:
|
||||
"""Sets the buffer scaling factor
|
||||
|
||||
This request sets an optional scaling factor on how the compositor
|
||||
interprets the contents of the buffer attached to the window.
|
||||
|
||||
Buffer scale is double-buffered state, see :func:`WlSurface.commit()`.
|
||||
|
||||
A newly created surface has its buffer scale set to 1.
|
||||
|
||||
:func:`WlSurface.set_buffer_scale()` changes the pending buffer scale.
|
||||
:func:`WlSurface.commit()` copies the pending buffer scale to the
|
||||
current one. Otherwise, the pending and current values are never
|
||||
changed.
|
||||
|
||||
The purpose of this request is to allow clients to supply higher
|
||||
resolution buffer data for use on high resolution outputs. It is
|
||||
intended that you pick the same buffer scale as the scale of the output
|
||||
that the surface is displayed on. This means the compositor can avoid
|
||||
scaling when rendering the surface on that output.
|
||||
|
||||
Note that if the scale is larger than 1, then you have to attach a
|
||||
buffer that is larger (by a factor of scale in each dimension) than the
|
||||
desired surface size.
|
||||
|
||||
If scale is not greater than 0 the invalid_scale protocol error is
|
||||
raised.
|
||||
|
||||
:param scale:
|
||||
scale for interpreting buffer contents
|
||||
:type scale:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(8, scale)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
version=4,
|
||||
)
|
||||
def damage_buffer(self, x: int, y: int, width: int, height: int) -> None:
|
||||
"""Mark part of the surface damaged using buffer coordinates
|
||||
|
||||
This request is used to describe the regions where the pending buffer
|
||||
is different from the current surface contents, and where the surface
|
||||
therefore needs to be repainted. The compositor ignores the parts of
|
||||
the damage that fall outside of the surface.
|
||||
|
||||
Damage is double-buffered state, see :func:`WlSurface.commit()`.
|
||||
|
||||
The damage rectangle is specified in buffer coordinates, where x and y
|
||||
specify the upper left corner of the damage rectangle.
|
||||
|
||||
The initial value for pending damage is empty: no damage.
|
||||
:func:`WlSurface.damage_buffer()` adds pending damage: the new pending
|
||||
damage is the union of old pending damage and the given rectangle.
|
||||
|
||||
:func:`WlSurface.commit()` assigns pending damage as the current
|
||||
damage, and clears pending damage. The server will clear the current
|
||||
damage as it repaints the surface.
|
||||
|
||||
This request differs from :func:`WlSurface.damage()` in only one way -
|
||||
it takes damage in buffer coordinates instead of surface-local
|
||||
coordinates. While this generally is more intuitive than surface
|
||||
coordinates, it is especially desirable when using wp_viewport or when
|
||||
a drawing library (like EGL) is unaware of buffer scale and buffer
|
||||
transform.
|
||||
|
||||
Note: Because buffer transformation changes and damage requests may be
|
||||
interleaved in the protocol stream, it is impossible to determine the
|
||||
actual mapping between surface and buffer damage until
|
||||
:func:`WlSurface.commit()` time. Therefore, compositors wishing to take
|
||||
both kinds of damage into account will have to accumulate damage from
|
||||
the two requests separately and only transform from one to the other
|
||||
after receiving the :func:`WlSurface.commit()`.
|
||||
|
||||
:param x:
|
||||
buffer-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
buffer-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param width:
|
||||
width of damage rectangle
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
height of damage rectangle
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(9, x, y, width, height)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
version=5,
|
||||
)
|
||||
def offset(self, x: int, y: int) -> None:
|
||||
"""Set the surface contents offset
|
||||
|
||||
The x and y arguments specify the location of the new pending buffer's
|
||||
upper left corner, relative to the current buffer's upper left corner,
|
||||
in surface-local coordinates. In other words, the x and y, combined
|
||||
with the new surface size define in which directions the surface's size
|
||||
changes.
|
||||
|
||||
The exact semantics of :func:`WlSurface.offset()` are role-specific.
|
||||
Refer to the documentation of specific roles for more information.
|
||||
|
||||
Surface location offset is double-buffered state, see
|
||||
:func:`WlSurface.commit()`.
|
||||
|
||||
This request is semantically equivalent to and the replaces the x and y
|
||||
arguments in the :func:`WlSurface.attach()` request in
|
||||
:class:`WlSurface` versions prior to 5. See :func:`WlSurface.attach()`
|
||||
for details.
|
||||
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._marshal(10, x, y)
|
||||
|
||||
@WlSurface.request(
|
||||
Argument(ArgumentType.NewId, interface=WlCallback),
|
||||
version=7,
|
||||
)
|
||||
def get_release(self) -> Proxy[WlCallback]:
|
||||
"""Get a release callback
|
||||
|
||||
Create a callback for the release of the buffer attached by the client
|
||||
with :func:`WlSurface.attach()`.
|
||||
|
||||
The compositor will release the buffer when it has finished its usage
|
||||
of the underlying storage for the relevant commit. Once the client
|
||||
receives this event, and assuming the associated buffer is not pending
|
||||
release from other :func:`WlSurface.commit()` requests, the client can
|
||||
safely re-use the buffer.
|
||||
|
||||
Release callbacks are double-buffered state, and will be associated
|
||||
with the pending buffer at :func:`WlSurface.commit()` time.
|
||||
|
||||
The callback_data passed in the :func:`WlCallback.done()
|
||||
<pywayland.protocol.wayland.WlCallback.done>` event is unused and is
|
||||
always zero.
|
||||
|
||||
Sending this request without attaching a non-null buffer in the same
|
||||
content update is a protocol error. The compositor will send the
|
||||
no_buffer error in this case.
|
||||
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wayland.WlCallback` -- callback object
|
||||
for the release
|
||||
"""
|
||||
callback = self._marshal_constructor(11, WlCallback)
|
||||
return callback
|
||||
|
||||
|
||||
class WlSurfaceResource(Resource):
|
||||
interface = WlSurface
|
||||
|
||||
@WlSurface.event(
|
||||
Argument(ArgumentType.Object, interface=WlOutput),
|
||||
)
|
||||
def enter(self, output: WlOutput) -> None:
|
||||
"""Surface enters an output
|
||||
|
||||
This is emitted whenever a surface's creation, movement, or resizing
|
||||
results in some part of it being within the scanout region of an
|
||||
output.
|
||||
|
||||
Note that a surface may be overlapping with zero or more outputs.
|
||||
|
||||
:param output:
|
||||
output entered by the surface
|
||||
:type output:
|
||||
:class:`~pywayland.protocol.wayland.WlOutput`
|
||||
"""
|
||||
self._post_event(0, output)
|
||||
|
||||
@WlSurface.event(
|
||||
Argument(ArgumentType.Object, interface=WlOutput),
|
||||
)
|
||||
def leave(self, output: WlOutput) -> None:
|
||||
"""Surface leaves an output
|
||||
|
||||
This is emitted whenever a surface's creation, movement, or resizing
|
||||
results in it no longer having any part of it within the scanout region
|
||||
of an output.
|
||||
|
||||
Clients should not use the number of outputs the surface is on for
|
||||
frame throttling purposes. The surface might be hidden even if no leave
|
||||
event has been sent, and the compositor might expect new surface
|
||||
content updates even if no enter event has been sent. The frame event
|
||||
should be used instead.
|
||||
|
||||
:param output:
|
||||
output left by the surface
|
||||
:type output:
|
||||
:class:`~pywayland.protocol.wayland.WlOutput`
|
||||
"""
|
||||
self._post_event(1, output)
|
||||
|
||||
@WlSurface.event(
|
||||
Argument(ArgumentType.Int),
|
||||
version=6,
|
||||
)
|
||||
def preferred_buffer_scale(self, factor: int) -> None:
|
||||
"""Preferred buffer scale for the surface
|
||||
|
||||
This event indicates the preferred buffer scale for this surface. It is
|
||||
sent whenever the compositor's preference changes.
|
||||
|
||||
Before receiving this event the preferred buffer scale for this surface
|
||||
is 1.
|
||||
|
||||
It is intended that scaling aware clients use this event to scale their
|
||||
content and use :func:`WlSurface.set_buffer_scale()` to indicate the
|
||||
scale they have rendered with. This allows clients to supply a higher
|
||||
detail buffer.
|
||||
|
||||
The compositor shall emit a scale value greater than 0.
|
||||
|
||||
:param factor:
|
||||
preferred scaling factor
|
||||
:type factor:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(2, factor)
|
||||
|
||||
@WlSurface.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
version=6,
|
||||
)
|
||||
def preferred_buffer_transform(self, transform: int) -> None:
|
||||
"""Preferred buffer transform for the surface
|
||||
|
||||
This event indicates the preferred buffer transform for this surface.
|
||||
It is sent whenever the compositor's preference changes.
|
||||
|
||||
Before receiving this event the preferred buffer transform for this
|
||||
surface is normal.
|
||||
|
||||
Applying this transformation to the surface buffer contents and using
|
||||
:func:`WlSurface.set_buffer_transform()` might allow the compositor to
|
||||
use the surface buffer more efficiently.
|
||||
|
||||
:param transform:
|
||||
preferred transform
|
||||
:type transform:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(3, transform)
|
||||
|
||||
|
||||
class WlSurfaceGlobal(Global):
|
||||
interface = WlSurface
|
||||
|
||||
|
||||
WlSurface._gen_c()
|
||||
WlSurface.proxy_class = WlSurfaceProxy
|
||||
WlSurface.resource_class = WlSurfaceResource
|
||||
WlSurface.global_class = WlSurfaceGlobal
|
||||
@@ -0,0 +1,306 @@
|
||||
# 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
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
from .wl_surface import WlSurface
|
||||
|
||||
|
||||
class WlTouch(Interface):
|
||||
"""Touchscreen input device
|
||||
|
||||
The :class:`WlTouch` interface represents a touchscreen associated with a
|
||||
seat.
|
||||
|
||||
Touch interactions can consist of one or more contacts. For each contact, a
|
||||
series of events is generated, starting with a down event, followed by zero
|
||||
or more motion events, and ending with an up event. Events relating to the
|
||||
same contact point can be identified by the ID of the sequence.
|
||||
"""
|
||||
|
||||
name = "wl_touch"
|
||||
version = 11
|
||||
|
||||
|
||||
class WlTouchProxy(Proxy[WlTouch]):
|
||||
interface = WlTouch
|
||||
|
||||
@WlTouch.request(version=3)
|
||||
def release(self) -> None:
|
||||
"""Release the touch object
|
||||
"""
|
||||
self._marshal(0)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class WlTouchResource(Resource):
|
||||
interface = WlTouch
|
||||
|
||||
@WlTouch.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Object, interface=WlSurface),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
)
|
||||
def down(self, serial: int, time: int, surface: WlSurface, id: int, x: float, y: float) -> None:
|
||||
"""Touch down event and beginning of a touch sequence
|
||||
|
||||
A new touch point has appeared on the surface. This touch point is
|
||||
assigned a unique ID. Future events from this touch point reference
|
||||
this ID. The ID ceases to be valid after a touch up event and may be
|
||||
reused in the future.
|
||||
|
||||
:param serial:
|
||||
serial number of the touch down event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param surface:
|
||||
surface touched
|
||||
:type surface:
|
||||
:class:`~pywayland.protocol.wayland.WlSurface`
|
||||
:param id:
|
||||
the unique ID of this touch point
|
||||
:type id:
|
||||
`ArgumentType.Int`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Fixed`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(0, serial, time, surface, id, x, y)
|
||||
|
||||
@WlTouch.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def up(self, serial: int, time: int, id: int) -> None:
|
||||
"""End of a touch event sequence
|
||||
|
||||
The touch point has disappeared. No further events will be sent for
|
||||
this touch point and the touch point's ID is released and may be reused
|
||||
in a future touch down event.
|
||||
|
||||
:param serial:
|
||||
serial number of the touch up event
|
||||
:type serial:
|
||||
`ArgumentType.Uint`
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param id:
|
||||
the unique ID of this touch point
|
||||
:type id:
|
||||
`ArgumentType.Int`
|
||||
"""
|
||||
self._post_event(1, serial, time, id)
|
||||
|
||||
@WlTouch.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
)
|
||||
def motion(self, time: int, id: int, x: float, y: float) -> None:
|
||||
"""Update of touch point coordinates
|
||||
|
||||
A touch point has changed coordinates.
|
||||
|
||||
:param time:
|
||||
timestamp with millisecond granularity
|
||||
:type time:
|
||||
`ArgumentType.Uint`
|
||||
:param id:
|
||||
the unique ID of this touch point
|
||||
:type id:
|
||||
`ArgumentType.Int`
|
||||
:param x:
|
||||
surface-local x coordinate
|
||||
:type x:
|
||||
`ArgumentType.Fixed`
|
||||
:param y:
|
||||
surface-local y coordinate
|
||||
:type y:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(2, time, id, x, y)
|
||||
|
||||
@WlTouch.event()
|
||||
def frame(self) -> None:
|
||||
"""End of touch frame event
|
||||
|
||||
Indicates the end of a set of events that logically belong together. A
|
||||
client is expected to accumulate the data in all events within the
|
||||
frame before proceeding.
|
||||
|
||||
A :func:`WlTouch.frame()` terminates at least one event but otherwise
|
||||
no guarantee is provided about the set of events within a frame. A
|
||||
client must assume that any state not updated in a frame is unchanged
|
||||
from the previously known state.
|
||||
"""
|
||||
self._post_event(3)
|
||||
|
||||
@WlTouch.event()
|
||||
def cancel(self) -> None:
|
||||
"""Touch session cancelled
|
||||
|
||||
Sent if the compositor decides the touch stream is a global gesture. No
|
||||
further events are sent to the clients from that particular gesture.
|
||||
Touch cancellation applies to all touch points currently active on this
|
||||
client's surface. The client is responsible for finalizing the touch
|
||||
points, future touch points on this surface may reuse the touch point
|
||||
ID.
|
||||
|
||||
No frame event is required after the cancel event.
|
||||
"""
|
||||
self._post_event(4)
|
||||
|
||||
@WlTouch.event(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Fixed),
|
||||
Argument(ArgumentType.Fixed),
|
||||
version=6,
|
||||
)
|
||||
def shape(self, id: int, major: float, minor: float) -> None:
|
||||
"""Update shape of touch point
|
||||
|
||||
Sent when a touchpoint has changed its shape.
|
||||
|
||||
This event does not occur on its own. It is sent before a
|
||||
:func:`WlTouch.frame()` event and carries the new shape information for
|
||||
any previously reported, or new touch points of that frame.
|
||||
|
||||
Other events describing the touch point such as :func:`WlTouch.down()`,
|
||||
:func:`WlTouch.motion()` or :func:`WlTouch.orientation()` may be sent
|
||||
within the same :func:`WlTouch.frame()`. A client should treat these
|
||||
events as a single logical touch point update. The order of
|
||||
:func:`WlTouch.shape()`, :func:`WlTouch.orientation()` and
|
||||
:func:`WlTouch.motion()` is not guaranteed. A :func:`WlTouch.down()`
|
||||
event is guaranteed to occur before the first :func:`WlTouch.shape()`
|
||||
event for this touch ID but both events may occur within the same
|
||||
:func:`WlTouch.frame()`.
|
||||
|
||||
A touchpoint shape is approximated by an ellipse through the major and
|
||||
minor axis length. The major axis length describes the longer diameter
|
||||
of the ellipse, while the minor axis length describes the shorter
|
||||
diameter. Major and minor are orthogonal and both are specified in
|
||||
surface-local coordinates. The center of the ellipse is always at the
|
||||
touchpoint location as reported by :func:`WlTouch.down()` or
|
||||
:func:`WlTouch.motion()`.
|
||||
|
||||
This event is only sent by the compositor if the touch device supports
|
||||
shape reports. The client has to make reasonable assumptions about the
|
||||
shape if it did not receive this event.
|
||||
|
||||
:param id:
|
||||
the unique ID of this touch point
|
||||
:type id:
|
||||
`ArgumentType.Int`
|
||||
:param major:
|
||||
length of the major axis in surface-local coordinates
|
||||
:type major:
|
||||
`ArgumentType.Fixed`
|
||||
:param minor:
|
||||
length of the minor axis in surface-local coordinates
|
||||
:type minor:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(5, id, major, minor)
|
||||
|
||||
@WlTouch.event(
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Fixed),
|
||||
version=6,
|
||||
)
|
||||
def orientation(self, id: int, orientation: float) -> None:
|
||||
"""Update orientation of touch point
|
||||
|
||||
Sent when a touchpoint has changed its orientation.
|
||||
|
||||
This event does not occur on its own. It is sent before a
|
||||
:func:`WlTouch.frame()` event and carries the new shape information for
|
||||
any previously reported, or new touch points of that frame.
|
||||
|
||||
Other events describing the touch point such as :func:`WlTouch.down()`,
|
||||
:func:`WlTouch.motion()` or :func:`WlTouch.shape()` may be sent within
|
||||
the same :func:`WlTouch.frame()`. A client should treat these events as
|
||||
a single logical touch point update. The order of
|
||||
:func:`WlTouch.shape()`, :func:`WlTouch.orientation()` and
|
||||
:func:`WlTouch.motion()` is not guaranteed. A :func:`WlTouch.down()`
|
||||
event is guaranteed to occur before the first
|
||||
:func:`WlTouch.orientation()` event for this touch ID but both events
|
||||
may occur within the same :func:`WlTouch.frame()`.
|
||||
|
||||
The orientation describes the clockwise angle of a touchpoint's major
|
||||
axis to the positive surface y-axis and is normalized to the -180 to
|
||||
+180 degree range. The granularity of orientation depends on the touch
|
||||
device, some devices only support binary rotation values between 0 and
|
||||
90 degrees.
|
||||
|
||||
This event is only sent by the compositor if the touch device supports
|
||||
orientation reports.
|
||||
|
||||
:param id:
|
||||
the unique ID of this touch point
|
||||
:type id:
|
||||
`ArgumentType.Int`
|
||||
:param orientation:
|
||||
angle between major axis and positive surface y-axis in degrees
|
||||
:type orientation:
|
||||
`ArgumentType.Fixed`
|
||||
"""
|
||||
self._post_event(6, id, orientation)
|
||||
|
||||
|
||||
class WlTouchGlobal(Global):
|
||||
interface = WlTouch
|
||||
|
||||
|
||||
WlTouch._gen_c()
|
||||
WlTouch.proxy_class = WlTouchProxy
|
||||
WlTouch.resource_class = WlTouchResource
|
||||
WlTouch.global_class = WlTouchGlobal
|
||||
@@ -0,0 +1,26 @@
|
||||
# This file has been autogenerated by the pywayland scanner
|
||||
|
||||
# Copyright © 2018 Simon Ser
|
||||
# Copyright © 2019 Andri Yngvason
|
||||
#
|
||||
# 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 .zwlr_screencopy_frame_v1 import ZwlrScreencopyFrameV1 # noqa: F401
|
||||
from .zwlr_screencopy_manager_v1 import ZwlrScreencopyManagerV1 # noqa: F401
|
||||
@@ -0,0 +1,307 @@
|
||||
# This file has been autogenerated by the pywayland scanner
|
||||
|
||||
# Copyright © 2018 Simon Ser
|
||||
# Copyright © 2019 Andri Yngvason
|
||||
#
|
||||
# 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 ..wayland import WlBuffer
|
||||
|
||||
|
||||
class ZwlrScreencopyFrameV1(Interface):
|
||||
"""A frame ready for copy
|
||||
|
||||
This object represents a single frame.
|
||||
|
||||
When created, a series of buffer events will be sent, each representing a
|
||||
supported buffer type. The "buffer_done" event is sent afterwards to
|
||||
indicate that all supported buffer types have been enumerated. The client
|
||||
will then be able to send a "copy" request. If the capture is successful,
|
||||
the compositor will send a "flags" followed by a "ready" event.
|
||||
|
||||
For objects version 2 or lower, :class:`~pywayland.protocol.wayland.WlShm`
|
||||
buffers are always supported, ie. the "buffer" event is guaranteed to be
|
||||
sent.
|
||||
|
||||
If the capture failed, the "failed" event is sent. This can happen anytime
|
||||
before the "ready" event.
|
||||
|
||||
Once either a "ready" or a "failed" event is received, the client should
|
||||
destroy the frame.
|
||||
"""
|
||||
|
||||
name = "zwlr_screencopy_frame_v1"
|
||||
version = 3
|
||||
|
||||
class error(enum.IntEnum):
|
||||
already_used = 0
|
||||
invalid_buffer = 1
|
||||
|
||||
class flags(enum.IntFlag):
|
||||
y_invert = 1
|
||||
|
||||
|
||||
class ZwlrScreencopyFrameV1Proxy(Proxy[ZwlrScreencopyFrameV1]):
|
||||
interface = ZwlrScreencopyFrameV1
|
||||
|
||||
@ZwlrScreencopyFrameV1.request(
|
||||
Argument(ArgumentType.Object, interface=WlBuffer),
|
||||
)
|
||||
def copy(self, buffer: WlBuffer) -> None:
|
||||
"""Copy the frame
|
||||
|
||||
Copy the frame to the supplied buffer. The buffer must have a the
|
||||
correct size, see :func:`ZwlrScreencopyFrameV1.buffer()` and
|
||||
:func:`ZwlrScreencopyFrameV1.linux_dmabuf()`. The buffer needs to have
|
||||
a supported format.
|
||||
|
||||
If the frame is successfully copied, a "flags" and a "ready" events are
|
||||
sent. Otherwise, a "failed" event is sent.
|
||||
|
||||
:param buffer:
|
||||
:type buffer:
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer`
|
||||
"""
|
||||
self._marshal(0, buffer)
|
||||
|
||||
@ZwlrScreencopyFrameV1.request()
|
||||
def destroy(self) -> None:
|
||||
"""Delete this object, used or not
|
||||
|
||||
Destroys the frame. This request can be sent at any time by the client.
|
||||
"""
|
||||
self._marshal(1)
|
||||
self._destroy()
|
||||
|
||||
@ZwlrScreencopyFrameV1.request(
|
||||
Argument(ArgumentType.Object, interface=WlBuffer),
|
||||
version=2,
|
||||
)
|
||||
def copy_with_damage(self, buffer: WlBuffer) -> None:
|
||||
"""Copy the frame when it's damaged
|
||||
|
||||
Same as copy, except it waits until there is damage to copy.
|
||||
|
||||
:param buffer:
|
||||
:type buffer:
|
||||
:class:`~pywayland.protocol.wayland.WlBuffer`
|
||||
"""
|
||||
self._marshal(2, buffer)
|
||||
|
||||
|
||||
class ZwlrScreencopyFrameV1Resource(Resource):
|
||||
interface = ZwlrScreencopyFrameV1
|
||||
|
||||
@ZwlrScreencopyFrameV1.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def buffer(self, format: int, width: int, height: int, stride: int) -> None:
|
||||
"""Wl_shm buffer information
|
||||
|
||||
Provides information about :class:`~pywayland.protocol.wayland.WlShm`
|
||||
buffer parameters that need to be used for this frame. This event is
|
||||
sent once after the frame is created if
|
||||
:class:`~pywayland.protocol.wayland.WlShm` buffers are supported.
|
||||
|
||||
:param format:
|
||||
buffer format
|
||||
:type format:
|
||||
`ArgumentType.Uint`
|
||||
:param width:
|
||||
buffer width
|
||||
:type width:
|
||||
`ArgumentType.Uint`
|
||||
:param height:
|
||||
buffer height
|
||||
:type height:
|
||||
`ArgumentType.Uint`
|
||||
:param stride:
|
||||
buffer stride
|
||||
:type stride:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(0, format, width, height, stride)
|
||||
|
||||
@ZwlrScreencopyFrameV1.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def flags(self, flags: int) -> None:
|
||||
"""Frame flags
|
||||
|
||||
Provides flags about the frame. This event is sent once before the
|
||||
"ready" event.
|
||||
|
||||
:param flags:
|
||||
frame flags
|
||||
:type flags:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(1, flags)
|
||||
|
||||
@ZwlrScreencopyFrameV1.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
)
|
||||
def ready(self, tv_sec_hi: int, tv_sec_lo: int, tv_nsec: int) -> None:
|
||||
"""Indicates frame is available for reading
|
||||
|
||||
Called as soon as the frame is copied, indicating it is available for
|
||||
reading. This event includes the time at which presentation happened
|
||||
at.
|
||||
|
||||
The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,
|
||||
each component being an unsigned 32-bit value. Whole seconds are in
|
||||
tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,
|
||||
and the additional fractional part in tv_nsec as nanoseconds. Hence,
|
||||
for valid timestamps tv_nsec must be in [0, 999999999]. The seconds
|
||||
part may have an arbitrary offset at start.
|
||||
|
||||
After receiving this event, the client should destroy the object.
|
||||
|
||||
:param tv_sec_hi:
|
||||
high 32 bits of the seconds part of the timestamp
|
||||
:type tv_sec_hi:
|
||||
`ArgumentType.Uint`
|
||||
:param tv_sec_lo:
|
||||
low 32 bits of the seconds part of the timestamp
|
||||
:type tv_sec_lo:
|
||||
`ArgumentType.Uint`
|
||||
:param tv_nsec:
|
||||
nanoseconds part of the timestamp
|
||||
:type tv_nsec:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(2, tv_sec_hi, tv_sec_lo, tv_nsec)
|
||||
|
||||
@ZwlrScreencopyFrameV1.event()
|
||||
def failed(self) -> None:
|
||||
"""Frame copy failed
|
||||
|
||||
This event indicates that the attempted frame copy has failed.
|
||||
|
||||
After receiving this event, the client should destroy the object.
|
||||
"""
|
||||
self._post_event(3)
|
||||
|
||||
@ZwlrScreencopyFrameV1.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
version=2,
|
||||
)
|
||||
def damage(self, x: int, y: int, width: int, height: int) -> None:
|
||||
"""Carries the coordinates of the damaged region
|
||||
|
||||
This event is sent right before the ready event when copy_with_damage
|
||||
is requested. It may be generated multiple times for each
|
||||
copy_with_damage request.
|
||||
|
||||
The arguments describe a box around an area that has changed since the
|
||||
last copy request that was derived from the current screencopy manager
|
||||
instance.
|
||||
|
||||
The union of all regions received between the call to copy_with_damage
|
||||
and a ready event is the total damage since the prior ready event.
|
||||
|
||||
:param x:
|
||||
damaged x coordinates
|
||||
:type x:
|
||||
`ArgumentType.Uint`
|
||||
:param y:
|
||||
damaged y coordinates
|
||||
:type y:
|
||||
`ArgumentType.Uint`
|
||||
:param width:
|
||||
current width
|
||||
:type width:
|
||||
`ArgumentType.Uint`
|
||||
:param height:
|
||||
current height
|
||||
:type height:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(4, x, y, width, height)
|
||||
|
||||
@ZwlrScreencopyFrameV1.event(
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
Argument(ArgumentType.Uint),
|
||||
version=3,
|
||||
)
|
||||
def linux_dmabuf(self, format: int, width: int, height: int) -> None:
|
||||
"""Linux-dmabuf buffer information
|
||||
|
||||
Provides information about linux-dmabuf buffer parameters that need to
|
||||
be used for this frame. This event is sent once after the frame is
|
||||
created if linux-dmabuf buffers are supported.
|
||||
|
||||
:param format:
|
||||
fourcc pixel format
|
||||
:type format:
|
||||
`ArgumentType.Uint`
|
||||
:param width:
|
||||
buffer width
|
||||
:type width:
|
||||
`ArgumentType.Uint`
|
||||
:param height:
|
||||
buffer height
|
||||
:type height:
|
||||
`ArgumentType.Uint`
|
||||
"""
|
||||
self._post_event(5, format, width, height)
|
||||
|
||||
@ZwlrScreencopyFrameV1.event(version=3)
|
||||
def buffer_done(self) -> None:
|
||||
"""All buffer types reported
|
||||
|
||||
This event is sent once after all buffer events have been sent.
|
||||
|
||||
The client should proceed to create a buffer of one of the supported
|
||||
types, and send a "copy" request.
|
||||
"""
|
||||
self._post_event(6)
|
||||
|
||||
|
||||
class ZwlrScreencopyFrameV1Global(Global):
|
||||
interface = ZwlrScreencopyFrameV1
|
||||
|
||||
|
||||
ZwlrScreencopyFrameV1._gen_c()
|
||||
ZwlrScreencopyFrameV1.proxy_class = ZwlrScreencopyFrameV1Proxy
|
||||
ZwlrScreencopyFrameV1.resource_class = ZwlrScreencopyFrameV1Resource
|
||||
ZwlrScreencopyFrameV1.global_class = ZwlrScreencopyFrameV1Global
|
||||
@@ -0,0 +1,142 @@
|
||||
# This file has been autogenerated by the pywayland scanner
|
||||
|
||||
# Copyright © 2018 Simon Ser
|
||||
# Copyright © 2019 Andri Yngvason
|
||||
#
|
||||
# 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
|
||||
|
||||
from pywayland.protocol_core import (
|
||||
Argument,
|
||||
ArgumentType,
|
||||
Global,
|
||||
Interface,
|
||||
Proxy,
|
||||
Resource,
|
||||
)
|
||||
|
||||
from ..wayland import WlOutput
|
||||
from .zwlr_screencopy_frame_v1 import ZwlrScreencopyFrameV1
|
||||
|
||||
|
||||
class ZwlrScreencopyManagerV1(Interface):
|
||||
"""Manager to inform clients and begin capturing
|
||||
|
||||
This object is a manager which offers requests to start capturing from a
|
||||
source.
|
||||
"""
|
||||
|
||||
name = "zwlr_screencopy_manager_v1"
|
||||
version = 3
|
||||
|
||||
|
||||
class ZwlrScreencopyManagerV1Proxy(Proxy[ZwlrScreencopyManagerV1]):
|
||||
interface = ZwlrScreencopyManagerV1
|
||||
|
||||
@ZwlrScreencopyManagerV1.request(
|
||||
Argument(ArgumentType.NewId, interface=ZwlrScreencopyFrameV1),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Object, interface=WlOutput),
|
||||
)
|
||||
def capture_output(self, overlay_cursor: int, output: WlOutput) -> Proxy[ZwlrScreencopyFrameV1]:
|
||||
"""Capture an output
|
||||
|
||||
Capture the next frame of an entire output.
|
||||
|
||||
:param overlay_cursor:
|
||||
composite cursor onto the frame
|
||||
:type overlay_cursor:
|
||||
`ArgumentType.Int`
|
||||
:param output:
|
||||
:type output:
|
||||
:class:`~pywayland.protocol.wayland.WlOutput`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wlr_screencopy_unstable_v1.ZwlrScreencopyFrameV1`
|
||||
"""
|
||||
frame = self._marshal_constructor(0, ZwlrScreencopyFrameV1, overlay_cursor, output)
|
||||
return frame
|
||||
|
||||
@ZwlrScreencopyManagerV1.request(
|
||||
Argument(ArgumentType.NewId, interface=ZwlrScreencopyFrameV1),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Object, interface=WlOutput),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
Argument(ArgumentType.Int),
|
||||
)
|
||||
def capture_output_region(self, overlay_cursor: int, output: WlOutput, x: int, y: int, width: int, height: int) -> Proxy[ZwlrScreencopyFrameV1]:
|
||||
"""Capture an output's region
|
||||
|
||||
Capture the next frame of an output's region.
|
||||
|
||||
The region is given in output logical coordinates, see
|
||||
xdg_output.logical_size. The region will be clipped to the output's
|
||||
extents.
|
||||
|
||||
:param overlay_cursor:
|
||||
composite cursor onto the frame
|
||||
:type overlay_cursor:
|
||||
`ArgumentType.Int`
|
||||
:param output:
|
||||
:type output:
|
||||
:class:`~pywayland.protocol.wayland.WlOutput`
|
||||
:param x:
|
||||
:type x:
|
||||
`ArgumentType.Int`
|
||||
:param y:
|
||||
:type y:
|
||||
`ArgumentType.Int`
|
||||
:param width:
|
||||
:type width:
|
||||
`ArgumentType.Int`
|
||||
:param height:
|
||||
:type height:
|
||||
`ArgumentType.Int`
|
||||
:returns:
|
||||
:class:`~pywayland.protocol.wlr_screencopy_unstable_v1.ZwlrScreencopyFrameV1`
|
||||
"""
|
||||
frame = self._marshal_constructor(1, ZwlrScreencopyFrameV1, overlay_cursor, output, x, y, width, height)
|
||||
return frame
|
||||
|
||||
@ZwlrScreencopyManagerV1.request()
|
||||
def destroy(self) -> None:
|
||||
"""Destroy the manager
|
||||
|
||||
All objects created by the manager will still remain valid, until their
|
||||
appropriate destroy request has been called.
|
||||
"""
|
||||
self._marshal(2)
|
||||
self._destroy()
|
||||
|
||||
|
||||
class ZwlrScreencopyManagerV1Resource(Resource):
|
||||
interface = ZwlrScreencopyManagerV1
|
||||
|
||||
|
||||
class ZwlrScreencopyManagerV1Global(Global):
|
||||
interface = ZwlrScreencopyManagerV1
|
||||
|
||||
|
||||
ZwlrScreencopyManagerV1._gen_c()
|
||||
ZwlrScreencopyManagerV1.proxy_class = ZwlrScreencopyManagerV1Proxy
|
||||
ZwlrScreencopyManagerV1.resource_class = ZwlrScreencopyManagerV1Resource
|
||||
ZwlrScreencopyManagerV1.global_class = ZwlrScreencopyManagerV1Global
|
||||
@@ -0,0 +1,100 @@
|
||||
"""Encode one frame as PNG, with nothing but the standard library.
|
||||
|
||||
Why hand-rolled: the in-process capture backend (``wayland_capture``) needs to
|
||||
publish *something* the contract allows, and PNG is the one format Python can
|
||||
produce without a dependency -- ``zlib`` and ``struct`` are already here, and the
|
||||
alternative (a JPEG binding) would put a compiled library into a package whose
|
||||
stated policy is that the frame socket, the CLI and the broker are stdlib-only.
|
||||
|
||||
The tradeoff is bytes, not speed, and it is worth stating plainly because the
|
||||
deployment config chose differently: measured on this machine, a 1280x720 JPEG
|
||||
q80 frame is ~105-130 KB and a PNG of the same frame is ~580 KB. PNG costs more
|
||||
on the wire; it does not cost an extra dependency. A later change that wants JPEG
|
||||
has to bring an encoder (``libjpeg-turbo`` through ``ctypes`` measured ~1.7 ms for
|
||||
a 1280x720 frame, which is cheap -- the cost is the dependency, not the time).
|
||||
|
||||
**No filtering.** Every scanline is written with filter type 0 (None), because
|
||||
filtering is where a hand-rolled encoder goes wrong and the compressor's own
|
||||
search does most of the work on a screenshot. That is a deliberate
|
||||
simplicity-for-bytes trade, and it is why the compression level is configurable:
|
||||
level 1 measured far cheaper than level 6 for frames that are transcoded to a
|
||||
lossy format anyway, if a caller ever puts a JPEG step behind this.
|
||||
|
||||
The input is a ``wl_shm`` frame: 32 bits per pixel, little-endian, with the
|
||||
channels in memory order **B, G, R, X** (that is ``XRGB8888``/``ARGB8888`` --
|
||||
the compositor's format names describe the 32-bit word, not the byte order). The
|
||||
alpha byte is dropped rather than converted, so the output is colour type 2
|
||||
(truecolour RGB): the frames this server publishes are opaque, and a needless
|
||||
alpha channel would cost a quarter more bytes for nothing.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import struct
|
||||
import zlib
|
||||
|
||||
#: PNG colour type 2 = truecolour RGB, 8 bits per channel.
|
||||
_COLOR_TYPE_RGB = 2
|
||||
_BIT_DEPTH = 8
|
||||
_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||||
|
||||
|
||||
def encode_rgb(width: int, height: int, stride: int, pixels: bytes | memoryview,
|
||||
level: int = 1) -> bytes:
|
||||
"""Return a PNG of the frame in *pixels*.
|
||||
|
||||
``stride`` is the row pitch in bytes as the compositor reported it, which is
|
||||
not always ``width * 4`` -- some backends pad rows. Using it rather than
|
||||
assuming is the difference between a correct image and a sheared one, and it
|
||||
is exactly the bug ``grim`` had in its 1.5 release.
|
||||
|
||||
``pixels`` must hold at least ``stride * height`` bytes.
|
||||
"""
|
||||
if width <= 0 or height <= 0:
|
||||
raise ValueError(f"frame must have a positive size, got {width}x{height}")
|
||||
if stride < width * 4:
|
||||
raise ValueError(f"stride {stride} is too small for {width} pixels per row")
|
||||
needed = stride * height
|
||||
if len(pixels) < needed:
|
||||
raise ValueError(f"frame buffer holds {len(pixels)} bytes, needs {needed}")
|
||||
|
||||
view = memoryview(pixels).cast("B") if not isinstance(pixels, memoryview) else pixels.cast("B")
|
||||
|
||||
# One filter byte per scanline, then the RGB triples lifted out of BGRX.
|
||||
raw = bytearray(height * (1 + width * 3))
|
||||
source = 0
|
||||
target = 0
|
||||
row_bytes = width * 3
|
||||
for _ in range(height):
|
||||
raw[target] = 0 # filter: None
|
||||
target += 1
|
||||
# `pixels[row:row+row_bytes]` is a strided copy; the slice assignment
|
||||
# below is the fast path (a C-level memcpy per channel).
|
||||
raw[target:target + row_bytes:3] = view[source + 2:source + stride:4][:width]
|
||||
raw[target + 1:target + row_bytes:3] = view[source + 1:source + stride:4][:width]
|
||||
raw[target + 2:target + row_bytes:3] = view[source:source + stride:4][:width]
|
||||
source += stride
|
||||
target += row_bytes
|
||||
|
||||
return b"".join(
|
||||
[
|
||||
_SIGNATURE,
|
||||
_chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, _BIT_DEPTH,
|
||||
_COLOR_TYPE_RGB, 0, 0, 0)),
|
||||
_chunk(b"IDAT", zlib.compress(bytes(raw), level)),
|
||||
_chunk(b"IEND", b""),
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
def _chunk(kind: bytes, payload: bytes) -> bytes:
|
||||
"""A PNG chunk: length, type, payload, CRC over type+payload."""
|
||||
return (
|
||||
struct.pack(">I", len(payload))
|
||||
+ kind
|
||||
+ payload
|
||||
+ struct.pack(">I", zlib.crc32(kind + payload) & 0xFFFFFFFF)
|
||||
)
|
||||
|
||||
|
||||
__all__ = ["encode_rgb"]
|
||||
+58
-5
@@ -297,6 +297,10 @@ class FrameServer:
|
||||
#: `--format png` is the module's spelling; the Hello carries the MIME type.
|
||||
_MIME = {"png": "image/png", "jpeg": "image/jpeg"}
|
||||
_CAPTURE_FLAG = "--capture-command"
|
||||
#: Selects a capture backend by name instead of by program: `wayland[:OUTPUT]`.
|
||||
#: Added because the in-process client (see `wayland_capture`) is not a command --
|
||||
#: there is nothing to exec, which is most of why it is faster.
|
||||
_CAPTURE_BACKEND_FLAG = "--capture"
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
@@ -316,6 +320,12 @@ def build_parser() -> argparse.ArgumentParser:
|
||||
"--format", choices=sorted(_MIME), default="png",
|
||||
help="frame encoding (default: %(default)s)",
|
||||
)
|
||||
parser.add_argument(
|
||||
_CAPTURE_BACKEND_FLAG, metavar="BACKEND", default=None,
|
||||
help="capture in-process instead of by command: 'wayland' to capture the "
|
||||
"first output, 'wayland:NAME' to capture that output by name. "
|
||||
"Only PNG can be produced this way, so it needs --format png.",
|
||||
)
|
||||
parser.add_argument(
|
||||
_CAPTURE_FLAG, action="append", dest="capture_command", metavar="TOKEN",
|
||||
help="one argv token of the capture command; repeat once per token "
|
||||
@@ -331,10 +341,16 @@ def main(argv: Iterable[str] | None = None) -> int:
|
||||
level=logging.INFO, stream=sys.stderr,
|
||||
format="%(asctime)s %(levelname)s %(message)s",
|
||||
)
|
||||
capture_command = args.capture_command or _default_capture_command(args.format)
|
||||
if args.capture is None:
|
||||
capture_command = args.capture_command or _default_capture_command(args.format)
|
||||
capture: CaptureBackend = CommandCapture(capture_command)
|
||||
else:
|
||||
capture = _build_capture_backend(args.capture, args.format)
|
||||
if capture is None:
|
||||
return 2
|
||||
server = FrameServer(
|
||||
args.socket,
|
||||
CommandCapture(capture_command),
|
||||
capture,
|
||||
args.fps,
|
||||
fmt=_MIME[args.format],
|
||||
)
|
||||
@@ -353,6 +369,42 @@ def _default_capture_command(fmt: str) -> list[str]:
|
||||
return ["grim", "-t", fmt, "-"]
|
||||
|
||||
|
||||
def _build_capture_backend(spec: str, fmt: str) -> CaptureBackend | None:
|
||||
"""Turn `--capture BACKEND` into a backend, or log why it cannot be one.
|
||||
|
||||
The in-process backend publishes PNG, because PNG is the one format this
|
||||
package can produce without a dependency (see `png.encode_rgb`). Rather than
|
||||
advertise a MIME type the frames do not have -- the Hello carries the format,
|
||||
and a client that trusts it would mis-decode every frame -- this refuses the
|
||||
combination and says what to do instead.
|
||||
"""
|
||||
if fmt != "png":
|
||||
log.error(
|
||||
"the in-process capture backend publishes PNG only, but --format %s "
|
||||
"was asked for; JPEG in-process needs an encoder this package does "
|
||||
"not carry yet, so use --format png or the command backend", fmt,
|
||||
)
|
||||
return None
|
||||
if spec == "wayland":
|
||||
output = None
|
||||
elif spec.startswith("wayland:"):
|
||||
output = spec.split(":", 1)[1] or None
|
||||
if output is not None and ":" in output:
|
||||
# `wayland:A:B` is a typo or a wrong separator, not an output name:
|
||||
# no compositor calls a monitor "A:B", and carrying it through would
|
||||
# only turn into "no output named ..." after a connection.
|
||||
log.error("output name %r contains ':' -- use 'wayland:NAME'", output)
|
||||
return None
|
||||
else:
|
||||
log.error("unknown capture backend %r; the only one is 'wayland[:OUTPUT]'", spec)
|
||||
return None
|
||||
# Imported here rather than at module scope: a deployment using the command
|
||||
# backend (still the default) should not need pywayland importable at all.
|
||||
from .wayland_capture import WaylandCapture
|
||||
|
||||
return WaylandCapture(output=output)
|
||||
|
||||
|
||||
def _positive_int(text: str) -> int:
|
||||
value = int(text)
|
||||
if value <= 0:
|
||||
@@ -365,7 +417,8 @@ def _join_capture_tokens(argv: Iterable[str] | None) -> list[str] | None:
|
||||
|
||||
Capture tokens are argv tokens, and real ones start with a dash (`-t`, `-`
|
||||
in the default `grim -t png -`). argparse would read those as options, so
|
||||
the separated form is folded into the `=` form before it sees them.
|
||||
the separated form is folded into the `=` form before it sees them. The
|
||||
backend flag gets the same treatment so both arrive in one shape.
|
||||
"""
|
||||
if argv is None:
|
||||
argv = sys.argv[1:]
|
||||
@@ -377,8 +430,8 @@ def _join_capture_tokens(argv: Iterable[str] | None) -> list[str] | None:
|
||||
if token == "--": # everything after this is positional; leave it alone
|
||||
out.extend(tokens[i:])
|
||||
break
|
||||
if token == _CAPTURE_FLAG and i + 1 < len(tokens):
|
||||
out.append(f"{_CAPTURE_FLAG}={tokens[i + 1]}")
|
||||
if token in (_CAPTURE_FLAG, _CAPTURE_BACKEND_FLAG) and i + 1 < len(tokens):
|
||||
out.append(f"{token}={tokens[i + 1]}")
|
||||
i += 2
|
||||
continue
|
||||
out.append(token)
|
||||
|
||||
@@ -0,0 +1,387 @@
|
||||
"""Capture frames from the compositor in-process, instead of by running grim.
|
||||
|
||||
This replaces a subprocess per frame with one long-lived Wayland client, and the
|
||||
measurements behind that decision (spike ``capture-speed``, 1280x720, one
|
||||
session's container, JPEG q80, 200 frames) are worth stating because they are the
|
||||
whole reason this module exists:
|
||||
|
||||
=========================== ========= ============= =============
|
||||
route p50 ms fps compositor CPU
|
||||
=========================== ========= ============= =============
|
||||
``grim`` (subprocess) 117.3 8.1 116.4 ms/frame
|
||||
``grim-rs`` (Rust crate) 124.6 7.5 123.1 ms/frame
|
||||
this client 78.0 13.9 67.5 ms/frame
|
||||
=========================== ========= ============= =============
|
||||
|
||||
Three things follow, and each one shaped the code below:
|
||||
|
||||
1. **The win is buffer reuse, not language.** ``grim`` and ``grim-rs`` both hand
|
||||
the compositor a *new* shared-memory buffer for every frame (grim because it
|
||||
is a one-shot tool, grim-rs because its API returns owned pixels and so
|
||||
allocates and copies per capture). The compositor then imports and copies into
|
||||
a fresh buffer each time -- which is why their compositor CPU is nearly double
|
||||
ours. So this class creates one buffer per output and keeps it. Measured in
|
||||
isolation, the per-frame allocate-and-copy that grim-rs pays costs only 2.4 ms
|
||||
of *client* time; the other ~40 ms shows up inside the compositor.
|
||||
2. **A persistent client also stops paying a round trip per frame.** ~95% of a
|
||||
grim frame is waiting -- fork, connect, handshake, round trip -- not encoding.
|
||||
3. **Keep the deprecated protocol.** ``zwlr-screencopy-v1`` is deprecated in
|
||||
favour of ``ext-image-copy-capture-v1``, which was measured as identical
|
||||
(78.0 vs 77.7 ms, compositor 67.5 vs 67.2) and which appears in a Hyprland
|
||||
segfault stack (``CScreenshareFrame::transform()`` reached from
|
||||
``create_frame``). When that crash is fixed, the switch is a constant here.
|
||||
|
||||
**Why the wait is a poll loop and not a signal.** The frame server captures in a
|
||||
worker thread (``FrameServer._capture_loop``), so ``SIGALRM`` -- the obvious way to
|
||||
bound a blocking wait, and what the spike used -- is unavailable: signals are only
|
||||
delivered to the main thread. ``pywayland`` only reads events from
|
||||
``read()``/``dispatch(block=True)``, both of which block without a timeout, and
|
||||
``dispatch(block=False)`` never reads at all (it only drains events that were
|
||||
already read). So this waits on the display fd itself with ``select`` and then
|
||||
lets pywayland read, which is the only combination here that both bounds the wait
|
||||
and actually reads.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import mmap
|
||||
import os
|
||||
import select
|
||||
from typing import Any
|
||||
|
||||
from pywayland.client import Display
|
||||
|
||||
from ._protocol.wayland.wl_output import WlOutput
|
||||
from ._protocol.wayland.wl_shm import WlShm
|
||||
from ._protocol.wlr_screencopy_unstable_v1.zwlr_screencopy_manager_v1 import (
|
||||
ZwlrScreencopyManagerV1,
|
||||
)
|
||||
from .capture import CaptureError
|
||||
from .png import encode_rgb
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
#: `wl_shm` format 0 is ARGB8888; the compositor's byte order for both it and
|
||||
#: XRGB8888 is B, G, R, X in memory. Only these two are accepted.
|
||||
_FORMAT_ARGB8888 = 0
|
||||
_FORMAT_XRGB8888 = 1
|
||||
_ACCEPTED_FORMATS = (_FORMAT_ARGB8888, _FORMAT_XRGB8888)
|
||||
|
||||
|
||||
class _ShmBuffer:
|
||||
"""One shared-memory buffer, created once and reused for every frame.
|
||||
|
||||
`memfd_create` rather than a temporary file: the buffer never needs a name,
|
||||
never needs to survive this process, and a memfd cannot leak a file behind a
|
||||
crash the way `mkstemp` can. That is the same choice that makes this cheaper
|
||||
than grim-rs, which writes a fresh temp file per capture.
|
||||
"""
|
||||
|
||||
def __init__(self, shm: Any, width: int, height: int, stride: int, fmt: int) -> None:
|
||||
self.width = width
|
||||
self.height = height
|
||||
self.stride = stride
|
||||
self.format = fmt
|
||||
self.size = stride * height
|
||||
self.fd = os.memfd_create("hhstream-frame", os.MFD_CLOEXEC)
|
||||
os.ftruncate(self.fd, self.size)
|
||||
self.map = mmap.mmap(self.fd, self.size, prot=mmap.PROT_READ | mmap.PROT_WRITE)
|
||||
self.pool = shm.create_pool(self.fd, self.size)
|
||||
self.buffer = self.pool.create_buffer(0, width, height, stride, fmt)
|
||||
|
||||
def destroy(self) -> None:
|
||||
for closer in (getattr(self, "buffer", None), getattr(self, "pool", None)):
|
||||
if closer is not None:
|
||||
closer.destroy()
|
||||
self.buffer = self.pool = None
|
||||
self.map.close()
|
||||
os.close(self.fd)
|
||||
|
||||
|
||||
class WaylandCapture:
|
||||
"""A capture backend (see `capture.CaptureBackend`) speaking Wayland directly.
|
||||
|
||||
One connection and one buffer per output, kept for the process's lifetime: the
|
||||
point of the exercise is that neither is rebuilt per frame. `grab()` returns a
|
||||
PNG (see `png.py` for why PNG and what it costs).
|
||||
|
||||
The connection is rebuilt on demand: any failure inside a frame tears the
|
||||
client down, so the next `grab()` reconnects rather than failing forever. A
|
||||
compositor restart (this server is `Restart=always` and so is the compositor)
|
||||
must not leave the frame server permanently blind.
|
||||
"""
|
||||
|
||||
#: The frame server's equivalent of a timeout: how long one frame may take
|
||||
#: before `grab()` gives up. Bounds the *wait for events*, not the encode.
|
||||
DEFAULT_TIMEOUT = 5.0
|
||||
|
||||
def __init__(self, output: str | None = None, timeout: float = DEFAULT_TIMEOUT,
|
||||
display: str | None = None, level: int = 1) -> None:
|
||||
if timeout is not None and timeout <= 0:
|
||||
raise ValueError(f"capture timeout must be positive, got {timeout!r}")
|
||||
self.output_name = output
|
||||
self.timeout = timeout
|
||||
#: `None` means "whatever WAYLAND_DISPLAY says", which is how the module
|
||||
#: runs this: the service shares the compositor's private runtime dir.
|
||||
self.display_name = display
|
||||
self.level = level
|
||||
self._display: Any = None
|
||||
self._shm: Any = None
|
||||
self._manager: Any = None
|
||||
self._output: Any = None
|
||||
self._buffer: _ShmBuffer | None = None
|
||||
self._size: tuple[int, int] = (0, 0)
|
||||
self._outputs: dict[str, Any] = {}
|
||||
self._names_pending = 0
|
||||
self._frame: Any = None
|
||||
self._ready: bool | None = None
|
||||
self._failure: str | None = None
|
||||
self._advertised: tuple[int, int, int, int] | None = None
|
||||
|
||||
# -- the two-method backend interface ---------------------------------
|
||||
|
||||
def size(self) -> tuple[int, int]:
|
||||
"""Pixel size of the captured output; ``(0, 0)`` until the first frame.
|
||||
|
||||
The server uses this for the Hello, and the contract forbids a Hello with
|
||||
zero size -- so reporting nothing until a frame has actually arrived is
|
||||
the correct behaviour, not a placeholder.
|
||||
"""
|
||||
return self._size
|
||||
|
||||
def grab(self) -> bytes:
|
||||
"""Capture one frame and return it as PNG. Raises `CaptureError`."""
|
||||
self._ensure_connected()
|
||||
try:
|
||||
self._wait_for_buffer()
|
||||
self._copy_frame()
|
||||
self._wait_for_ready()
|
||||
assert self._buffer is not None
|
||||
return encode_rgb(self._buffer.width, self._buffer.height,
|
||||
self._buffer.stride, memoryview(self._buffer.map),
|
||||
level=self.level)
|
||||
except CaptureError:
|
||||
raise
|
||||
except Exception as exc: # pywayland and the kernel can both throw
|
||||
self.close()
|
||||
raise CaptureError(f"wayland capture failed: {exc}") from exc
|
||||
|
||||
def close(self) -> None:
|
||||
"""Drop the connection and the buffer. Safe to call twice, and after a
|
||||
failure -- it is the recovery path, not just a shutdown path."""
|
||||
if self._buffer is not None:
|
||||
try:
|
||||
self._buffer.destroy()
|
||||
except Exception: # a dead connection cannot destroy anything
|
||||
log.debug("could not destroy the shm buffer cleanly", exc_info=True)
|
||||
self._buffer = None
|
||||
if self._display is not None:
|
||||
try:
|
||||
self._display.disconnect()
|
||||
except Exception:
|
||||
log.debug("could not disconnect cleanly", exc_info=True)
|
||||
self._display = None
|
||||
self._shm = None
|
||||
self._manager = None
|
||||
self._output = None
|
||||
self._outputs = {}
|
||||
self._frame = None
|
||||
self._advertised = None
|
||||
|
||||
# -- connection --------------------------------------------------------
|
||||
|
||||
def _ensure_connected(self) -> None:
|
||||
if self._display is not None and self._manager is not None:
|
||||
return
|
||||
self.close()
|
||||
display = Display(self.display_name)
|
||||
try:
|
||||
display.connect()
|
||||
registry = display.get_registry()
|
||||
registry.dispatcher["global"] = self._on_global
|
||||
registry.dispatcher["global_remove"] = self._on_global_remove
|
||||
display.roundtrip()
|
||||
except Exception as exc:
|
||||
self.close()
|
||||
raise CaptureError(
|
||||
f"cannot connect to Wayland display "
|
||||
f"{self.display_name or os.environ.get('WAYLAND_DISPLAY', '(unset)')!r}: {exc}"
|
||||
) from exc
|
||||
if self._manager is None:
|
||||
raise CaptureError(
|
||||
"compositor does not advertise zwlr_screencopy_manager_v1: "
|
||||
"this backend needs a wlroots-style compositor (Hyprland, sway, ...)"
|
||||
)
|
||||
if self._shm is None:
|
||||
raise CaptureError("compositor does not advertise wl_shm; cannot capture pixels")
|
||||
self._display = display
|
||||
self._choose_output()
|
||||
|
||||
def _on_global(self, registry: Any, name: int, interface: str, version: int) -> None:
|
||||
if interface == WlShm.name and self._shm is None:
|
||||
self._shm = registry.bind(name, WlShm, min(version, 1))
|
||||
elif interface == ZwlrScreencopyManagerV1.name and self._manager is None:
|
||||
# v3 is the last revision of the deprecated protocol; asking for more
|
||||
# than the compositor offers is a protocol error, hence the min().
|
||||
self._manager = registry.bind(name, ZwlrScreencopyManagerV1, min(version, 3))
|
||||
elif interface == WlOutput.name:
|
||||
# `name` (the string the operator means by "Virtual-1") only exists in
|
||||
# v4; older outputs have to be matched by make/model instead, which
|
||||
# this backend does not pretend to do.
|
||||
output = registry.bind(name, WlOutput, min(version, 4))
|
||||
output.dispatcher["name"] = self._on_output_name
|
||||
output.dispatcher["geometry"] = self._on_output_geometry
|
||||
self._names_pending += 1
|
||||
self._outputs[str(name)] = output
|
||||
|
||||
def _on_global_remove(self, registry: Any, name: int) -> None:
|
||||
output = self._outputs.pop(str(name), None)
|
||||
if output is not None and output is self._output:
|
||||
# The output we were capturing is gone (the usual cause: its session
|
||||
# was killed). Drop it so the next grab reconnects and re-selects --
|
||||
# keeping it would mean capturing an object the compositor freed.
|
||||
log.info("output %s went away; will re-select on the next frame", name)
|
||||
self._output = None
|
||||
|
||||
def _on_output_name(self, output: Any, name: str) -> None:
|
||||
setattr(output, "_hhstream_name", name)
|
||||
self._names_pending = max(0, self._names_pending - 1)
|
||||
|
||||
def _on_output_geometry(self, output: Any, x: int, y: int, physical_width: int,
|
||||
physical_height: int, subpixel: int, make: str, model: str,
|
||||
transform: int) -> None:
|
||||
setattr(output, "_hhstream_model", f"{make} {model}".strip())
|
||||
|
||||
def _choose_output(self) -> None:
|
||||
"""Pick the output to capture, by name if one was given.
|
||||
|
||||
A second roundtrip is what fills in the names and geometry, because those
|
||||
are events: after binding, the compositor has to be given a chance to
|
||||
answer before any output can be identified.
|
||||
"""
|
||||
assert self._display is not None
|
||||
if self._outputs:
|
||||
self._display.roundtrip()
|
||||
if not self._outputs:
|
||||
raise CaptureError("compositor advertises no outputs to capture")
|
||||
if self.output_name is None:
|
||||
# Request order, not dict order: the compositor's first output is the
|
||||
# one `grim` would have used with no `-o`, and matching that keeps the
|
||||
# two backends interchangeable.
|
||||
self._output = next(iter(self._outputs.values()))
|
||||
log.info("capturing first output (of %d)", len(self._outputs))
|
||||
return
|
||||
for output in self._outputs.values():
|
||||
if getattr(output, "_hhstream_name", None) == self.output_name:
|
||||
self._output = output
|
||||
return
|
||||
known = ", ".join(sorted(
|
||||
str(getattr(o, "_hhstream_name", None) or getattr(o, "_hhstream_model", "?"))
|
||||
for o in self._outputs.values()
|
||||
))
|
||||
raise CaptureError(
|
||||
f"no output named {self.output_name!r}; the compositor has: {known}"
|
||||
)
|
||||
|
||||
# -- one frame ---------------------------------------------------------
|
||||
|
||||
def _wait_for_buffer(self) -> None:
|
||||
"""Create a frame and wait for the compositor to describe the buffer.
|
||||
|
||||
The `buffer` event (format, size, stride) arrives *before* any buffer can
|
||||
be allocated -- it is the compositor telling us what it is going to send.
|
||||
Attaching a buffer before it arrives is attaching ``None``, which is how
|
||||
this failed the first time it was written.
|
||||
"""
|
||||
assert self._manager is not None and self._output is not None
|
||||
self._ready = None
|
||||
self._failure = None
|
||||
self._advertised = None
|
||||
frame = self._manager.capture_output(1, self._output)
|
||||
frame.dispatcher["buffer"] = self._on_frame_buffer
|
||||
frame.dispatcher["flags"] = self._on_frame_flags
|
||||
frame.dispatcher["ready"] = self._on_frame_ready
|
||||
frame.dispatcher["failed"] = self._on_frame_failed
|
||||
self._frame = frame
|
||||
self._pump(lambda: self._advertised is not None or self._failure is not None,
|
||||
"the compositor never described a frame buffer")
|
||||
if self._failure is not None:
|
||||
raise CaptureError(f"compositor refused the frame: {self._failure}")
|
||||
assert self._advertised is not None
|
||||
fmt, width, height, stride = self._advertised
|
||||
if self._buffer is None or (self._buffer.format, self._buffer.width,
|
||||
self._buffer.height, self._buffer.stride) != self._advertised:
|
||||
if self._buffer is not None:
|
||||
self._buffer.destroy()
|
||||
self._buffer = _ShmBuffer(self._shm, width, height, stride, fmt)
|
||||
self._size = (width, height)
|
||||
log.info("capturing %dx%d stride %d", width, height, stride)
|
||||
|
||||
def _on_frame_buffer(self, frame: Any, fmt: int, width: int, height: int, stride: int) -> None:
|
||||
if fmt not in _ACCEPTED_FORMATS:
|
||||
self._failure = f"unsupported shm format {fmt}"
|
||||
return
|
||||
self._advertised = (fmt, width, height, stride)
|
||||
|
||||
def _on_frame_flags(self, frame: Any, flags: int) -> None:
|
||||
# Bit 0 is y_invert, which this backend does not handle: Hyprland does not
|
||||
# set it for outputs, but a compositor that did would produce an upside
|
||||
# down image rather than a wrong one, so refusing is not worth it. Logged
|
||||
# so the cause is not a mystery if it ever shows up.
|
||||
if flags & 1:
|
||||
log.warning("compositor set y_invert on this frame; the image will be flipped")
|
||||
|
||||
def _on_frame_ready(self, frame: Any, tv_sec: int, tv_nsec: int, *rest: Any) -> None:
|
||||
self._ready = True
|
||||
|
||||
def _on_frame_failed(self, frame: Any, reason: str) -> None:
|
||||
self._ready = False
|
||||
self._failure = reason or "unknown reason"
|
||||
|
||||
def _copy_frame(self) -> None:
|
||||
"""Ask for the copy, now that a buffer exists to receive it."""
|
||||
assert self._frame is not None and self._buffer is not None
|
||||
self._frame.copy(self._buffer.buffer)
|
||||
|
||||
def _wait_for_ready(self) -> None:
|
||||
self._pump(lambda: self._ready is not None, "the compositor never sent the frame")
|
||||
if self._ready is not True:
|
||||
raise CaptureError(f"compositor could not fill the frame: {self._failure}")
|
||||
if self._frame is not None:
|
||||
self._frame.destroy()
|
||||
self._frame = None
|
||||
|
||||
def _pump(self, done: Any, message: str) -> None:
|
||||
"""Dispatch events until *done* is true, or `timeout` elapses.
|
||||
|
||||
See the module docstring for why this is a poll loop rather than a
|
||||
signal-bounded blocking dispatch, and note that this is bound by
|
||||
`timeout` as a whole: a compositor that trickles events forever is
|
||||
exactly the failure this is here to catch.
|
||||
"""
|
||||
assert self._display is not None
|
||||
fd = self._display.get_fd()
|
||||
deadline = _monotonic() + self.timeout
|
||||
while not done():
|
||||
remaining = deadline - _monotonic()
|
||||
if remaining <= 0:
|
||||
raise CaptureError(f"timed out after {self.timeout}s: {message}")
|
||||
self._display.flush()
|
||||
if self._display.dispatch(block=False):
|
||||
continue
|
||||
readable, _, _ = select.select([fd], [], [], remaining)
|
||||
if not readable:
|
||||
raise CaptureError(f"timed out after {self.timeout}s: {message}")
|
||||
self._display.read()
|
||||
self._display.dispatch(block=False)
|
||||
|
||||
|
||||
def _monotonic() -> float:
|
||||
"""Indirection so tests can drive the clock instead of waiting for it."""
|
||||
import time
|
||||
|
||||
return time.monotonic()
|
||||
|
||||
|
||||
__all__ = ["WaylandCapture"]
|
||||
@@ -0,0 +1,121 @@
|
||||
"""`hhstream.png`: the hand-rolled PNG encoder, checked against zlib itself.
|
||||
|
||||
There is no image library in the unit environment (the whole point of this
|
||||
encoder is that it needs none), so the decoder below is written from the PNG
|
||||
spec too. That is not a weakness of the test: it re-derives the scanlines from
|
||||
the file the encoder produced and compares them with the pixels that went in,
|
||||
which is exactly the property that matters -- a wrong stride, a wrong colour
|
||||
type or a byte order slip all show up as a mismatch rather than as a file that
|
||||
merely starts with the right eight bytes.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import struct
|
||||
import zlib
|
||||
|
||||
import pytest
|
||||
|
||||
from hhstream.png import encode_rgb
|
||||
|
||||
SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||||
|
||||
|
||||
def decode(png: bytes) -> tuple[int, int, bytes]:
|
||||
"""Return (width, height, rgb scanlines) for a PNG this encoder can produce."""
|
||||
assert png.startswith(SIGNATURE), "missing PNG signature"
|
||||
offset = len(SIGNATURE)
|
||||
width = height = None
|
||||
idat = b""
|
||||
while offset < len(png):
|
||||
(length,) = struct.unpack(">I", png[offset:offset + 4])
|
||||
kind = png[offset + 4:offset + 8]
|
||||
payload = png[offset + 8:offset + 8 + length]
|
||||
crc = png[offset + 8 + length:offset + 12 + length]
|
||||
assert struct.unpack(">I", crc)[0] == zlib.crc32(kind + payload) & 0xFFFFFFFF, (
|
||||
f"bad CRC on {kind!r} chunk -- the file is corrupt"
|
||||
)
|
||||
if kind == b"IHDR":
|
||||
width, height, depth, color, comp, filt, interlace = struct.unpack(">IIBBBBB", payload)
|
||||
assert (depth, color, comp, filt, interlace) == (8, 2, 0, 0, 0)
|
||||
elif kind == b"IDAT":
|
||||
idat += payload
|
||||
offset += 12 + length
|
||||
|
||||
assert width is not None and height is not None, "no IHDR chunk in the file"
|
||||
raw = zlib.decompress(idat)
|
||||
stride = width * 3
|
||||
assert len(raw) == height * (1 + stride), "the scanline payload is the wrong length"
|
||||
out = bytearray()
|
||||
for row in range(height):
|
||||
start = row * (1 + stride)
|
||||
assert raw[start] == 0, "every scanline should be written unfiltered"
|
||||
out += raw[start + 1:start + 1 + stride]
|
||||
return width, height, bytes(out)
|
||||
|
||||
|
||||
def bgrx(width: int, height: int, stride: int | None = None) -> bytes:
|
||||
"""A frame in the compositor's memory order: B, G, R, X per pixel."""
|
||||
stride = stride if stride is not None else width * 4
|
||||
out = bytearray()
|
||||
for y in range(height):
|
||||
row = bytearray()
|
||||
for x in range(width):
|
||||
row += bytes(((x * 3) % 256, (y * 5) % 256, (x + y) % 256, 0x00))
|
||||
row += b"\xee" * (stride - width * 4) # row padding, if any
|
||||
out += row
|
||||
return bytes(out)
|
||||
|
||||
|
||||
def test_pixels_round_trip_in_the_right_channel_order():
|
||||
frame = bgrx(4, 2)
|
||||
width, height, rgb = decode(encode_rgb(4, 2, 16, frame))
|
||||
assert (width, height) == (4, 2)
|
||||
# Pixel (x, y) went in as B,G,R,X; it must come out as R,G,B.
|
||||
for y in range(2):
|
||||
for x in range(4):
|
||||
b, g, r, _ = frame[(y * 4 + x) * 4:(y * 4 + x) * 4 + 4]
|
||||
assert rgb[(y * 4 + x) * 3:(y * 4 + x) * 3 + 3] == bytes((r, g, b)), (
|
||||
f"channel order is wrong at ({x}, {y})"
|
||||
)
|
||||
|
||||
|
||||
def test_a_padded_stride_is_honoured_rather_than_assumed():
|
||||
"""`stride` is the compositor's row pitch, not `width * 4`.
|
||||
|
||||
Assuming it would shear the image, which is the bug grim 1.5 shipped -- so
|
||||
the padding bytes below are deliberately not black: if they leak into the
|
||||
output the comparison fails.
|
||||
"""
|
||||
width, height, stride = 3, 2, 20 # 12 meaningful bytes, 8 bytes of padding
|
||||
frame = bgrx(width, height, stride)
|
||||
_, _, rgb = decode(encode_rgb(width, height, stride, frame))
|
||||
assert rgb == b"".join(
|
||||
bytes(reversed(frame[(y * stride + x * 4):(y * stride + x * 4) + 3]))
|
||||
for y in range(height)
|
||||
for x in range(width)
|
||||
)
|
||||
|
||||
|
||||
def test_a_memoryview_of_a_mapping_is_accepted():
|
||||
"""The caller passes `memoryview(shm_map)`, not `bytes`."""
|
||||
frame = bgrx(2, 2)
|
||||
assert encode_rgb(2, 2, 8, memoryview(frame)) == encode_rgb(2, 2, 8, frame)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"kwargs, message",
|
||||
[
|
||||
(dict(width=0, height=4, stride=0), "positive size"),
|
||||
(dict(width=4, height=0, stride=16), "positive size"),
|
||||
(dict(width=4, height=4, stride=8), "too small"),
|
||||
],
|
||||
)
|
||||
def test_bad_geometry_is_rejected_before_anything_is_encoded(kwargs, message):
|
||||
with pytest.raises(ValueError, match=message):
|
||||
encode_rgb(pixels=b"\x00" * 64, **kwargs)
|
||||
|
||||
|
||||
def test_a_short_buffer_is_rejected_rather_than_encoding_garbage():
|
||||
with pytest.raises(ValueError, match="needs"):
|
||||
encode_rgb(4, 4, 16, b"\x00" * 63)
|
||||
@@ -0,0 +1,130 @@
|
||||
"""The in-process capture backend, in the parts that need no compositor.
|
||||
|
||||
Everything that needs a real Wayland connection is left to the vm checks
|
||||
(`checks/vm-hyprland.nix` runs the server against the actual headless
|
||||
compositor), so what is worth testing here is the behaviour around the edges: the
|
||||
timeout that stops a frame from hanging forever, the recovery path that makes a
|
||||
dead compositor reconnectable, and the argv the module and the CLI agree on.
|
||||
|
||||
The `_pump` tests are the point of the file. `pywayland` only reads events from
|
||||
`read()` and `dispatch(block=True)`, neither of which takes a timeout, so a
|
||||
compositor that stops answering used to mean a capture thread that never returns
|
||||
-- and a frame server that has silently stopped serving while its socket still
|
||||
accepts connections. The stub display below is a real pipe fd that never becomes
|
||||
readable: the test passes only if the deadline is what ends the wait.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
import pytest
|
||||
|
||||
from hhstream.capture import CaptureError
|
||||
from hhstream.server import _build_capture_backend, _join_capture_tokens, build_parser
|
||||
from hhstream.wayland_capture import WaylandCapture
|
||||
|
||||
|
||||
class _StubDisplay:
|
||||
"""Just enough `Display` for `_pump`: a fd, and a dispatch that finds nothing."""
|
||||
|
||||
def __init__(self, fd: int) -> None:
|
||||
self._fd = fd
|
||||
self.reads = 0
|
||||
|
||||
def get_fd(self) -> int:
|
||||
return self._fd
|
||||
|
||||
def flush(self) -> None:
|
||||
return None
|
||||
|
||||
def dispatch(self, *, block: bool = False, queue=None) -> int:
|
||||
return 0
|
||||
|
||||
def read(self, *, queue=None) -> None:
|
||||
# Reached only if select() said the fd was readable; on this pipe it never
|
||||
# is, so arriving here means the wait was not bounded by the deadline.
|
||||
self.reads += 1
|
||||
raise AssertionError("read() called although nothing was readable")
|
||||
|
||||
|
||||
def test_a_frame_that_never_arrives_raises_instead_of_hanging():
|
||||
capture = WaylandCapture(timeout=0.05)
|
||||
read_fd, write_fd = os.pipe()
|
||||
stub = _StubDisplay(read_fd)
|
||||
capture._display = stub
|
||||
try:
|
||||
with pytest.raises(CaptureError, match="timed out"):
|
||||
capture._pump(lambda: False, "the compositor never sent the frame")
|
||||
assert stub.reads == 0, "it waited on a readable fd instead of on the clock"
|
||||
finally:
|
||||
os.close(read_fd)
|
||||
os.close(write_fd)
|
||||
|
||||
|
||||
def test_the_pump_returns_immediately_when_it_is_already_done():
|
||||
"""A queued event must not cost a select() timeout to notice."""
|
||||
capture = WaylandCapture(timeout=0.05)
|
||||
read_fd, write_fd = os.pipe()
|
||||
capture._display = _StubDisplay(read_fd)
|
||||
try:
|
||||
capture._pump(lambda: True, "nothing to wait for")
|
||||
finally:
|
||||
os.close(read_fd)
|
||||
os.close(write_fd)
|
||||
|
||||
|
||||
def test_size_is_unknown_until_a_frame_has_actually_been_captured():
|
||||
"""The Hello must never carry a size that was guessed."""
|
||||
capture = WaylandCapture()
|
||||
assert capture.size() == (0, 0)
|
||||
|
||||
|
||||
def test_close_is_safe_twice_and_before_anything_was_opened():
|
||||
"""`close()` is the recovery path, so it runs on a half-torn-down backend."""
|
||||
capture = WaylandCapture()
|
||||
capture.close()
|
||||
capture.close()
|
||||
assert capture.size() == (0, 0)
|
||||
|
||||
|
||||
def test_a_timeout_of_zero_or_less_is_refused_at_construction():
|
||||
with pytest.raises(ValueError, match="positive"):
|
||||
WaylandCapture(timeout=0)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"spec, expected_output",
|
||||
[("wayland", None), ("wayland:Virtual-1", "Virtual-1"), ("wayland:", None)],
|
||||
)
|
||||
def test_the_backend_spec_selects_an_output_without_connecting(spec, expected_output):
|
||||
"""Constructing the backend must not open a connection -- grab() does."""
|
||||
backend = _build_capture_backend(spec, "png")
|
||||
assert isinstance(backend, WaylandCapture)
|
||||
assert backend.output_name == expected_output
|
||||
assert backend._display is None, "the connection belongs to grab(), not to __init__"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("spec", ["grim", "wayland:too:many:colons:here", "x11"])
|
||||
def test_an_unknown_backend_spec_is_refused_rather_than_guessed(spec, caplog):
|
||||
"""`wayland:a:b` is not an output name, and guessing would capture the wrong
|
||||
output silently."""
|
||||
assert _build_capture_backend(spec, "png") is None
|
||||
|
||||
|
||||
def test_jpeg_is_refused_rather_than_advertised_in_the_hello(caplog):
|
||||
"""The Hello carries the MIME type; publishing jpeg over PNG frames would
|
||||
mis-decode every frame in every client, so it is refused up front."""
|
||||
assert _build_capture_backend("wayland", "jpeg") is None
|
||||
assert "PNG only" in caplog.text
|
||||
|
||||
|
||||
def test_the_backend_flag_survives_the_token_folding_that_capture_tokens_need():
|
||||
folded = _join_capture_tokens(["--capture", "wayland:Virtual-1", "--fps", "10"])
|
||||
assert folded == ["--capture=wayland:Virtual-1", "--fps", "10"]
|
||||
assert build_parser().parse_args(folded).capture == "wayland:Virtual-1"
|
||||
|
||||
|
||||
def test_no_backend_flag_still_means_the_command_backend():
|
||||
args = build_parser().parse_args(["--socket", "/tmp/x.sock"])
|
||||
assert args.capture is None
|
||||
Reference in new issue
Block a user