From a7d9357b4399d44855bf9b970004b666c820bb54 Mon Sep 17 00:00:00 2001 From: Hermenix Date: Sun, 11 Oct 2026 20:34:33 +0000 Subject: [PATCH] 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. --- docs/ARCHITECTURE.md | 24 +- docs/CONTRACT.md | 13 +- nix/module.nix | 54 +- src/hhstream/_protocol/__init__.py | 6 + src/hhstream/_protocol/regenerate.py | 104 +++ src/hhstream/_protocol/wayland/__init__.py | 50 ++ src/hhstream/_protocol/wayland/wl_buffer.py | 112 +++ src/hhstream/_protocol/wayland/wl_callback.py | 85 ++ .../_protocol/wayland/wl_compositor.py | 108 +++ .../_protocol/wayland/wl_data_device.py | 320 +++++++ .../wayland/wl_data_device_manager.py | 136 +++ .../_protocol/wayland/wl_data_offer.py | 325 +++++++ .../_protocol/wayland/wl_data_source.py | 272 ++++++ src/hhstream/_protocol/wayland/wl_display.py | 180 ++++ src/hhstream/_protocol/wayland/wl_fixes.py | 151 ++++ src/hhstream/_protocol/wayland/wl_keyboard.py | 326 +++++++ src/hhstream/_protocol/wayland/wl_output.py | 353 ++++++++ src/hhstream/_protocol/wayland/wl_pointer.py | 627 ++++++++++++++ src/hhstream/_protocol/wayland/wl_region.py | 137 +++ src/hhstream/_protocol/wayland/wl_registry.py | 167 ++++ src/hhstream/_protocol/wayland/wl_seat.py | 234 ++++++ src/hhstream/_protocol/wayland/wl_shell.py | 106 +++ .../_protocol/wayland/wl_shell_surface.py | 463 ++++++++++ src/hhstream/_protocol/wayland/wl_shm.py | 292 +++++++ src/hhstream/_protocol/wayland/wl_shm_pool.py | 165 ++++ .../_protocol/wayland/wl_subcompositor.py | 150 ++++ .../_protocol/wayland/wl_subsurface.py | 232 +++++ src/hhstream/_protocol/wayland/wl_surface.py | 792 ++++++++++++++++++ src/hhstream/_protocol/wayland/wl_touch.py | 306 +++++++ .../wlr_screencopy_unstable_v1/__init__.py | 26 + .../zwlr_screencopy_frame_v1.py | 307 +++++++ .../zwlr_screencopy_manager_v1.py | 142 ++++ src/hhstream/png.py | 100 +++ src/hhstream/server.py | 63 +- src/hhstream/wayland_capture.py | 387 +++++++++ tests/unit/test_png.py | 121 +++ tests/unit/test_wayland_capture.py | 130 +++ 37 files changed, 7556 insertions(+), 10 deletions(-) create mode 100644 src/hhstream/_protocol/__init__.py create mode 100644 src/hhstream/_protocol/regenerate.py create mode 100644 src/hhstream/_protocol/wayland/__init__.py create mode 100644 src/hhstream/_protocol/wayland/wl_buffer.py create mode 100644 src/hhstream/_protocol/wayland/wl_callback.py create mode 100644 src/hhstream/_protocol/wayland/wl_compositor.py create mode 100644 src/hhstream/_protocol/wayland/wl_data_device.py create mode 100644 src/hhstream/_protocol/wayland/wl_data_device_manager.py create mode 100644 src/hhstream/_protocol/wayland/wl_data_offer.py create mode 100644 src/hhstream/_protocol/wayland/wl_data_source.py create mode 100644 src/hhstream/_protocol/wayland/wl_display.py create mode 100644 src/hhstream/_protocol/wayland/wl_fixes.py create mode 100644 src/hhstream/_protocol/wayland/wl_keyboard.py create mode 100644 src/hhstream/_protocol/wayland/wl_output.py create mode 100644 src/hhstream/_protocol/wayland/wl_pointer.py create mode 100644 src/hhstream/_protocol/wayland/wl_region.py create mode 100644 src/hhstream/_protocol/wayland/wl_registry.py create mode 100644 src/hhstream/_protocol/wayland/wl_seat.py create mode 100644 src/hhstream/_protocol/wayland/wl_shell.py create mode 100644 src/hhstream/_protocol/wayland/wl_shell_surface.py create mode 100644 src/hhstream/_protocol/wayland/wl_shm.py create mode 100644 src/hhstream/_protocol/wayland/wl_shm_pool.py create mode 100644 src/hhstream/_protocol/wayland/wl_subcompositor.py create mode 100644 src/hhstream/_protocol/wayland/wl_subsurface.py create mode 100644 src/hhstream/_protocol/wayland/wl_surface.py create mode 100644 src/hhstream/_protocol/wayland/wl_touch.py create mode 100644 src/hhstream/_protocol/wlr_screencopy_unstable_v1/__init__.py create mode 100644 src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_frame_v1.py create mode 100644 src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_manager_v1.py create mode 100644 src/hhstream/png.py create mode 100644 src/hhstream/wayland_capture.py create mode 100644 tests/unit/test_png.py create mode 100644 tests/unit/test_wayland_capture.py diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index ad6cb06..db97f1f 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -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 diff --git a/docs/CONTRACT.md b/docs/CONTRACT.md index 3448b98..13a118a 100644 --- a/docs/CONTRACT.md +++ b/docs/CONTRACT.md @@ -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 --fps --format \ - [--capture-command ...] + [--capture-command ...] [--capture wayland[:NAME]] ``` - `--format` takes the **short name** (`png`, `jpeg`), not a MIME type; the @@ -119,6 +121,13 @@ hhstream-server --socket --fps --format \ --capture-command -`. A single shell string cannot carry a leading `-` unambiguously. The `--capture-command=` form is accepted as well, and the two may be mixed. When absent, the server derives `grim -t -`. +- `--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 diff --git a/nix/module.nix b/nix/module.nix index 4508f50..ed596a5 100644 --- a/nix/module.nix +++ b/nix/module.nix @@ -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 diff --git a/src/hhstream/_protocol/__init__.py b/src/hhstream/_protocol/__init__.py new file mode 100644 index 0000000..1fb9626 --- /dev/null +++ b/src/hhstream/_protocol/__init__.py @@ -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`. +""" diff --git a/src/hhstream/_protocol/regenerate.py b/src/hhstream/_protocol/regenerate.py new file mode 100644 index 0000000..0b5ac16 --- /dev/null +++ b/src/hhstream/_protocol/regenerate.py @@ -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()) diff --git a/src/hhstream/_protocol/wayland/__init__.py b/src/hhstream/_protocol/wayland/__init__.py new file mode 100644 index 0000000..f37d613 --- /dev/null +++ b/src/hhstream/_protocol/wayland/__init__.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_buffer.py b/src/hhstream/_protocol/wayland/wl_buffer.py new file mode 100644 index 0000000..47ec09e --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_buffer.py @@ -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() + `. + """ + 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() + `. + + If a client receives a release event before the frame callback + requested in the same :func:`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 diff --git a/src/hhstream/_protocol/wayland/wl_callback.py b/src/hhstream/_protocol/wayland/wl_callback.py new file mode 100644 index 0000000..33e9dec --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_callback.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_compositor.py b/src/hhstream/_protocol/wayland/wl_compositor.py new file mode 100644 index 0000000..285a507 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_compositor.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_data_device.py b/src/hhstream/_protocol/wayland/wl_data_device.py new file mode 100644 index 0000000..2bcdf8d --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_data_device.py @@ -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() + ` requests can move the + relative position. Attach requests must be confirmed with + :func:`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() + `, if the resulting + action is "copy" or "move", the destination can still perform + :func:`WlDataOffer.receive() + ` requests, and is + expected to end all transfers with a :func:`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() + ` request, or + :func:`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 diff --git a/src/hhstream/_protocol/wayland/wl_data_device_manager.py b/src/hhstream/_protocol/wayland/wl_data_device_manager.py new file mode 100644 index 0000000..64c9a71 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_data_device_manager.py @@ -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() + `, + :func:`WlDataOffer.accept() + ` and + :func:`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 diff --git a/src/hhstream/_protocol/wayland/wl_data_offer.py b/src/hhstream/_protocol/wayland/wl_data_offer.py new file mode 100644 index 0000000..cf824dc --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_data_offer.py @@ -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() + `. Clients may still + use this event in conjunction with :func:`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() + `. 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() + ` 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() + ` 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() + ` or + :func:`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() + `. + + The dnd_actions argument must contain only values expressed in the + :func:`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() + `. + + :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() + ` 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() + `, the chosen action may + change (e.g. due to keyboard modifiers being pressed). At the time of + receiving :func:`WlDataDevice.drop() + ` the drag-and-drop + destination must honor the last action received. + + Action changes may still happen after :func:`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 diff --git a/src/hhstream/_protocol/wayland/wl_data_source.py b/src/hhstream/_protocol/wayland/wl_data_source.py new file mode 100644 index 0000000..5dd9b3a --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_data_source.py @@ -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() + ` 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() + ` 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() + `. 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() + `, 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 diff --git a/src/hhstream/_protocol/wayland/wl_display.py b/src/hhstream/_protocol/wayland/wl_display.py new file mode 100644 index 0000000..62b51cf --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_display.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_fixes.py b/src/hhstream/_protocol/wayland/wl_fixes.py new file mode 100644 index 0000000..b1154a2 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_fixes.py @@ -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() + ` 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() + ` 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()() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_keyboard.py b/src/hhstream/_protocol/wayland/wl_keyboard.py new file mode 100644 index 0000000..9357a57 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_keyboard.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_output.py b/src/hhstream/_protocol/wayland/wl_output.py new file mode 100644 index 0000000..a3c272d --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_output.py @@ -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() + ` + 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() + ` 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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_pointer.py b/src/hhstream/_protocol/wayland/wl_pointer.py new file mode 100644 index 0000000..2a471ab --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_pointer.py @@ -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() + ` 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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_region.py b/src/hhstream/_protocol/wayland/wl_region.py new file mode 100644 index 0000000..a4eae3c --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_region.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_registry.py b/src/hhstream/_protocol/wayland/wl_registry.py new file mode 100644 index 0000000..cde1011 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_registry.py @@ -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() + ` request immediately after + calling :func:`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 diff --git a/src/hhstream/_protocol/wayland/wl_seat.py b/src/hhstream/_protocol/wayland/wl_seat.py new file mode 100644 index 0000000..305c854 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_seat.py @@ -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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_shell.py b/src/hhstream/_protocol/wayland/wl_shell.py new file mode 100644 index 0000000..4568b23 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_shell.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_shell_surface.py b/src/hhstream/_protocol/wayland/wl_shell_surface.py new file mode 100644 index 0000000..a06c500 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_shell_surface.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_shm.py b/src/hhstream/_protocol/wayland/wl_shm.py new file mode 100644 index 0000000..ffca28f --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_shm.py @@ -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 diff --git a/src/hhstream/_protocol/wayland/wl_shm_pool.py b/src/hhstream/_protocol/wayland/wl_shm_pool.py new file mode 100644 index 0000000..a12876c --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_shm_pool.py @@ -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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_subcompositor.py b/src/hhstream/_protocol/wayland/wl_subcompositor.py new file mode 100644 index 0000000..12e337a --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_subcompositor.py @@ -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() + `). 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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_subsurface.py b/src/hhstream/_protocol/wayland/wl_subsurface.py new file mode 100644 index 0000000..e14d441 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_subsurface.py @@ -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() + ` 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() + ` 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() + ` 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() + ` 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() + ` 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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_surface.py b/src/hhstream/_protocol/wayland/wl_surface.py new file mode 100644 index 0000000..6b20dee --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_surface.py @@ -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() + `), a drag icon + (:func:`WlDataDevice.start_drag() + `), a sub-surface + (:func:`WlSubcompositor.get_subsurface() + `), and a window + as defined by a shell protocol (e.g. :func:`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() + `. 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() + ` event. Only after + receiving :func:`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() + ` events becomes + undefined. A well behaved client should not rely on + :func:`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() + ` does not change the + surface contents. Destroying the + :class:`~pywayland.protocol.wayland.WlBuffer` before + :func:`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() + ` 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() + ` and + :func:`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() + `. + + 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() + ` 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() + ` 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 diff --git a/src/hhstream/_protocol/wayland/wl_touch.py b/src/hhstream/_protocol/wayland/wl_touch.py new file mode 100644 index 0000000..c6a87c1 --- /dev/null +++ b/src/hhstream/_protocol/wayland/wl_touch.py @@ -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 diff --git a/src/hhstream/_protocol/wlr_screencopy_unstable_v1/__init__.py b/src/hhstream/_protocol/wlr_screencopy_unstable_v1/__init__.py new file mode 100644 index 0000000..b91f7f4 --- /dev/null +++ b/src/hhstream/_protocol/wlr_screencopy_unstable_v1/__init__.py @@ -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 diff --git a/src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_frame_v1.py b/src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_frame_v1.py new file mode 100644 index 0000000..166cc25 --- /dev/null +++ b/src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_frame_v1.py @@ -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 diff --git a/src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_manager_v1.py b/src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_manager_v1.py new file mode 100644 index 0000000..a8dbc16 --- /dev/null +++ b/src/hhstream/_protocol/wlr_screencopy_unstable_v1/zwlr_screencopy_manager_v1.py @@ -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 diff --git a/src/hhstream/png.py b/src/hhstream/png.py new file mode 100644 index 0000000..c92840e --- /dev/null +++ b/src/hhstream/png.py @@ -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"] \ No newline at end of file diff --git a/src/hhstream/server.py b/src/hhstream/server.py index c354301..0661ba0 100644 --- a/src/hhstream/server.py +++ b/src/hhstream/server.py @@ -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) diff --git a/src/hhstream/wayland_capture.py b/src/hhstream/wayland_capture.py new file mode 100644 index 0000000..98a35ee --- /dev/null +++ b/src/hhstream/wayland_capture.py @@ -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"] \ No newline at end of file diff --git a/tests/unit/test_png.py b/tests/unit/test_png.py new file mode 100644 index 0000000..673c4a7 --- /dev/null +++ b/tests/unit/test_png.py @@ -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) diff --git a/tests/unit/test_wayland_capture.py b/tests/unit/test_wayland_capture.py new file mode 100644 index 0000000..f5c586c --- /dev/null +++ b/tests/unit/test_wayland_capture.py @@ -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