raveos update

15 files changed, 0 insertions, 8160 deletions

diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/AUTHORS b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/AUTHORS
deleted file mode 100644
index 7b24eab..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/AUTHORS
+++ /dev/null
@@ -1,3 +0,0 @@
-// Keep this sorted
-
-rajveermalviya
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/LICENSE b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/LICENSE
deleted file mode 100644
index 4da3300..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-Copyright 2021 go-wayland authors
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/README.md b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/README.md
deleted file mode 100644
index 9e52d99..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Wayland implementation in Go
-
-[![Go Reference](https://pkg.go.dev/badge/github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland.svg)](https://pkg.go.dev/github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland)
-
-This module contains pure Go implementation of the Wayland protocol.
-Currently only wayland-client functionality is supported.
-
-Go code is generated from protocol XML files using
-[`go-wayland-scanner`](cmd/go-wayland-scanner/scanner.go).
-
-To load cursor, minimal port of `wayland-cursor` & `xcursor` in pure Go
-is located at [`wayland/cursor`](wayland/cursor) & [`wayland/cursor/xcursor`](wayland/cursor/xcursor)
-respectively.
-
-To demonstrate the functionality of this module
-[`examples/imageviewer`](examples/imageviewer) contains a simple image
-viewer. It demos displaying a top-level window, resizing of window,
-cursor themes, pointer and keyboard. Because it's in pure Go, it can be
-compiled without CGO. You can try it using the following commands:
-
-```sh
-CGO_ENABLED=0 go install github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/examples/imageviewer@latest
-
-imageviewer file.jpg
-```
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generate b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generate
deleted file mode 100755
index 02ad975..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generate
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-
-cd ./wayland
-go generate -x ./...
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generatep b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generatep
deleted file mode 100755
index bd660d7..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generatep
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/usr/bin/env sh
-
-# Runs go generate for each directory, but in parallel. Any arguments are appended to the
-# go generate command.
-# Usage: $ ./generatep [go generate arguments]
-# Print all generate commands: $ ./generatep -x
-
-cd ./wayland || exit 1
-find . -type f -name '*.go' -exec dirname {} \; | sort -u | parallel -j 0 go generate "$1" {}/.
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/client.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/client.go
deleted file mode 100644
index fd49c20..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/client.go
+++ /dev/null
@@ -1,7542 +0,0 @@
-// Generated by go-wayland-scanner
-// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner
-// XML file : https://gitlab.freedesktop.org/wayland/wayland/-/raw/1.24.0/protocol/wayland.xml?ref_type=tags
-//
-// wayland Protocol Copyright:
-//
-// 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.
-
-package client
-
-import "golang.org/x/sys/unix"
-
-// DisplayInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const DisplayInterfaceName = "wl_display"
-
-// Display : core global object
-//
-// The core global object.  This is a special singleton object.  It
-// is used for internal Wayland protocol features.
-type Display struct {
-	BaseProxy
-	errorHandler    DisplayErrorHandlerFunc
-	deleteIdHandler DisplayDeleteIdHandlerFunc
-}
-
-// NewDisplay : core global object
-//
-// The core global object.  This is a special singleton object.  It
-// is used for internal Wayland protocol features.
-func NewDisplay(ctx *Context) *Display {
-	wlDisplay := &Display{}
-	ctx.Register(wlDisplay)
-	return wlDisplay
-}
-
-// Sync : asynchronous roundtrip
-//
-// The sync request asks the server to emit the 'done' event
-// on the returned wl_callback 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.
-func (i *Display) Sync() (*Callback, error) {
-	callback := NewCallback(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], callback.ID())
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return callback, err
-}
-
-// GetRegistry : 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.
-func (i *Display) GetRegistry() (*Registry, error) {
-	registry := NewRegistry(i.Context())
-	const opcode = 1
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], registry.ID())
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return registry, err
-}
-
-func (i *Display) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-type DisplayError uint32
-
-// DisplayError : global error values
-//
-// These errors are global and can be emitted in response to any
-// server request.
-const (
-	// DisplayErrorInvalidObject : server couldn't find object
-	DisplayErrorInvalidObject DisplayError = 0
-	// DisplayErrorInvalidMethod : method doesn't exist on the specified interface or malformed request
-	DisplayErrorInvalidMethod DisplayError = 1
-	// DisplayErrorNoMemory : server is out of memory
-	DisplayErrorNoMemory DisplayError = 2
-	// DisplayErrorImplementation : implementation error in compositor
-	DisplayErrorImplementation DisplayError = 3
-)
-
-func (e DisplayError) Name() string {
-	switch e {
-	case DisplayErrorInvalidObject:
-		return "invalid_object"
-	case DisplayErrorInvalidMethod:
-		return "invalid_method"
-	case DisplayErrorNoMemory:
-		return "no_memory"
-	case DisplayErrorImplementation:
-		return "implementation"
-	default:
-		return ""
-	}
-}
-
-func (e DisplayError) Value() string {
-	switch e {
-	case DisplayErrorInvalidObject:
-		return "0"
-	case DisplayErrorInvalidMethod:
-		return "1"
-	case DisplayErrorNoMemory:
-		return "2"
-	case DisplayErrorImplementation:
-		return "3"
-	default:
-		return ""
-	}
-}
-
-func (e DisplayError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// DisplayErrorEvent : 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.
-type DisplayErrorEvent struct {
-	ObjectId Proxy
-	Code     uint32
-	Message  string
-}
-type DisplayErrorHandlerFunc func(DisplayErrorEvent)
-
-// SetErrorHandler : sets handler for DisplayErrorEvent
-func (i *Display) SetErrorHandler(f DisplayErrorHandlerFunc) {
-	i.errorHandler = f
-}
-
-// DisplayDeleteIdEvent : acknowledge object ID deletion
-//
-// This event is used internally by the object ID management
-// logic. When a client deletes an object that it had created,
-// the server will send this event to acknowledge that it has
-// seen the delete request. When the client receives this event,
-// it will know that it can safely reuse the object ID.
-type DisplayDeleteIdEvent struct {
-	Id uint32
-}
-type DisplayDeleteIdHandlerFunc func(DisplayDeleteIdEvent)
-
-// SetDeleteIdHandler : sets handler for DisplayDeleteIdEvent
-func (i *Display) SetDeleteIdHandler(f DisplayDeleteIdHandlerFunc) {
-	i.deleteIdHandler = f
-}
-
-func (i *Display) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.errorHandler == nil {
-			return
-		}
-		var e DisplayErrorEvent
-		l := 0
-		e.ObjectId = i.Context().GetProxy(Uint32(data[l : l+4]))
-		l += 4
-		e.Code = Uint32(data[l : l+4])
-		l += 4
-		messageLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Message = String(data[l : l+messageLen])
-
-		i.errorHandler(e)
-	case 1:
-		var e DisplayDeleteIdEvent
-		l := 0
-		e.Id = Uint32(data[l : l+4])
-		l += 4
-
-		i.Context().DeleteID(e.Id)
-
-		if i.deleteIdHandler != nil {
-			i.deleteIdHandler(e)
-		}
-	}
-}
-
-// RegistryInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const RegistryInterfaceName = "wl_registry"
-
-// Registry : 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
-// wl_display.sync request immediately after calling
-// wl_display.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.
-type Registry struct {
-	BaseProxy
-	globalHandler       RegistryGlobalHandlerFunc
-	globalRemoveHandler RegistryGlobalRemoveHandlerFunc
-}
-
-// NewRegistry : 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
-// wl_display.sync request immediately after calling
-// wl_display.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.
-func NewRegistry(ctx *Context) *Registry {
-	wlRegistry := &Registry{}
-	ctx.Register(wlRegistry)
-	return wlRegistry
-}
-
-// Bind : bind an object to the display
-//
-// Binds a new, client-created object to the server using the
-// specified name as the identifier.
-//
-//	name: unique numeric name of the object
-func (i *Registry) Bind(name uint32, iface string, version uint32, id Proxy) error {
-	const opcode = 0
-	ifaceLen := PaddedLen(len(iface) + 1)
-	_reqBufLen := 8 + 4 + (4 + ifaceLen) + 4 + 4
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(name))
-	l += 4
-	PutString(_reqBuf[l:l+(4+ifaceLen)], iface)
-	l += (4 + ifaceLen)
-	PutUint32(_reqBuf[l:l+4], uint32(version))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf, nil)
-	return err
-}
-
-func (i *Registry) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-// RegistryGlobalEvent : 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.
-type RegistryGlobalEvent struct {
-	Name      uint32
-	Interface string
-	Version   uint32
-}
-type RegistryGlobalHandlerFunc func(RegistryGlobalEvent)
-
-// SetGlobalHandler : sets handler for RegistryGlobalEvent
-func (i *Registry) SetGlobalHandler(f RegistryGlobalHandlerFunc) {
-	i.globalHandler = f
-}
-
-// RegistryGlobalRemoveEvent : 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.
-type RegistryGlobalRemoveEvent struct {
-	Name uint32
-}
-type RegistryGlobalRemoveHandlerFunc func(RegistryGlobalRemoveEvent)
-
-// SetGlobalRemoveHandler : sets handler for RegistryGlobalRemoveEvent
-func (i *Registry) SetGlobalRemoveHandler(f RegistryGlobalRemoveHandlerFunc) {
-	i.globalRemoveHandler = f
-}
-
-func (i *Registry) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.globalHandler == nil {
-			return
-		}
-		var e RegistryGlobalEvent
-		l := 0
-		e.Name = Uint32(data[l : l+4])
-		l += 4
-		interfaceLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Interface = String(data[l : l+interfaceLen])
-		l += interfaceLen
-		e.Version = Uint32(data[l : l+4])
-		l += 4
-
-		i.globalHandler(e)
-	case 1:
-		if i.globalRemoveHandler == nil {
-			return
-		}
-		var e RegistryGlobalRemoveEvent
-		l := 0
-		e.Name = Uint32(data[l : l+4])
-		l += 4
-
-		i.globalRemoveHandler(e)
-	}
-}
-
-// CallbackInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const CallbackInterfaceName = "wl_callback"
-
-// Callback : callback object
-//
-// Clients can handle the 'done' event to get notified when
-// the related request is done.
-//
-// Note, because wl_callback objects are created from multiple independent
-// factory interfaces, the wl_callback interface is frozen at version 1.
-type Callback struct {
-	BaseProxy
-	doneHandler CallbackDoneHandlerFunc
-}
-
-// NewCallback : callback object
-//
-// Clients can handle the 'done' event to get notified when
-// the related request is done.
-//
-// Note, because wl_callback objects are created from multiple independent
-// factory interfaces, the wl_callback interface is frozen at version 1.
-func NewCallback(ctx *Context) *Callback {
-	wlCallback := &Callback{}
-	ctx.Register(wlCallback)
-	return wlCallback
-}
-
-func (i *Callback) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-// CallbackDoneEvent : done event
-//
-// Notify the client when the related request is done.
-type CallbackDoneEvent struct {
-	CallbackData uint32
-}
-type CallbackDoneHandlerFunc func(CallbackDoneEvent)
-
-// SetDoneHandler : sets handler for CallbackDoneEvent
-func (i *Callback) SetDoneHandler(f CallbackDoneHandlerFunc) {
-	i.doneHandler = f
-}
-
-func (i *Callback) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.doneHandler == nil {
-			return
-		}
-		var e CallbackDoneEvent
-		l := 0
-		e.CallbackData = Uint32(data[l : l+4])
-		l += 4
-
-		i.doneHandler(e)
-	}
-}
-
-// CompositorInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const CompositorInterfaceName = "wl_compositor"
-
-// Compositor : 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.
-type Compositor struct {
-	BaseProxy
-}
-
-// NewCompositor : 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.
-func NewCompositor(ctx *Context) *Compositor {
-	wlCompositor := &Compositor{}
-	ctx.Register(wlCompositor)
-	return wlCompositor
-}
-
-// CreateSurface : create new surface
-//
-// Ask the compositor to create a new surface.
-func (i *Compositor) CreateSurface() (*Surface, error) {
-	id := NewSurface(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// CreateRegion : create new region
-//
-// Ask the compositor to create a new region.
-func (i *Compositor) CreateRegion() (*Region, error) {
-	id := NewRegion(i.Context())
-	const opcode = 1
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-func (i *Compositor) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-// ShmPoolInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const ShmPoolInterfaceName = "wl_shm_pool"
-
-// ShmPool : a shared memory pool
-//
-// The wl_shm_pool object encapsulates a piece of memory shared
-// between the compositor and client.  Through the wl_shm_pool
-// object, the client can allocate shared memory wl_buffer 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.
-type ShmPool struct {
-	BaseProxy
-}
-
-// NewShmPool : a shared memory pool
-//
-// The wl_shm_pool object encapsulates a piece of memory shared
-// between the compositor and client.  Through the wl_shm_pool
-// object, the client can allocate shared memory wl_buffer 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.
-func NewShmPool(ctx *Context) *ShmPool {
-	wlShmPool := &ShmPool{}
-	ctx.Register(wlShmPool)
-	return wlShmPool
-}
-
-// CreateBuffer : create a buffer from the pool
-//
-// Create a wl_buffer 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 wl_shm.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.
-//
-//	offset: buffer byte offset within the pool
-//	width: buffer width, in pixels
-//	height: buffer height, in pixels
-//	stride: number of bytes from the beginning of one row to the beginning of the next row
-//	format: buffer pixel format
-func (i *ShmPool) CreateBuffer(offset, width, height, stride int32, format uint32) (*Buffer, error) {
-	id := NewBuffer(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(offset))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(width))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(height))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(stride))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(format))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// Destroy : 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.
-func (i *ShmPool) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 1
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Resize : 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.
-//
-//	size: new size of the pool, in bytes
-func (i *ShmPool) Resize(size int32) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(size))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// ShmInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const ShmInterfaceName = "wl_shm"
-
-// Shm : shared memory support
-//
-// A singleton global object that provides support for shared
-// memory.
-//
-// Clients can create wl_shm_pool objects using the create_pool
-// request.
-//
-// On binding the wl_shm object one or more format events
-// are emitted to inform clients about the valid pixel formats
-// that can be used for buffers.
-type Shm struct {
-	BaseProxy
-	formatHandler ShmFormatHandlerFunc
-}
-
-// NewShm : shared memory support
-//
-// A singleton global object that provides support for shared
-// memory.
-//
-// Clients can create wl_shm_pool objects using the create_pool
-// request.
-//
-// On binding the wl_shm object one or more format events
-// are emitted to inform clients about the valid pixel formats
-// that can be used for buffers.
-func NewShm(ctx *Context) *Shm {
-	wlShm := &Shm{}
-	ctx.Register(wlShm)
-	return wlShm
-}
-
-// CreatePool : create a shm pool
-//
-// Create a new wl_shm_pool 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.
-//
-//	fd: file descriptor for the pool
-//	size: pool size, in bytes
-func (i *Shm) CreatePool(fd int, size int32) (*ShmPool, error) {
-	id := NewShmPool(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(size))
-	l += 4
-	oob := unix.UnixRights(int(fd))
-	err := i.Context().WriteMsg(_reqBuf[:], oob)
-	return id, err
-}
-
-// Release : 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.
-func (i *Shm) Release() error {
-	defer i.MarkZombie()
-	const opcode = 1
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type ShmError uint32
-
-// ShmError : wl_shm error values
-//
-// These errors can be emitted in response to wl_shm requests.
-const (
-	// ShmErrorInvalidFormat : buffer format is not known
-	ShmErrorInvalidFormat ShmError = 0
-	// ShmErrorInvalidStride : invalid size or stride during pool or buffer creation
-	ShmErrorInvalidStride ShmError = 1
-	// ShmErrorInvalidFd : mmapping the file descriptor failed
-	ShmErrorInvalidFd ShmError = 2
-)
-
-func (e ShmError) Name() string {
-	switch e {
-	case ShmErrorInvalidFormat:
-		return "invalid_format"
-	case ShmErrorInvalidStride:
-		return "invalid_stride"
-	case ShmErrorInvalidFd:
-		return "invalid_fd"
-	default:
-		return ""
-	}
-}
-
-func (e ShmError) Value() string {
-	switch e {
-	case ShmErrorInvalidFormat:
-		return "0"
-	case ShmErrorInvalidStride:
-		return "1"
-	case ShmErrorInvalidFd:
-		return "2"
-	default:
-		return ""
-	}
-}
-
-func (e ShmError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type ShmFormat uint32
-
-// ShmFormat : pixel formats
-//
-// This describes the memory layout of an individual pixel.
-//
-// All renderers should support argb8888 and xrgb8888 but any other
-// formats are optional and may not be supported by the particular
-// renderer in use.
-//
-// The drm format codes match the macros defined in drm_fourcc.h, except
-// argb8888 and xrgb8888. The formats actually supported by the compositor
-// will be reported by the format event.
-//
-// For all wl_shm formats and unless specified in another protocol
-// extension, pre-multiplied alpha is used for pixel values.
-const (
-	// ShmFormatArgb8888 : 32-bit ARGB format, [31:0] A:R:G:B 8:8:8:8 little endian
-	ShmFormatArgb8888 ShmFormat = 0
-	// ShmFormatXrgb8888 : 32-bit RGB format, [31:0] x:R:G:B 8:8:8:8 little endian
-	ShmFormatXrgb8888 ShmFormat = 1
-	// ShmFormatC8 : 8-bit color index format, [7:0] C
-	ShmFormatC8 ShmFormat = 0x20203843
-	// ShmFormatRgb332 : 8-bit RGB format, [7:0] R:G:B 3:3:2
-	ShmFormatRgb332 ShmFormat = 0x38424752
-	// ShmFormatBgr233 : 8-bit BGR format, [7:0] B:G:R 2:3:3
-	ShmFormatBgr233 ShmFormat = 0x38524742
-	// ShmFormatXrgb4444 : 16-bit xRGB format, [15:0] x:R:G:B 4:4:4:4 little endian
-	ShmFormatXrgb4444 ShmFormat = 0x32315258
-	// ShmFormatXbgr4444 : 16-bit xBGR format, [15:0] x:B:G:R 4:4:4:4 little endian
-	ShmFormatXbgr4444 ShmFormat = 0x32314258
-	// ShmFormatRgbx4444 : 16-bit RGBx format, [15:0] R:G:B:x 4:4:4:4 little endian
-	ShmFormatRgbx4444 ShmFormat = 0x32315852
-	// ShmFormatBgrx4444 : 16-bit BGRx format, [15:0] B:G:R:x 4:4:4:4 little endian
-	ShmFormatBgrx4444 ShmFormat = 0x32315842
-	// ShmFormatArgb4444 : 16-bit ARGB format, [15:0] A:R:G:B 4:4:4:4 little endian
-	ShmFormatArgb4444 ShmFormat = 0x32315241
-	// ShmFormatAbgr4444 : 16-bit ABGR format, [15:0] A:B:G:R 4:4:4:4 little endian
-	ShmFormatAbgr4444 ShmFormat = 0x32314241
-	// ShmFormatRgba4444 : 16-bit RBGA format, [15:0] R:G:B:A 4:4:4:4 little endian
-	ShmFormatRgba4444 ShmFormat = 0x32314152
-	// ShmFormatBgra4444 : 16-bit BGRA format, [15:0] B:G:R:A 4:4:4:4 little endian
-	ShmFormatBgra4444 ShmFormat = 0x32314142
-	// ShmFormatXrgb1555 : 16-bit xRGB format, [15:0] x:R:G:B 1:5:5:5 little endian
-	ShmFormatXrgb1555 ShmFormat = 0x35315258
-	// ShmFormatXbgr1555 : 16-bit xBGR 1555 format, [15:0] x:B:G:R 1:5:5:5 little endian
-	ShmFormatXbgr1555 ShmFormat = 0x35314258
-	// ShmFormatRgbx5551 : 16-bit RGBx 5551 format, [15:0] R:G:B:x 5:5:5:1 little endian
-	ShmFormatRgbx5551 ShmFormat = 0x35315852
-	// ShmFormatBgrx5551 : 16-bit BGRx 5551 format, [15:0] B:G:R:x 5:5:5:1 little endian
-	ShmFormatBgrx5551 ShmFormat = 0x35315842
-	// ShmFormatArgb1555 : 16-bit ARGB 1555 format, [15:0] A:R:G:B 1:5:5:5 little endian
-	ShmFormatArgb1555 ShmFormat = 0x35315241
-	// ShmFormatAbgr1555 : 16-bit ABGR 1555 format, [15:0] A:B:G:R 1:5:5:5 little endian
-	ShmFormatAbgr1555 ShmFormat = 0x35314241
-	// ShmFormatRgba5551 : 16-bit RGBA 5551 format, [15:0] R:G:B:A 5:5:5:1 little endian
-	ShmFormatRgba5551 ShmFormat = 0x35314152
-	// ShmFormatBgra5551 : 16-bit BGRA 5551 format, [15:0] B:G:R:A 5:5:5:1 little endian
-	ShmFormatBgra5551 ShmFormat = 0x35314142
-	// ShmFormatRgb565 : 16-bit RGB 565 format, [15:0] R:G:B 5:6:5 little endian
-	ShmFormatRgb565 ShmFormat = 0x36314752
-	// ShmFormatBgr565 : 16-bit BGR 565 format, [15:0] B:G:R 5:6:5 little endian
-	ShmFormatBgr565 ShmFormat = 0x36314742
-	// ShmFormatRgb888 : 24-bit RGB format, [23:0] R:G:B little endian
-	ShmFormatRgb888 ShmFormat = 0x34324752
-	// ShmFormatBgr888 : 24-bit BGR format, [23:0] B:G:R little endian
-	ShmFormatBgr888 ShmFormat = 0x34324742
-	// ShmFormatXbgr8888 : 32-bit xBGR format, [31:0] x:B:G:R 8:8:8:8 little endian
-	ShmFormatXbgr8888 ShmFormat = 0x34324258
-	// ShmFormatRgbx8888 : 32-bit RGBx format, [31:0] R:G:B:x 8:8:8:8 little endian
-	ShmFormatRgbx8888 ShmFormat = 0x34325852
-	// ShmFormatBgrx8888 : 32-bit BGRx format, [31:0] B:G:R:x 8:8:8:8 little endian
-	ShmFormatBgrx8888 ShmFormat = 0x34325842
-	// ShmFormatAbgr8888 : 32-bit ABGR format, [31:0] A:B:G:R 8:8:8:8 little endian
-	ShmFormatAbgr8888 ShmFormat = 0x34324241
-	// ShmFormatRgba8888 : 32-bit RGBA format, [31:0] R:G:B:A 8:8:8:8 little endian
-	ShmFormatRgba8888 ShmFormat = 0x34324152
-	// ShmFormatBgra8888 : 32-bit BGRA format, [31:0] B:G:R:A 8:8:8:8 little endian
-	ShmFormatBgra8888 ShmFormat = 0x34324142
-	// ShmFormatXrgb2101010 : 32-bit xRGB format, [31:0] x:R:G:B 2:10:10:10 little endian
-	ShmFormatXrgb2101010 ShmFormat = 0x30335258
-	// ShmFormatXbgr2101010 : 32-bit xBGR format, [31:0] x:B:G:R 2:10:10:10 little endian
-	ShmFormatXbgr2101010 ShmFormat = 0x30334258
-	// ShmFormatRgbx1010102 : 32-bit RGBx format, [31:0] R:G:B:x 10:10:10:2 little endian
-	ShmFormatRgbx1010102 ShmFormat = 0x30335852
-	// ShmFormatBgrx1010102 : 32-bit BGRx format, [31:0] B:G:R:x 10:10:10:2 little endian
-	ShmFormatBgrx1010102 ShmFormat = 0x30335842
-	// ShmFormatArgb2101010 : 32-bit ARGB format, [31:0] A:R:G:B 2:10:10:10 little endian
-	ShmFormatArgb2101010 ShmFormat = 0x30335241
-	// ShmFormatAbgr2101010 : 32-bit ABGR format, [31:0] A:B:G:R 2:10:10:10 little endian
-	ShmFormatAbgr2101010 ShmFormat = 0x30334241
-	// ShmFormatRgba1010102 : 32-bit RGBA format, [31:0] R:G:B:A 10:10:10:2 little endian
-	ShmFormatRgba1010102 ShmFormat = 0x30334152
-	// ShmFormatBgra1010102 : 32-bit BGRA format, [31:0] B:G:R:A 10:10:10:2 little endian
-	ShmFormatBgra1010102 ShmFormat = 0x30334142
-	// ShmFormatYuyv : packed YCbCr format, [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian
-	ShmFormatYuyv ShmFormat = 0x56595559
-	// ShmFormatYvyu : packed YCbCr format, [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian
-	ShmFormatYvyu ShmFormat = 0x55595659
-	// ShmFormatUyvy : packed YCbCr format, [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian
-	ShmFormatUyvy ShmFormat = 0x59565955
-	// ShmFormatVyuy : packed YCbCr format, [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian
-	ShmFormatVyuy ShmFormat = 0x59555956
-	// ShmFormatAyuv : packed AYCbCr format, [31:0] A:Y:Cb:Cr 8:8:8:8 little endian
-	ShmFormatAyuv ShmFormat = 0x56555941
-	// ShmFormatNv12 : 2 plane YCbCr Cr:Cb format, 2x2 subsampled Cr:Cb plane
-	ShmFormatNv12 ShmFormat = 0x3231564e
-	// ShmFormatNv21 : 2 plane YCbCr Cb:Cr format, 2x2 subsampled Cb:Cr plane
-	ShmFormatNv21 ShmFormat = 0x3132564e
-	// ShmFormatNv16 : 2 plane YCbCr Cr:Cb format, 2x1 subsampled Cr:Cb plane
-	ShmFormatNv16 ShmFormat = 0x3631564e
-	// ShmFormatNv61 : 2 plane YCbCr Cb:Cr format, 2x1 subsampled Cb:Cr plane
-	ShmFormatNv61 ShmFormat = 0x3136564e
-	// ShmFormatYuv410 : 3 plane YCbCr format, 4x4 subsampled Cb (1) and Cr (2) planes
-	ShmFormatYuv410 ShmFormat = 0x39565559
-	// ShmFormatYvu410 : 3 plane YCbCr format, 4x4 subsampled Cr (1) and Cb (2) planes
-	ShmFormatYvu410 ShmFormat = 0x39555659
-	// ShmFormatYuv411 : 3 plane YCbCr format, 4x1 subsampled Cb (1) and Cr (2) planes
-	ShmFormatYuv411 ShmFormat = 0x31315559
-	// ShmFormatYvu411 : 3 plane YCbCr format, 4x1 subsampled Cr (1) and Cb (2) planes
-	ShmFormatYvu411 ShmFormat = 0x31315659
-	// ShmFormatYuv420 : 3 plane YCbCr format, 2x2 subsampled Cb (1) and Cr (2) planes
-	ShmFormatYuv420 ShmFormat = 0x32315559
-	// ShmFormatYvu420 : 3 plane YCbCr format, 2x2 subsampled Cr (1) and Cb (2) planes
-	ShmFormatYvu420 ShmFormat = 0x32315659
-	// ShmFormatYuv422 : 3 plane YCbCr format, 2x1 subsampled Cb (1) and Cr (2) planes
-	ShmFormatYuv422 ShmFormat = 0x36315559
-	// ShmFormatYvu422 : 3 plane YCbCr format, 2x1 subsampled Cr (1) and Cb (2) planes
-	ShmFormatYvu422 ShmFormat = 0x36315659
-	// ShmFormatYuv444 : 3 plane YCbCr format, non-subsampled Cb (1) and Cr (2) planes
-	ShmFormatYuv444 ShmFormat = 0x34325559
-	// ShmFormatYvu444 : 3 plane YCbCr format, non-subsampled Cr (1) and Cb (2) planes
-	ShmFormatYvu444 ShmFormat = 0x34325659
-	// ShmFormatR8 : [7:0] R
-	ShmFormatR8 ShmFormat = 0x20203852
-	// ShmFormatR16 : [15:0] R little endian
-	ShmFormatR16 ShmFormat = 0x20363152
-	// ShmFormatRg88 : [15:0] R:G 8:8 little endian
-	ShmFormatRg88 ShmFormat = 0x38384752
-	// ShmFormatGr88 : [15:0] G:R 8:8 little endian
-	ShmFormatGr88 ShmFormat = 0x38385247
-	// ShmFormatRg1616 : [31:0] R:G 16:16 little endian
-	ShmFormatRg1616 ShmFormat = 0x32334752
-	// ShmFormatGr1616 : [31:0] G:R 16:16 little endian
-	ShmFormatGr1616 ShmFormat = 0x32335247
-	// ShmFormatXrgb16161616F : [63:0] x:R:G:B 16:16:16:16 little endian
-	ShmFormatXrgb16161616F ShmFormat = 0x48345258
-	// ShmFormatXbgr16161616F : [63:0] x:B:G:R 16:16:16:16 little endian
-	ShmFormatXbgr16161616F ShmFormat = 0x48344258
-	// ShmFormatArgb16161616F : [63:0] A:R:G:B 16:16:16:16 little endian
-	ShmFormatArgb16161616F ShmFormat = 0x48345241
-	// ShmFormatAbgr16161616F : [63:0] A:B:G:R 16:16:16:16 little endian
-	ShmFormatAbgr16161616F ShmFormat = 0x48344241
-	// ShmFormatXyuv8888 : [31:0] X:Y:Cb:Cr 8:8:8:8 little endian
-	ShmFormatXyuv8888 ShmFormat = 0x56555958
-	// ShmFormatVuy888 : [23:0] Cr:Cb:Y 8:8:8 little endian
-	ShmFormatVuy888 ShmFormat = 0x34325556
-	// ShmFormatVuy101010 : Y followed by U then V, 10:10:10.
-	ShmFormatVuy101010 ShmFormat = 0x30335556
-	// ShmFormatY210 : [63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 10:6:10:6:10:6:10:6 little endian per 2 Y pixels
-	ShmFormatY210 ShmFormat = 0x30313259
-	// ShmFormatY212 : [63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 12:4:12:4:12:4:12:4 little endian per 2 Y pixels
-	ShmFormatY212 ShmFormat = 0x32313259
-	// ShmFormatY216 : [63:0] Cr0:Y1:Cb0:Y0 16:16:16:16 little endian per 2 Y pixels
-	ShmFormatY216 ShmFormat = 0x36313259
-	// ShmFormatY410 : [31:0] A:Cr:Y:Cb 2:10:10:10 little endian
-	ShmFormatY410 ShmFormat = 0x30313459
-	// ShmFormatY412 : [63:0] A:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian
-	ShmFormatY412 ShmFormat = 0x32313459
-	// ShmFormatY416 : [63:0] A:Cr:Y:Cb 16:16:16:16 little endian
-	ShmFormatY416 ShmFormat = 0x36313459
-	// ShmFormatXvyu2101010 : [31:0] X:Cr:Y:Cb 2:10:10:10 little endian
-	ShmFormatXvyu2101010 ShmFormat = 0x30335658
-	// ShmFormatXvyu1216161616 : [63:0] X:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian
-	ShmFormatXvyu1216161616 ShmFormat = 0x36335658
-	// ShmFormatXvyu16161616 : [63:0] X:Cr:Y:Cb 16:16:16:16 little endian
-	ShmFormatXvyu16161616 ShmFormat = 0x38345658
-	// ShmFormatY0L0 : [63:0] A3:A2:Y3:0:Cr0:0:Y2:0:A1:A0:Y1:0:Cb0:0:Y0:0 1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian
-	ShmFormatY0L0 ShmFormat = 0x304c3059
-	// ShmFormatX0L0 : [63:0] X3:X2:Y3:0:Cr0:0:Y2:0:X1:X0:Y1:0:Cb0:0:Y0:0 1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian
-	ShmFormatX0L0 ShmFormat = 0x304c3058
-	// ShmFormatY0L2 : [63:0] A3:A2:Y3:Cr0:Y2:A1:A0:Y1:Cb0:Y0 1:1:10:10:10:1:1:10:10:10 little endian
-	ShmFormatY0L2 ShmFormat = 0x324c3059
-	// ShmFormatX0L2 : [63:0] X3:X2:Y3:Cr0:Y2:X1:X0:Y1:Cb0:Y0 1:1:10:10:10:1:1:10:10:10 little endian
-	ShmFormatX0L2        ShmFormat = 0x324c3058
-	ShmFormatYuv4208Bit  ShmFormat = 0x38305559
-	ShmFormatYuv42010Bit ShmFormat = 0x30315559
-	ShmFormatXrgb8888A8  ShmFormat = 0x38415258
-	ShmFormatXbgr8888A8  ShmFormat = 0x38414258
-	ShmFormatRgbx8888A8  ShmFormat = 0x38415852
-	ShmFormatBgrx8888A8  ShmFormat = 0x38415842
-	ShmFormatRgb888A8    ShmFormat = 0x38413852
-	ShmFormatBgr888A8    ShmFormat = 0x38413842
-	ShmFormatRgb565A8    ShmFormat = 0x38413552
-	ShmFormatBgr565A8    ShmFormat = 0x38413542
-	// ShmFormatNv24 : non-subsampled Cr:Cb plane
-	ShmFormatNv24 ShmFormat = 0x3432564e
-	// ShmFormatNv42 : non-subsampled Cb:Cr plane
-	ShmFormatNv42 ShmFormat = 0x3234564e
-	// ShmFormatP210 : 2x1 subsampled Cr:Cb plane, 10 bit per channel
-	ShmFormatP210 ShmFormat = 0x30313250
-	// ShmFormatP010 : 2x2 subsampled Cr:Cb plane 10 bits per channel
-	ShmFormatP010 ShmFormat = 0x30313050
-	// ShmFormatP012 : 2x2 subsampled Cr:Cb plane 12 bits per channel
-	ShmFormatP012 ShmFormat = 0x32313050
-	// ShmFormatP016 : 2x2 subsampled Cr:Cb plane 16 bits per channel
-	ShmFormatP016 ShmFormat = 0x36313050
-	// ShmFormatAxbxgxrx106106106106 : [63:0] A:x:B:x:G:x:R:x 10:6:10:6:10:6:10:6 little endian
-	ShmFormatAxbxgxrx106106106106 ShmFormat = 0x30314241
-	// ShmFormatNv15 : 2x2 subsampled Cr:Cb plane
-	ShmFormatNv15 ShmFormat = 0x3531564e
-	ShmFormatQ410 ShmFormat = 0x30313451
-	ShmFormatQ401 ShmFormat = 0x31303451
-	// ShmFormatXrgb16161616 : [63:0] x:R:G:B 16:16:16:16 little endian
-	ShmFormatXrgb16161616 ShmFormat = 0x38345258
-	// ShmFormatXbgr16161616 : [63:0] x:B:G:R 16:16:16:16 little endian
-	ShmFormatXbgr16161616 ShmFormat = 0x38344258
-	// ShmFormatArgb16161616 : [63:0] A:R:G:B 16:16:16:16 little endian
-	ShmFormatArgb16161616 ShmFormat = 0x38345241
-	// ShmFormatAbgr16161616 : [63:0] A:B:G:R 16:16:16:16 little endian
-	ShmFormatAbgr16161616 ShmFormat = 0x38344241
-	// ShmFormatC1 : [7:0] C0:C1:C2:C3:C4:C5:C6:C7 1:1:1:1:1:1:1:1 eight pixels/byte
-	ShmFormatC1 ShmFormat = 0x20203143
-	// ShmFormatC2 : [7:0] C0:C1:C2:C3 2:2:2:2 four pixels/byte
-	ShmFormatC2 ShmFormat = 0x20203243
-	// ShmFormatC4 : [7:0] C0:C1 4:4 two pixels/byte
-	ShmFormatC4 ShmFormat = 0x20203443
-	// ShmFormatD1 : [7:0] D0:D1:D2:D3:D4:D5:D6:D7 1:1:1:1:1:1:1:1 eight pixels/byte
-	ShmFormatD1 ShmFormat = 0x20203144
-	// ShmFormatD2 : [7:0] D0:D1:D2:D3 2:2:2:2 four pixels/byte
-	ShmFormatD2 ShmFormat = 0x20203244
-	// ShmFormatD4 : [7:0] D0:D1 4:4 two pixels/byte
-	ShmFormatD4 ShmFormat = 0x20203444
-	// ShmFormatD8 : [7:0] D
-	ShmFormatD8 ShmFormat = 0x20203844
-	// ShmFormatR1 : [7:0] R0:R1:R2:R3:R4:R5:R6:R7 1:1:1:1:1:1:1:1 eight pixels/byte
-	ShmFormatR1 ShmFormat = 0x20203152
-	// ShmFormatR2 : [7:0] R0:R1:R2:R3 2:2:2:2 four pixels/byte
-	ShmFormatR2 ShmFormat = 0x20203252
-	// ShmFormatR4 : [7:0] R0:R1 4:4 two pixels/byte
-	ShmFormatR4 ShmFormat = 0x20203452
-	// ShmFormatR10 : [15:0] x:R 6:10 little endian
-	ShmFormatR10 ShmFormat = 0x20303152
-	// ShmFormatR12 : [15:0] x:R 4:12 little endian
-	ShmFormatR12 ShmFormat = 0x20323152
-	// ShmFormatAvuy8888 : [31:0] A:Cr:Cb:Y 8:8:8:8 little endian
-	ShmFormatAvuy8888 ShmFormat = 0x59555641
-	// ShmFormatXvuy8888 : [31:0] X:Cr:Cb:Y 8:8:8:8 little endian
-	ShmFormatXvuy8888 ShmFormat = 0x59555658
-	// ShmFormatP030 : 2x2 subsampled Cr:Cb plane 10 bits per channel packed
-	ShmFormatP030 ShmFormat = 0x30333050
-)
-
-func (e ShmFormat) Name() string {
-	switch e {
-	case ShmFormatArgb8888:
-		return "argb8888"
-	case ShmFormatXrgb8888:
-		return "xrgb8888"
-	case ShmFormatC8:
-		return "c8"
-	case ShmFormatRgb332:
-		return "rgb332"
-	case ShmFormatBgr233:
-		return "bgr233"
-	case ShmFormatXrgb4444:
-		return "xrgb4444"
-	case ShmFormatXbgr4444:
-		return "xbgr4444"
-	case ShmFormatRgbx4444:
-		return "rgbx4444"
-	case ShmFormatBgrx4444:
-		return "bgrx4444"
-	case ShmFormatArgb4444:
-		return "argb4444"
-	case ShmFormatAbgr4444:
-		return "abgr4444"
-	case ShmFormatRgba4444:
-		return "rgba4444"
-	case ShmFormatBgra4444:
-		return "bgra4444"
-	case ShmFormatXrgb1555:
-		return "xrgb1555"
-	case ShmFormatXbgr1555:
-		return "xbgr1555"
-	case ShmFormatRgbx5551:
-		return "rgbx5551"
-	case ShmFormatBgrx5551:
-		return "bgrx5551"
-	case ShmFormatArgb1555:
-		return "argb1555"
-	case ShmFormatAbgr1555:
-		return "abgr1555"
-	case ShmFormatRgba5551:
-		return "rgba5551"
-	case ShmFormatBgra5551:
-		return "bgra5551"
-	case ShmFormatRgb565:
-		return "rgb565"
-	case ShmFormatBgr565:
-		return "bgr565"
-	case ShmFormatRgb888:
-		return "rgb888"
-	case ShmFormatBgr888:
-		return "bgr888"
-	case ShmFormatXbgr8888:
-		return "xbgr8888"
-	case ShmFormatRgbx8888:
-		return "rgbx8888"
-	case ShmFormatBgrx8888:
-		return "bgrx8888"
-	case ShmFormatAbgr8888:
-		return "abgr8888"
-	case ShmFormatRgba8888:
-		return "rgba8888"
-	case ShmFormatBgra8888:
-		return "bgra8888"
-	case ShmFormatXrgb2101010:
-		return "xrgb2101010"
-	case ShmFormatXbgr2101010:
-		return "xbgr2101010"
-	case ShmFormatRgbx1010102:
-		return "rgbx1010102"
-	case ShmFormatBgrx1010102:
-		return "bgrx1010102"
-	case ShmFormatArgb2101010:
-		return "argb2101010"
-	case ShmFormatAbgr2101010:
-		return "abgr2101010"
-	case ShmFormatRgba1010102:
-		return "rgba1010102"
-	case ShmFormatBgra1010102:
-		return "bgra1010102"
-	case ShmFormatYuyv:
-		return "yuyv"
-	case ShmFormatYvyu:
-		return "yvyu"
-	case ShmFormatUyvy:
-		return "uyvy"
-	case ShmFormatVyuy:
-		return "vyuy"
-	case ShmFormatAyuv:
-		return "ayuv"
-	case ShmFormatNv12:
-		return "nv12"
-	case ShmFormatNv21:
-		return "nv21"
-	case ShmFormatNv16:
-		return "nv16"
-	case ShmFormatNv61:
-		return "nv61"
-	case ShmFormatYuv410:
-		return "yuv410"
-	case ShmFormatYvu410:
-		return "yvu410"
-	case ShmFormatYuv411:
-		return "yuv411"
-	case ShmFormatYvu411:
-		return "yvu411"
-	case ShmFormatYuv420:
-		return "yuv420"
-	case ShmFormatYvu420:
-		return "yvu420"
-	case ShmFormatYuv422:
-		return "yuv422"
-	case ShmFormatYvu422:
-		return "yvu422"
-	case ShmFormatYuv444:
-		return "yuv444"
-	case ShmFormatYvu444:
-		return "yvu444"
-	case ShmFormatR8:
-		return "r8"
-	case ShmFormatR16:
-		return "r16"
-	case ShmFormatRg88:
-		return "rg88"
-	case ShmFormatGr88:
-		return "gr88"
-	case ShmFormatRg1616:
-		return "rg1616"
-	case ShmFormatGr1616:
-		return "gr1616"
-	case ShmFormatXrgb16161616F:
-		return "xrgb16161616f"
-	case ShmFormatXbgr16161616F:
-		return "xbgr16161616f"
-	case ShmFormatArgb16161616F:
-		return "argb16161616f"
-	case ShmFormatAbgr16161616F:
-		return "abgr16161616f"
-	case ShmFormatXyuv8888:
-		return "xyuv8888"
-	case ShmFormatVuy888:
-		return "vuy888"
-	case ShmFormatVuy101010:
-		return "vuy101010"
-	case ShmFormatY210:
-		return "y210"
-	case ShmFormatY212:
-		return "y212"
-	case ShmFormatY216:
-		return "y216"
-	case ShmFormatY410:
-		return "y410"
-	case ShmFormatY412:
-		return "y412"
-	case ShmFormatY416:
-		return "y416"
-	case ShmFormatXvyu2101010:
-		return "xvyu2101010"
-	case ShmFormatXvyu1216161616:
-		return "xvyu12_16161616"
-	case ShmFormatXvyu16161616:
-		return "xvyu16161616"
-	case ShmFormatY0L0:
-		return "y0l0"
-	case ShmFormatX0L0:
-		return "x0l0"
-	case ShmFormatY0L2:
-		return "y0l2"
-	case ShmFormatX0L2:
-		return "x0l2"
-	case ShmFormatYuv4208Bit:
-		return "yuv420_8bit"
-	case ShmFormatYuv42010Bit:
-		return "yuv420_10bit"
-	case ShmFormatXrgb8888A8:
-		return "xrgb8888_a8"
-	case ShmFormatXbgr8888A8:
-		return "xbgr8888_a8"
-	case ShmFormatRgbx8888A8:
-		return "rgbx8888_a8"
-	case ShmFormatBgrx8888A8:
-		return "bgrx8888_a8"
-	case ShmFormatRgb888A8:
-		return "rgb888_a8"
-	case ShmFormatBgr888A8:
-		return "bgr888_a8"
-	case ShmFormatRgb565A8:
-		return "rgb565_a8"
-	case ShmFormatBgr565A8:
-		return "bgr565_a8"
-	case ShmFormatNv24:
-		return "nv24"
-	case ShmFormatNv42:
-		return "nv42"
-	case ShmFormatP210:
-		return "p210"
-	case ShmFormatP010:
-		return "p010"
-	case ShmFormatP012:
-		return "p012"
-	case ShmFormatP016:
-		return "p016"
-	case ShmFormatAxbxgxrx106106106106:
-		return "axbxgxrx106106106106"
-	case ShmFormatNv15:
-		return "nv15"
-	case ShmFormatQ410:
-		return "q410"
-	case ShmFormatQ401:
-		return "q401"
-	case ShmFormatXrgb16161616:
-		return "xrgb16161616"
-	case ShmFormatXbgr16161616:
-		return "xbgr16161616"
-	case ShmFormatArgb16161616:
-		return "argb16161616"
-	case ShmFormatAbgr16161616:
-		return "abgr16161616"
-	case ShmFormatC1:
-		return "c1"
-	case ShmFormatC2:
-		return "c2"
-	case ShmFormatC4:
-		return "c4"
-	case ShmFormatD1:
-		return "d1"
-	case ShmFormatD2:
-		return "d2"
-	case ShmFormatD4:
-		return "d4"
-	case ShmFormatD8:
-		return "d8"
-	case ShmFormatR1:
-		return "r1"
-	case ShmFormatR2:
-		return "r2"
-	case ShmFormatR4:
-		return "r4"
-	case ShmFormatR10:
-		return "r10"
-	case ShmFormatR12:
-		return "r12"
-	case ShmFormatAvuy8888:
-		return "avuy8888"
-	case ShmFormatXvuy8888:
-		return "xvuy8888"
-	case ShmFormatP030:
-		return "p030"
-	default:
-		return ""
-	}
-}
-
-func (e ShmFormat) Value() string {
-	switch e {
-	case ShmFormatArgb8888:
-		return "0"
-	case ShmFormatXrgb8888:
-		return "1"
-	case ShmFormatC8:
-		return "0x20203843"
-	case ShmFormatRgb332:
-		return "0x38424752"
-	case ShmFormatBgr233:
-		return "0x38524742"
-	case ShmFormatXrgb4444:
-		return "0x32315258"
-	case ShmFormatXbgr4444:
-		return "0x32314258"
-	case ShmFormatRgbx4444:
-		return "0x32315852"
-	case ShmFormatBgrx4444:
-		return "0x32315842"
-	case ShmFormatArgb4444:
-		return "0x32315241"
-	case ShmFormatAbgr4444:
-		return "0x32314241"
-	case ShmFormatRgba4444:
-		return "0x32314152"
-	case ShmFormatBgra4444:
-		return "0x32314142"
-	case ShmFormatXrgb1555:
-		return "0x35315258"
-	case ShmFormatXbgr1555:
-		return "0x35314258"
-	case ShmFormatRgbx5551:
-		return "0x35315852"
-	case ShmFormatBgrx5551:
-		return "0x35315842"
-	case ShmFormatArgb1555:
-		return "0x35315241"
-	case ShmFormatAbgr1555:
-		return "0x35314241"
-	case ShmFormatRgba5551:
-		return "0x35314152"
-	case ShmFormatBgra5551:
-		return "0x35314142"
-	case ShmFormatRgb565:
-		return "0x36314752"
-	case ShmFormatBgr565:
-		return "0x36314742"
-	case ShmFormatRgb888:
-		return "0x34324752"
-	case ShmFormatBgr888:
-		return "0x34324742"
-	case ShmFormatXbgr8888:
-		return "0x34324258"
-	case ShmFormatRgbx8888:
-		return "0x34325852"
-	case ShmFormatBgrx8888:
-		return "0x34325842"
-	case ShmFormatAbgr8888:
-		return "0x34324241"
-	case ShmFormatRgba8888:
-		return "0x34324152"
-	case ShmFormatBgra8888:
-		return "0x34324142"
-	case ShmFormatXrgb2101010:
-		return "0x30335258"
-	case ShmFormatXbgr2101010:
-		return "0x30334258"
-	case ShmFormatRgbx1010102:
-		return "0x30335852"
-	case ShmFormatBgrx1010102:
-		return "0x30335842"
-	case ShmFormatArgb2101010:
-		return "0x30335241"
-	case ShmFormatAbgr2101010:
-		return "0x30334241"
-	case ShmFormatRgba1010102:
-		return "0x30334152"
-	case ShmFormatBgra1010102:
-		return "0x30334142"
-	case ShmFormatYuyv:
-		return "0x56595559"
-	case ShmFormatYvyu:
-		return "0x55595659"
-	case ShmFormatUyvy:
-		return "0x59565955"
-	case ShmFormatVyuy:
-		return "0x59555956"
-	case ShmFormatAyuv:
-		return "0x56555941"
-	case ShmFormatNv12:
-		return "0x3231564e"
-	case ShmFormatNv21:
-		return "0x3132564e"
-	case ShmFormatNv16:
-		return "0x3631564e"
-	case ShmFormatNv61:
-		return "0x3136564e"
-	case ShmFormatYuv410:
-		return "0x39565559"
-	case ShmFormatYvu410:
-		return "0x39555659"
-	case ShmFormatYuv411:
-		return "0x31315559"
-	case ShmFormatYvu411:
-		return "0x31315659"
-	case ShmFormatYuv420:
-		return "0x32315559"
-	case ShmFormatYvu420:
-		return "0x32315659"
-	case ShmFormatYuv422:
-		return "0x36315559"
-	case ShmFormatYvu422:
-		return "0x36315659"
-	case ShmFormatYuv444:
-		return "0x34325559"
-	case ShmFormatYvu444:
-		return "0x34325659"
-	case ShmFormatR8:
-		return "0x20203852"
-	case ShmFormatR16:
-		return "0x20363152"
-	case ShmFormatRg88:
-		return "0x38384752"
-	case ShmFormatGr88:
-		return "0x38385247"
-	case ShmFormatRg1616:
-		return "0x32334752"
-	case ShmFormatGr1616:
-		return "0x32335247"
-	case ShmFormatXrgb16161616F:
-		return "0x48345258"
-	case ShmFormatXbgr16161616F:
-		return "0x48344258"
-	case ShmFormatArgb16161616F:
-		return "0x48345241"
-	case ShmFormatAbgr16161616F:
-		return "0x48344241"
-	case ShmFormatXyuv8888:
-		return "0x56555958"
-	case ShmFormatVuy888:
-		return "0x34325556"
-	case ShmFormatVuy101010:
-		return "0x30335556"
-	case ShmFormatY210:
-		return "0x30313259"
-	case ShmFormatY212:
-		return "0x32313259"
-	case ShmFormatY216:
-		return "0x36313259"
-	case ShmFormatY410:
-		return "0x30313459"
-	case ShmFormatY412:
-		return "0x32313459"
-	case ShmFormatY416:
-		return "0x36313459"
-	case ShmFormatXvyu2101010:
-		return "0x30335658"
-	case ShmFormatXvyu1216161616:
-		return "0x36335658"
-	case ShmFormatXvyu16161616:
-		return "0x38345658"
-	case ShmFormatY0L0:
-		return "0x304c3059"
-	case ShmFormatX0L0:
-		return "0x304c3058"
-	case ShmFormatY0L2:
-		return "0x324c3059"
-	case ShmFormatX0L2:
-		return "0x324c3058"
-	case ShmFormatYuv4208Bit:
-		return "0x38305559"
-	case ShmFormatYuv42010Bit:
-		return "0x30315559"
-	case ShmFormatXrgb8888A8:
-		return "0x38415258"
-	case ShmFormatXbgr8888A8:
-		return "0x38414258"
-	case ShmFormatRgbx8888A8:
-		return "0x38415852"
-	case ShmFormatBgrx8888A8:
-		return "0x38415842"
-	case ShmFormatRgb888A8:
-		return "0x38413852"
-	case ShmFormatBgr888A8:
-		return "0x38413842"
-	case ShmFormatRgb565A8:
-		return "0x38413552"
-	case ShmFormatBgr565A8:
-		return "0x38413542"
-	case ShmFormatNv24:
-		return "0x3432564e"
-	case ShmFormatNv42:
-		return "0x3234564e"
-	case ShmFormatP210:
-		return "0x30313250"
-	case ShmFormatP010:
-		return "0x30313050"
-	case ShmFormatP012:
-		return "0x32313050"
-	case ShmFormatP016:
-		return "0x36313050"
-	case ShmFormatAxbxgxrx106106106106:
-		return "0x30314241"
-	case ShmFormatNv15:
-		return "0x3531564e"
-	case ShmFormatQ410:
-		return "0x30313451"
-	case ShmFormatQ401:
-		return "0x31303451"
-	case ShmFormatXrgb16161616:
-		return "0x38345258"
-	case ShmFormatXbgr16161616:
-		return "0x38344258"
-	case ShmFormatArgb16161616:
-		return "0x38345241"
-	case ShmFormatAbgr16161616:
-		return "0x38344241"
-	case ShmFormatC1:
-		return "0x20203143"
-	case ShmFormatC2:
-		return "0x20203243"
-	case ShmFormatC4:
-		return "0x20203443"
-	case ShmFormatD1:
-		return "0x20203144"
-	case ShmFormatD2:
-		return "0x20203244"
-	case ShmFormatD4:
-		return "0x20203444"
-	case ShmFormatD8:
-		return "0x20203844"
-	case ShmFormatR1:
-		return "0x20203152"
-	case ShmFormatR2:
-		return "0x20203252"
-	case ShmFormatR4:
-		return "0x20203452"
-	case ShmFormatR10:
-		return "0x20303152"
-	case ShmFormatR12:
-		return "0x20323152"
-	case ShmFormatAvuy8888:
-		return "0x59555641"
-	case ShmFormatXvuy8888:
-		return "0x59555658"
-	case ShmFormatP030:
-		return "0x30333050"
-	default:
-		return ""
-	}
-}
-
-func (e ShmFormat) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// ShmFormatEvent : pixel format description
-//
-// Informs the client about a valid pixel format that
-// can be used for buffers. Known formats include
-// argb8888 and xrgb8888.
-type ShmFormatEvent struct {
-	Format uint32
-}
-type ShmFormatHandlerFunc func(ShmFormatEvent)
-
-// SetFormatHandler : sets handler for ShmFormatEvent
-func (i *Shm) SetFormatHandler(f ShmFormatHandlerFunc) {
-	i.formatHandler = f
-}
-
-func (i *Shm) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.formatHandler == nil {
-			return
-		}
-		var e ShmFormatEvent
-		l := 0
-		e.Format = Uint32(data[l : l+4])
-		l += 4
-
-		i.formatHandler(e)
-	}
-}
-
-// BufferInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const BufferInterfaceName = "wl_buffer"
-
-// Buffer : content for a wl_surface
-//
-// A buffer provides the content for a wl_surface. Buffers are
-// created through factory interfaces such as wl_shm, 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 wl_surface, 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 wl_buffer objects are created from multiple independent
-// factory interfaces, the wl_buffer interface is frozen at version 1.
-type Buffer struct {
-	BaseProxy
-	releaseHandler BufferReleaseHandlerFunc
-}
-
-// NewBuffer : content for a wl_surface
-//
-// A buffer provides the content for a wl_surface. Buffers are
-// created through factory interfaces such as wl_shm, 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 wl_surface, 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 wl_buffer objects are created from multiple independent
-// factory interfaces, the wl_buffer interface is frozen at version 1.
-func NewBuffer(ctx *Context) *Buffer {
-	wlBuffer := &Buffer{}
-	ctx.Register(wlBuffer)
-	return wlBuffer
-}
-
-// Destroy : 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 wl_surface.attach.
-func (i *Buffer) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// BufferReleaseEvent : compositor releases buffer
-//
-// Sent when this wl_buffer 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
-// wl_surface.attach.
-//
-// If a client receives a release event before the frame callback
-// requested in the same wl_surface.commit that attaches this
-// wl_buffer 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
-// wl_surface contents, e.g. as a GL texture. This is an important
-// optimization for GL(ES) compositors with wl_shm clients.
-type BufferReleaseEvent struct{}
-type BufferReleaseHandlerFunc func(BufferReleaseEvent)
-
-// SetReleaseHandler : sets handler for BufferReleaseEvent
-func (i *Buffer) SetReleaseHandler(f BufferReleaseHandlerFunc) {
-	i.releaseHandler = f
-}
-
-func (i *Buffer) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.releaseHandler == nil {
-			return
-		}
-		var e BufferReleaseEvent
-
-		i.releaseHandler(e)
-	}
-}
-
-// DataOfferInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const DataOfferInterfaceName = "wl_data_offer"
-
-// DataOffer : offer to transfer data
-//
-// A wl_data_offer 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.
-type DataOffer struct {
-	BaseProxy
-	offerHandler         DataOfferOfferHandlerFunc
-	sourceActionsHandler DataOfferSourceActionsHandlerFunc
-	actionHandler        DataOfferActionHandlerFunc
-}
-
-// NewDataOffer : offer to transfer data
-//
-// A wl_data_offer 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.
-func NewDataOffer(ctx *Context) *DataOffer {
-	wlDataOffer := &DataOffer{}
-	ctx.Register(wlDataOffer)
-	return wlDataOffer
-}
-
-// Accept : 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
-// wl_data_source.cancelled. Clients may still use this event in
-// conjunction with wl_data_source.action for feedback.
-//
-//	serial: serial number of the accept request
-//	mimeType: mime type accepted by the client
-func (i *DataOffer) Accept(serial uint32, mimeType string) error {
-	const opcode = 0
-	mimeTypeLen := PaddedLen(len(mimeType) + 1)
-	_reqBufLen := 8 + 4 + (4 + mimeTypeLen)
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	PutString(_reqBuf[l:l+(4+mimeTypeLen)], mimeType)
-	l += (4 + mimeTypeLen)
-	err := i.Context().WriteMsg(_reqBuf, nil)
-	return err
-}
-
-// Receive : 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 wl_data_device.drop. Drag-and-drop destination
-// clients may preemptively fetch data or examine it more closely to
-// determine acceptance.
-//
-//	mimeType: mime type desired by receiver
-//	fd: file descriptor for data transfer
-func (i *DataOffer) Receive(mimeType string, fd int) error {
-	const opcode = 1
-	mimeTypeLen := PaddedLen(len(mimeType) + 1)
-	_reqBufLen := 8 + (4 + mimeTypeLen)
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutString(_reqBuf[l:l+(4+mimeTypeLen)], mimeType)
-	l += (4 + mimeTypeLen)
-	oob := unix.UnixRights(int(fd))
-	err := i.Context().WriteMsg(_reqBuf, oob)
-	return err
-}
-
-// Destroy : destroy data offer
-//
-// Destroy the data offer.
-func (i *DataOffer) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 2
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Finish : 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
-// wl_data_source.dnd_finished on the drag source client.
-//
-// It is a client error to perform other requests than
-// wl_data_offer.destroy after this one. It is also an error to perform
-// this request after a NULL mime type has been set in
-// wl_data_offer.accept or no action was received through
-// wl_data_offer.action.
-//
-// If wl_data_offer.finish request is received for a non drag and drop
-// operation, the invalid_finish protocol error is raised.
-func (i *DataOffer) Finish() error {
-	const opcode = 3
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetActions : 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
-// wl_data_source.action and wl_data_offer.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 wl_data_device.enter
-// or wl_data_device.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 wl_data_source.cancelled.
-//
-// The dnd_actions argument must contain only values expressed in the
-// wl_data_device_manager.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 wl_data_offer.receive requests, and is expected
-// to perform one last wl_data_offer.set_actions request with a preferred
-// action other than "ask" (and optionally wl_data_offer.accept) before
-// requesting wl_data_offer.finish, in order to convey the action selected
-// by the user. If the preferred action is not in the
-// wl_data_offer.source_actions mask, an error will be raised.
-//
-// If the "ask" action is dismissed (e.g. user cancellation), the client
-// is expected to perform wl_data_offer.destroy right away.
-//
-// This request can only be made on drag-and-drop offers, a protocol error
-// will be raised otherwise.
-//
-//	dndActions: actions supported by the destination client
-//	preferredAction: action preferred by the destination client
-func (i *DataOffer) SetActions(dndActions, preferredAction uint32) error {
-	const opcode = 4
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(dndActions))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(preferredAction))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type DataOfferError uint32
-
-// DataOfferError :
-const (
-	// DataOfferErrorInvalidFinish : finish request was called untimely
-	DataOfferErrorInvalidFinish DataOfferError = 0
-	// DataOfferErrorInvalidActionMask : action mask contains invalid values
-	DataOfferErrorInvalidActionMask DataOfferError = 1
-	// DataOfferErrorInvalidAction : action argument has an invalid value
-	DataOfferErrorInvalidAction DataOfferError = 2
-	// DataOfferErrorInvalidOffer : offer doesn't accept this request
-	DataOfferErrorInvalidOffer DataOfferError = 3
-)
-
-func (e DataOfferError) Name() string {
-	switch e {
-	case DataOfferErrorInvalidFinish:
-		return "invalid_finish"
-	case DataOfferErrorInvalidActionMask:
-		return "invalid_action_mask"
-	case DataOfferErrorInvalidAction:
-		return "invalid_action"
-	case DataOfferErrorInvalidOffer:
-		return "invalid_offer"
-	default:
-		return ""
-	}
-}
-
-func (e DataOfferError) Value() string {
-	switch e {
-	case DataOfferErrorInvalidFinish:
-		return "0"
-	case DataOfferErrorInvalidActionMask:
-		return "1"
-	case DataOfferErrorInvalidAction:
-		return "2"
-	case DataOfferErrorInvalidOffer:
-		return "3"
-	default:
-		return ""
-	}
-}
-
-func (e DataOfferError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// DataOfferOfferEvent : advertise offered mime type
-//
-// Sent immediately after creating the wl_data_offer object.  One
-// event per offered mime type.
-type DataOfferOfferEvent struct {
-	MimeType string
-}
-type DataOfferOfferHandlerFunc func(DataOfferOfferEvent)
-
-// SetOfferHandler : sets handler for DataOfferOfferEvent
-func (i *DataOffer) SetOfferHandler(f DataOfferOfferHandlerFunc) {
-	i.offerHandler = f
-}
-
-// DataOfferSourceActionsEvent : notify the source-side available actions
-//
-// This event indicates the actions offered by the data source. It
-// will be sent immediately after creating the wl_data_offer object,
-// or anytime the source side changes its offered actions through
-// wl_data_source.set_actions.
-type DataOfferSourceActionsEvent struct {
-	SourceActions uint32
-}
-type DataOfferSourceActionsHandlerFunc func(DataOfferSourceActionsEvent)
-
-// SetSourceActionsHandler : sets handler for DataOfferSourceActionsEvent
-func (i *DataOffer) SetSourceActionsHandler(f DataOfferSourceActionsHandlerFunc) {
-	i.sourceActionsHandler = f
-}
-
-// DataOfferActionEvent : 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
-// wl_data_offer.set_actions.
-//
-// This event will no longer be emitted after wl_data_device.drop
-// happened on the drag-and-drop destination, the client must
-// honor the last action received, or the last preferred one set
-// through wl_data_offer.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 wl_data_device.drop, the chosen action may change (e.g.
-// due to keyboard modifiers being pressed). At the time of receiving
-// wl_data_device.drop the drag-and-drop destination must honor the
-// last action received.
-//
-// Action changes may still happen after wl_data_device.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 wl_data_offer.source_actions and finally chosen by the
-// user (e.g. popping up a menu with the available options). The
-// final wl_data_offer.set_actions and wl_data_offer.accept requests
-// must happen before the call to wl_data_offer.finish.
-type DataOfferActionEvent struct {
-	DndAction uint32
-}
-type DataOfferActionHandlerFunc func(DataOfferActionEvent)
-
-// SetActionHandler : sets handler for DataOfferActionEvent
-func (i *DataOffer) SetActionHandler(f DataOfferActionHandlerFunc) {
-	i.actionHandler = f
-}
-
-func (i *DataOffer) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.offerHandler == nil {
-			return
-		}
-		var e DataOfferOfferEvent
-		l := 0
-		mimeTypeLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.MimeType = String(data[l : l+mimeTypeLen])
-		l += mimeTypeLen
-
-		i.offerHandler(e)
-	case 1:
-		if i.sourceActionsHandler == nil {
-			return
-		}
-		var e DataOfferSourceActionsEvent
-		l := 0
-		e.SourceActions = Uint32(data[l : l+4])
-		l += 4
-
-		i.sourceActionsHandler(e)
-	case 2:
-		if i.actionHandler == nil {
-			return
-		}
-		var e DataOfferActionEvent
-		l := 0
-		e.DndAction = Uint32(data[l : l+4])
-		l += 4
-
-		i.actionHandler(e)
-	}
-}
-
-// DataSourceInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const DataSourceInterfaceName = "wl_data_source"
-
-// DataSource : offer to transfer data
-//
-// The wl_data_source object is the source side of a wl_data_offer.
-// 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.
-type DataSource struct {
-	BaseProxy
-	targetHandler           DataSourceTargetHandlerFunc
-	sendHandler             DataSourceSendHandlerFunc
-	cancelledHandler        DataSourceCancelledHandlerFunc
-	dndDropPerformedHandler DataSourceDndDropPerformedHandlerFunc
-	dndFinishedHandler      DataSourceDndFinishedHandlerFunc
-	actionHandler           DataSourceActionHandlerFunc
-}
-
-// NewDataSource : offer to transfer data
-//
-// The wl_data_source object is the source side of a wl_data_offer.
-// 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.
-func NewDataSource(ctx *Context) *DataSource {
-	wlDataSource := &DataSource{}
-	ctx.Register(wlDataSource)
-	return wlDataSource
-}
-
-// Offer : 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.
-//
-//	mimeType: mime type offered by the data source
-func (i *DataSource) Offer(mimeType string) error {
-	const opcode = 0
-	mimeTypeLen := PaddedLen(len(mimeType) + 1)
-	_reqBufLen := 8 + (4 + mimeTypeLen)
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutString(_reqBuf[l:l+(4+mimeTypeLen)], mimeType)
-	l += (4 + mimeTypeLen)
-	err := i.Context().WriteMsg(_reqBuf, nil)
-	return err
-}
-
-// Destroy : destroy the data source
-//
-// Destroy the data source.
-func (i *DataSource) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 1
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetActions : set the available drag-and-drop actions
-//
-// Sets the actions that the source side client supports for this
-// operation. This request may trigger wl_data_source.action and
-// wl_data_offer.action events if the compositor needs to change the
-// selected action.
-//
-// The dnd_actions argument must contain only values expressed in the
-// wl_data_device_manager.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
-// wl_data_device.start_drag. Attempting to use the source other than
-// for drag-and-drop will raise a protocol error.
-//
-//	dndActions: actions supported by the data source
-func (i *DataSource) SetActions(dndActions uint32) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(dndActions))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type DataSourceError uint32
-
-// DataSourceError :
-const (
-	// DataSourceErrorInvalidActionMask : action mask contains invalid values
-	DataSourceErrorInvalidActionMask DataSourceError = 0
-	// DataSourceErrorInvalidSource : source doesn't accept this request
-	DataSourceErrorInvalidSource DataSourceError = 1
-)
-
-func (e DataSourceError) Name() string {
-	switch e {
-	case DataSourceErrorInvalidActionMask:
-		return "invalid_action_mask"
-	case DataSourceErrorInvalidSource:
-		return "invalid_source"
-	default:
-		return ""
-	}
-}
-
-func (e DataSourceError) Value() string {
-	switch e {
-	case DataSourceErrorInvalidActionMask:
-		return "0"
-	case DataSourceErrorInvalidSource:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e DataSourceError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// DataSourceTargetEvent : 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.
-type DataSourceTargetEvent struct {
-	MimeType string
-}
-type DataSourceTargetHandlerFunc func(DataSourceTargetEvent)
-
-// SetTargetHandler : sets handler for DataSourceTargetEvent
-func (i *DataSource) SetTargetHandler(f DataSourceTargetHandlerFunc) {
-	i.targetHandler = f
-}
-
-// DataSourceSendEvent : 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.
-type DataSourceSendEvent struct {
-	MimeType string
-	Fd       int
-}
-type DataSourceSendHandlerFunc func(DataSourceSendEvent)
-
-// SetSendHandler : sets handler for DataSourceSendEvent
-func (i *DataSource) SetSendHandler(f DataSourceSendHandlerFunc) {
-	i.sendHandler = f
-}
-
-// DataSourceCancelledEvent : 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
-// wl_data_source.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
-// wl_data_source.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, wl_data_source.cancelled will
-// only be emitted if the data source was replaced by another data
-// source.
-type DataSourceCancelledEvent struct{}
-type DataSourceCancelledHandlerFunc func(DataSourceCancelledEvent)
-
-// SetCancelledHandler : sets handler for DataSourceCancelledEvent
-func (i *DataSource) SetCancelledHandler(f DataSourceCancelledHandlerFunc) {
-	i.cancelledHandler = f
-}
-
-// DataSourceDndDropPerformedEvent : the drag-and-drop operation physically finished
-//
-// The user performed the drop action. This event does not indicate
-// acceptance, wl_data_source.cancelled may still be emitted afterwards
-// if the drop destination does not accept any mime type.
-//
-// However, this event might however 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.
-type DataSourceDndDropPerformedEvent struct{}
-type DataSourceDndDropPerformedHandlerFunc func(DataSourceDndDropPerformedEvent)
-
-// SetDndDropPerformedHandler : sets handler for DataSourceDndDropPerformedEvent
-func (i *DataSource) SetDndDropPerformedHandler(f DataSourceDndDropPerformedHandlerFunc) {
-	i.dndDropPerformedHandler = f
-}
-
-// DataSourceDndFinishedEvent : 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.
-type DataSourceDndFinishedEvent struct{}
-type DataSourceDndFinishedHandlerFunc func(DataSourceDndFinishedEvent)
-
-// SetDndFinishedHandler : sets handler for DataSourceDndFinishedEvent
-func (i *DataSource) SetDndFinishedHandler(f DataSourceDndFinishedHandlerFunc) {
-	i.dndFinishedHandler = f
-}
-
-// DataSourceActionEvent : 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
-// wl_data_offer.set_actions, and as the data device enters/leaves
-// surfaces.
-//
-// It is only possible to receive this event after
-// wl_data_source.dnd_drop_performed if the drag-and-drop operation
-// ended in an "ask" action, in which case the final wl_data_source.action
-// event will happen immediately before wl_data_source.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 wl_data_offer.dnd_finished.
-//
-// Clients can trigger cursor surface changes from this point, so
-// they reflect the current action.
-type DataSourceActionEvent struct {
-	DndAction uint32
-}
-type DataSourceActionHandlerFunc func(DataSourceActionEvent)
-
-// SetActionHandler : sets handler for DataSourceActionEvent
-func (i *DataSource) SetActionHandler(f DataSourceActionHandlerFunc) {
-	i.actionHandler = f
-}
-
-func (i *DataSource) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.targetHandler == nil {
-			return
-		}
-		var e DataSourceTargetEvent
-		l := 0
-		mimeTypeLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.MimeType = String(data[l : l+mimeTypeLen])
-		l += mimeTypeLen
-
-		i.targetHandler(e)
-	case 1:
-		if i.sendHandler == nil {
-			if fd != -1 {
-				unix.Close(fd)
-			}
-			return
-		}
-		var e DataSourceSendEvent
-		l := 0
-		mimeTypeLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.MimeType = String(data[l : l+mimeTypeLen])
-		l += mimeTypeLen
-		e.Fd = fd
-
-		i.sendHandler(e)
-	case 2:
-		if i.cancelledHandler == nil {
-			return
-		}
-		var e DataSourceCancelledEvent
-
-		i.cancelledHandler(e)
-	case 3:
-		if i.dndDropPerformedHandler == nil {
-			return
-		}
-		var e DataSourceDndDropPerformedEvent
-
-		i.dndDropPerformedHandler(e)
-	case 4:
-		if i.dndFinishedHandler == nil {
-			return
-		}
-		var e DataSourceDndFinishedEvent
-
-		i.dndFinishedHandler(e)
-	case 5:
-		if i.actionHandler == nil {
-			return
-		}
-		var e DataSourceActionEvent
-		l := 0
-		e.DndAction = Uint32(data[l : l+4])
-		l += 4
-
-		i.actionHandler(e)
-	}
-}
-
-// DataDeviceInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const DataDeviceInterfaceName = "wl_data_device"
-
-// DataDevice : data transfer device
-//
-// There is one wl_data_device per seat which can be obtained
-// from the global wl_data_device_manager singleton.
-//
-// A wl_data_device provides access to inter-client data transfer
-// mechanisms such as copy-and-paste and drag-and-drop.
-type DataDevice struct {
-	BaseProxy
-	dataOfferHandler DataDeviceDataOfferHandlerFunc
-	enterHandler     DataDeviceEnterHandlerFunc
-	leaveHandler     DataDeviceLeaveHandlerFunc
-	motionHandler    DataDeviceMotionHandlerFunc
-	dropHandler      DataDeviceDropHandlerFunc
-	selectionHandler DataDeviceSelectionHandlerFunc
-}
-
-// NewDataDevice : data transfer device
-//
-// There is one wl_data_device per seat which can be obtained
-// from the global wl_data_device_manager singleton.
-//
-// A wl_data_device provides access to inter-client data transfer
-// mechanisms such as copy-and-paste and drag-and-drop.
-func NewDataDevice(ctx *Context) *DataDevice {
-	wlDataDevice := &DataDevice{}
-	ctx.Register(wlDataDevice)
-	return wlDataDevice
-}
-
-// StartDrag : 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 wl_surface.offset requests can move the
-// relative position. Attach requests must be confirmed with
-// wl_surface.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.
-//
-//	source: data source for the eventual transfer
-//	origin: surface where the drag originates
-//	icon: drag-and-drop icon surface
-//	serial: serial number of the implicit grab on the origin
-func (i *DataDevice) StartDrag(source *DataSource, origin, icon *Surface, serial uint32) error {
-	const opcode = 0
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	if source == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], source.ID())
-		l += 4
-	}
-	PutUint32(_reqBuf[l:l+4], origin.ID())
-	l += 4
-	if icon == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], icon.ID())
-		l += 4
-	}
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetSelection : 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.
-//
-//	source: data source for the selection
-//	serial: serial number of the event that triggered this request
-func (i *DataDevice) SetSelection(source *DataSource, serial uint32) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	if source == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], source.ID())
-		l += 4
-	}
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Release : destroy data device
-//
-// This request destroys the data device.
-func (i *DataDevice) Release() error {
-	defer i.MarkZombie()
-	const opcode = 2
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type DataDeviceError uint32
-
-// DataDeviceError :
-const (
-	// DataDeviceErrorRole : given wl_surface has another role
-	DataDeviceErrorRole DataDeviceError = 0
-	// DataDeviceErrorUsedSource : source has already been used
-	DataDeviceErrorUsedSource DataDeviceError = 1
-)
-
-func (e DataDeviceError) Name() string {
-	switch e {
-	case DataDeviceErrorRole:
-		return "role"
-	case DataDeviceErrorUsedSource:
-		return "used_source"
-	default:
-		return ""
-	}
-}
-
-func (e DataDeviceError) Value() string {
-	switch e {
-	case DataDeviceErrorRole:
-		return "0"
-	case DataDeviceErrorUsedSource:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e DataDeviceError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// DataDeviceDataOfferEvent : introduce a new wl_data_offer
-//
-// The data_offer event introduces a new wl_data_offer 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.
-type DataDeviceDataOfferEvent struct {
-	Id *DataOffer
-}
-type DataDeviceDataOfferHandlerFunc func(DataDeviceDataOfferEvent)
-
-// SetDataOfferHandler : sets handler for DataDeviceDataOfferEvent
-func (i *DataDevice) SetDataOfferHandler(f DataDeviceDataOfferHandlerFunc) {
-	i.dataOfferHandler = f
-}
-
-// DataDeviceEnterEvent : 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.
-type DataDeviceEnterEvent struct {
-	Serial  uint32
-	Surface *Surface
-	X       float64
-	Y       float64
-	Id      *DataOffer
-}
-type DataDeviceEnterHandlerFunc func(DataDeviceEnterEvent)
-
-// SetEnterHandler : sets handler for DataDeviceEnterEvent
-func (i *DataDevice) SetEnterHandler(f DataDeviceEnterHandlerFunc) {
-	i.enterHandler = f
-}
-
-// DataDeviceLeaveEvent : 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
-// wl_data_offer introduced at enter time at this point.
-type DataDeviceLeaveEvent struct{}
-type DataDeviceLeaveHandlerFunc func(DataDeviceLeaveEvent)
-
-// SetLeaveHandler : sets handler for DataDeviceLeaveEvent
-func (i *DataDevice) SetLeaveHandler(f DataDeviceLeaveHandlerFunc) {
-	i.leaveHandler = f
-}
-
-// DataDeviceMotionEvent : 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.
-type DataDeviceMotionEvent struct {
-	Time uint32
-	X    float64
-	Y    float64
-}
-type DataDeviceMotionHandlerFunc func(DataDeviceMotionEvent)
-
-// SetMotionHandler : sets handler for DataDeviceMotionEvent
-func (i *DataDevice) SetMotionHandler(f DataDeviceMotionHandlerFunc) {
-	i.motionHandler = f
-}
-
-// DataDeviceDropEvent : 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 wl_data_offer.action, if the resulting action is
-// "copy" or "move", the destination can still perform
-// wl_data_offer.receive requests, and is expected to end all
-// transfers with a wl_data_offer.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
-// wl_data_offer.set_actions request, or wl_data_offer.destroy in order
-// to cancel the operation.
-type DataDeviceDropEvent struct{}
-type DataDeviceDropHandlerFunc func(DataDeviceDropEvent)
-
-// SetDropHandler : sets handler for DataDeviceDropEvent
-func (i *DataDevice) SetDropHandler(f DataDeviceDropHandlerFunc) {
-	i.dropHandler = f
-}
-
-// DataDeviceSelectionEvent : advertise new selection
-//
-// The selection event is sent out to notify the client of a new
-// wl_data_offer 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.
-type DataDeviceSelectionEvent struct {
-	Id *DataOffer
-}
-type DataDeviceSelectionHandlerFunc func(DataDeviceSelectionEvent)
-
-// SetSelectionHandler : sets handler for DataDeviceSelectionEvent
-func (i *DataDevice) SetSelectionHandler(f DataDeviceSelectionHandlerFunc) {
-	i.selectionHandler = f
-}
-
-func (i *DataDevice) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.dataOfferHandler == nil {
-			return
-		}
-		var e DataDeviceDataOfferEvent
-		l := 0
-		e.Id = i.Context().GetProxy(Uint32(data[l : l+4])).(*DataOffer)
-		l += 4
-
-		i.dataOfferHandler(e)
-	case 1:
-		if i.enterHandler == nil {
-			return
-		}
-		var e DataDeviceEnterEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Surface = i.Context().GetProxy(Uint32(data[l : l+4])).(*Surface)
-		l += 4
-		e.X = Fixed(data[l : l+4])
-		l += 4
-		e.Y = Fixed(data[l : l+4])
-		l += 4
-		e.Id = i.Context().GetProxy(Uint32(data[l : l+4])).(*DataOffer)
-		l += 4
-
-		i.enterHandler(e)
-	case 2:
-		if i.leaveHandler == nil {
-			return
-		}
-		var e DataDeviceLeaveEvent
-
-		i.leaveHandler(e)
-	case 3:
-		if i.motionHandler == nil {
-			return
-		}
-		var e DataDeviceMotionEvent
-		l := 0
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.X = Fixed(data[l : l+4])
-		l += 4
-		e.Y = Fixed(data[l : l+4])
-		l += 4
-
-		i.motionHandler(e)
-	case 4:
-		if i.dropHandler == nil {
-			return
-		}
-		var e DataDeviceDropEvent
-
-		i.dropHandler(e)
-	case 5:
-		if i.selectionHandler == nil {
-			return
-		}
-		var e DataDeviceSelectionEvent
-		l := 0
-		e.Id = i.Context().GetProxy(Uint32(data[l : l+4])).(*DataOffer)
-		l += 4
-
-		i.selectionHandler(e)
-	}
-}
-
-// DataDeviceManagerInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const DataDeviceManagerInterfaceName = "wl_data_device_manager"
-
-// DataDeviceManager : data transfer interface
-//
-// The wl_data_device_manager 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 wl_seat and this interface lets a client get a wl_data_device
-// corresponding to a wl_seat.
-//
-// Depending on the version bound, the objects created from the bound
-// wl_data_device_manager object will have different requirements for
-// functioning properly. See wl_data_source.set_actions,
-// wl_data_offer.accept and wl_data_offer.finish for details.
-type DataDeviceManager struct {
-	BaseProxy
-}
-
-// NewDataDeviceManager : data transfer interface
-//
-// The wl_data_device_manager 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 wl_seat and this interface lets a client get a wl_data_device
-// corresponding to a wl_seat.
-//
-// Depending on the version bound, the objects created from the bound
-// wl_data_device_manager object will have different requirements for
-// functioning properly. See wl_data_source.set_actions,
-// wl_data_offer.accept and wl_data_offer.finish for details.
-func NewDataDeviceManager(ctx *Context) *DataDeviceManager {
-	wlDataDeviceManager := &DataDeviceManager{}
-	ctx.Register(wlDataDeviceManager)
-	return wlDataDeviceManager
-}
-
-// CreateDataSource : create a new data source
-//
-// Create a new data source.
-func (i *DataDeviceManager) CreateDataSource() (*DataSource, error) {
-	id := NewDataSource(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// GetDataDevice : create a new data device
-//
-// Create a new data device for a given seat.
-//
-//	seat: seat associated with the data device
-func (i *DataDeviceManager) GetDataDevice(seat *Seat) (*DataDevice, error) {
-	id := NewDataDevice(i.Context())
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], seat.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-func (i *DataDeviceManager) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-type DataDeviceManagerDndAction uint32
-
-// DataDeviceManagerDndAction : drag and drop actions
-//
-// This is a bitmask of the available/preferred actions in a
-// drag-and-drop operation.
-//
-// In the compositor, the selected action is a result of matching the
-// actions offered by the source and destination sides.  "action" events
-// with a "none" action will be sent to both source and destination if
-// there is no match. All further checks will effectively happen on
-// (source actions ∩ destination actions).
-//
-// In addition, compositors may also pick different actions in
-// reaction to key modifiers being pressed. One common design that
-// is used in major toolkits (and the behavior recommended for
-// compositors) is:
-//
-// - If no modifiers are pressed, the first match (in bit order)
-// will be used.
-// - Pressing Shift selects "move", if enabled in the mask.
-// - Pressing Control selects "copy", if enabled in the mask.
-//
-// Behavior beyond that is considered implementation-dependent.
-// Compositors may for example bind other modifiers (like Alt/Meta)
-// or drags initiated with other buttons than BTN_LEFT to specific
-// actions (e.g. "ask").
-const (
-	// DataDeviceManagerDndActionNone : no action
-	DataDeviceManagerDndActionNone DataDeviceManagerDndAction = 0
-	// DataDeviceManagerDndActionCopy : copy action
-	DataDeviceManagerDndActionCopy DataDeviceManagerDndAction = 1
-	// DataDeviceManagerDndActionMove : move action
-	DataDeviceManagerDndActionMove DataDeviceManagerDndAction = 2
-	// DataDeviceManagerDndActionAsk : ask action
-	DataDeviceManagerDndActionAsk DataDeviceManagerDndAction = 4
-)
-
-func (e DataDeviceManagerDndAction) Name() string {
-	switch e {
-	case DataDeviceManagerDndActionNone:
-		return "none"
-	case DataDeviceManagerDndActionCopy:
-		return "copy"
-	case DataDeviceManagerDndActionMove:
-		return "move"
-	case DataDeviceManagerDndActionAsk:
-		return "ask"
-	default:
-		return ""
-	}
-}
-
-func (e DataDeviceManagerDndAction) Value() string {
-	switch e {
-	case DataDeviceManagerDndActionNone:
-		return "0"
-	case DataDeviceManagerDndActionCopy:
-		return "1"
-	case DataDeviceManagerDndActionMove:
-		return "2"
-	case DataDeviceManagerDndActionAsk:
-		return "4"
-	default:
-		return ""
-	}
-}
-
-func (e DataDeviceManagerDndAction) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// ShellInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const ShellInterfaceName = "wl_shell"
-
-// Shell : create desktop-style surfaces
-//
-// This interface is implemented by servers that provide
-// desktop-style user interfaces.
-//
-// It allows clients to associate a wl_shell_surface 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.
-type Shell struct {
-	BaseProxy
-}
-
-// NewShell : create desktop-style surfaces
-//
-// This interface is implemented by servers that provide
-// desktop-style user interfaces.
-//
-// It allows clients to associate a wl_shell_surface 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.
-func NewShell(ctx *Context) *Shell {
-	wlShell := &Shell{}
-	ctx.Register(wlShell)
-	return wlShell
-}
-
-// GetShellSurface : create a shell surface from a surface
-//
-// Create a shell surface for an existing surface. This gives
-// the wl_surface the role of a shell surface. If the wl_surface
-// already has another role, it raises a protocol error.
-//
-// Only one shell surface can be associated with a given surface.
-//
-//	surface: surface to be given the shell surface role
-func (i *Shell) GetShellSurface(surface *Surface) (*ShellSurface, error) {
-	id := NewShellSurface(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], surface.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-func (i *Shell) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-type ShellError uint32
-
-// ShellError :
-const (
-	// ShellErrorRole : given wl_surface has another role
-	ShellErrorRole ShellError = 0
-)
-
-func (e ShellError) Name() string {
-	switch e {
-	case ShellErrorRole:
-		return "role"
-	default:
-		return ""
-	}
-}
-
-func (e ShellError) Value() string {
-	switch e {
-	case ShellErrorRole:
-		return "0"
-	default:
-		return ""
-	}
-}
-
-func (e ShellError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// ShellSurfaceInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const ShellSurfaceInterfaceName = "wl_shell_surface"
-
-// ShellSurface : desktop-style metadata interface
-//
-// An interface that may be implemented by a wl_surface, 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 wl_surface is destroyed. On the client side,
-// wl_shell_surface_destroy() must be called before destroying
-// the wl_surface object.
-type ShellSurface struct {
-	BaseProxy
-	pingHandler      ShellSurfacePingHandlerFunc
-	configureHandler ShellSurfaceConfigureHandlerFunc
-	popupDoneHandler ShellSurfacePopupDoneHandlerFunc
-}
-
-// NewShellSurface : desktop-style metadata interface
-//
-// An interface that may be implemented by a wl_surface, 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 wl_surface is destroyed. On the client side,
-// wl_shell_surface_destroy() must be called before destroying
-// the wl_surface object.
-func NewShellSurface(ctx *Context) *ShellSurface {
-	wlShellSurface := &ShellSurface{}
-	ctx.Register(wlShellSurface)
-	return wlShellSurface
-}
-
-// Pong : respond to a ping event
-//
-// A client must respond to a ping event with a pong request or
-// the client may be deemed unresponsive.
-//
-//	serial: serial number of the ping event
-func (i *ShellSurface) Pong(serial uint32) error {
-	const opcode = 0
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Move : 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).
-//
-//	seat: seat whose pointer is used
-//	serial: serial number of the implicit grab on the pointer
-func (i *ShellSurface) Move(seat *Seat, serial uint32) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], seat.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Resize : 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).
-//
-//	seat: seat whose pointer is used
-//	serial: serial number of the implicit grab on the pointer
-//	edges: which edge or corner is being dragged
-func (i *ShellSurface) Resize(seat *Seat, serial, edges uint32) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], seat.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(edges))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetToplevel : make the surface a toplevel surface
-//
-// Map the surface as a toplevel surface.
-//
-// A toplevel surface is not fullscreen, maximized or transient.
-func (i *ShellSurface) SetToplevel() error {
-	const opcode = 3
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetTransient : 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.
-//
-//	parent: parent surface
-//	x: surface-local x coordinate
-//	y: surface-local y coordinate
-//	flags: transient surface behavior
-func (i *ShellSurface) SetTransient(parent *Surface, x, y int32, flags uint32) error {
-	const opcode = 4
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], parent.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(flags))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetFullscreen : 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.
-//
-//	method: method for resolving size conflict
-//	framerate: framerate in mHz
-//	output: output on which the surface is to be fullscreen
-func (i *ShellSurface) SetFullscreen(method, framerate uint32, output *Output) error {
-	const opcode = 5
-	const _reqBufLen = 8 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(method))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(framerate))
-	l += 4
-	if output == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], output.ID())
-		l += 4
-	}
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetPopup : 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.
-//
-//	seat: seat whose pointer is used
-//	serial: serial number of the implicit grab on the pointer
-//	parent: parent surface
-//	x: surface-local x coordinate
-//	y: surface-local y coordinate
-//	flags: transient surface behavior
-func (i *ShellSurface) SetPopup(seat *Seat, serial uint32, parent *Surface, x, y int32, flags uint32) error {
-	const opcode = 6
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], seat.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], parent.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(flags))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetMaximized : 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.
-//
-//	output: output on which the surface is to be maximized
-func (i *ShellSurface) SetMaximized(output *Output) error {
-	const opcode = 7
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	if output == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], output.ID())
-		l += 4
-	}
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetTitle : 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.
-//
-//	title: surface title
-func (i *ShellSurface) SetTitle(title string) error {
-	const opcode = 8
-	titleLen := PaddedLen(len(title) + 1)
-	_reqBufLen := 8 + (4 + titleLen)
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutString(_reqBuf[l:l+(4+titleLen)], title)
-	l += (4 + titleLen)
-	err := i.Context().WriteMsg(_reqBuf, nil)
-	return err
-}
-
-// SetClass : 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.
-//
-//	class: surface class
-func (i *ShellSurface) SetClass(class string) error {
-	const opcode = 9
-	classLen := PaddedLen(len(class) + 1)
-	_reqBufLen := 8 + (4 + classLen)
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutString(_reqBuf[l:l+(4+classLen)], class)
-	l += (4 + classLen)
-	err := i.Context().WriteMsg(_reqBuf, nil)
-	return err
-}
-
-func (i *ShellSurface) Destroy() error {
-	i.MarkZombie()
-	return nil
-}
-
-type ShellSurfaceResize uint32
-
-// ShellSurfaceResize : edge values for resizing
-//
-// These values are used to indicate which edge of a surface
-// is being dragged in a resize operation. The server may
-// use this information to adapt its behavior, e.g. choose
-// an appropriate cursor image.
-const (
-	// ShellSurfaceResizeNone : no edge
-	ShellSurfaceResizeNone ShellSurfaceResize = 0
-	// ShellSurfaceResizeTop : top edge
-	ShellSurfaceResizeTop ShellSurfaceResize = 1
-	// ShellSurfaceResizeBottom : bottom edge
-	ShellSurfaceResizeBottom ShellSurfaceResize = 2
-	// ShellSurfaceResizeLeft : left edge
-	ShellSurfaceResizeLeft ShellSurfaceResize = 4
-	// ShellSurfaceResizeTopLeft : top and left edges
-	ShellSurfaceResizeTopLeft ShellSurfaceResize = 5
-	// ShellSurfaceResizeBottomLeft : bottom and left edges
-	ShellSurfaceResizeBottomLeft ShellSurfaceResize = 6
-	// ShellSurfaceResizeRight : right edge
-	ShellSurfaceResizeRight ShellSurfaceResize = 8
-	// ShellSurfaceResizeTopRight : top and right edges
-	ShellSurfaceResizeTopRight ShellSurfaceResize = 9
-	// ShellSurfaceResizeBottomRight : bottom and right edges
-	ShellSurfaceResizeBottomRight ShellSurfaceResize = 10
-)
-
-func (e ShellSurfaceResize) Name() string {
-	switch e {
-	case ShellSurfaceResizeNone:
-		return "none"
-	case ShellSurfaceResizeTop:
-		return "top"
-	case ShellSurfaceResizeBottom:
-		return "bottom"
-	case ShellSurfaceResizeLeft:
-		return "left"
-	case ShellSurfaceResizeTopLeft:
-		return "top_left"
-	case ShellSurfaceResizeBottomLeft:
-		return "bottom_left"
-	case ShellSurfaceResizeRight:
-		return "right"
-	case ShellSurfaceResizeTopRight:
-		return "top_right"
-	case ShellSurfaceResizeBottomRight:
-		return "bottom_right"
-	default:
-		return ""
-	}
-}
-
-func (e ShellSurfaceResize) Value() string {
-	switch e {
-	case ShellSurfaceResizeNone:
-		return "0"
-	case ShellSurfaceResizeTop:
-		return "1"
-	case ShellSurfaceResizeBottom:
-		return "2"
-	case ShellSurfaceResizeLeft:
-		return "4"
-	case ShellSurfaceResizeTopLeft:
-		return "5"
-	case ShellSurfaceResizeBottomLeft:
-		return "6"
-	case ShellSurfaceResizeRight:
-		return "8"
-	case ShellSurfaceResizeTopRight:
-		return "9"
-	case ShellSurfaceResizeBottomRight:
-		return "10"
-	default:
-		return ""
-	}
-}
-
-func (e ShellSurfaceResize) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type ShellSurfaceTransient uint32
-
-// ShellSurfaceTransient : details of transient behaviour
-//
-// These flags specify details of the expected behaviour
-// of transient surfaces. Used in the set_transient request.
-const (
-	// ShellSurfaceTransientInactive : do not set keyboard focus
-	ShellSurfaceTransientInactive ShellSurfaceTransient = 0x1
-)
-
-func (e ShellSurfaceTransient) Name() string {
-	switch e {
-	case ShellSurfaceTransientInactive:
-		return "inactive"
-	default:
-		return ""
-	}
-}
-
-func (e ShellSurfaceTransient) Value() string {
-	switch e {
-	case ShellSurfaceTransientInactive:
-		return "0x1"
-	default:
-		return ""
-	}
-}
-
-func (e ShellSurfaceTransient) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type ShellSurfaceFullscreenMethod uint32
-
-// ShellSurfaceFullscreenMethod : different method to set the surface fullscreen
-//
-// Hints to indicate to the compositor how to deal with a conflict
-// between the dimensions of the surface and the dimensions of the
-// output. The compositor is free to ignore this parameter.
-const (
-	// ShellSurfaceFullscreenMethodDefault : no preference, apply default policy
-	ShellSurfaceFullscreenMethodDefault ShellSurfaceFullscreenMethod = 0
-	// ShellSurfaceFullscreenMethodScale : scale, preserve the surface's aspect ratio and center on output
-	ShellSurfaceFullscreenMethodScale ShellSurfaceFullscreenMethod = 1
-	// ShellSurfaceFullscreenMethodDriver : switch output mode to the smallest mode that can fit the surface, add black borders to compensate size mismatch
-	ShellSurfaceFullscreenMethodDriver ShellSurfaceFullscreenMethod = 2
-	// ShellSurfaceFullscreenMethodFill : no upscaling, center on output and add black borders to compensate size mismatch
-	ShellSurfaceFullscreenMethodFill ShellSurfaceFullscreenMethod = 3
-)
-
-func (e ShellSurfaceFullscreenMethod) Name() string {
-	switch e {
-	case ShellSurfaceFullscreenMethodDefault:
-		return "default"
-	case ShellSurfaceFullscreenMethodScale:
-		return "scale"
-	case ShellSurfaceFullscreenMethodDriver:
-		return "driver"
-	case ShellSurfaceFullscreenMethodFill:
-		return "fill"
-	default:
-		return ""
-	}
-}
-
-func (e ShellSurfaceFullscreenMethod) Value() string {
-	switch e {
-	case ShellSurfaceFullscreenMethodDefault:
-		return "0"
-	case ShellSurfaceFullscreenMethodScale:
-		return "1"
-	case ShellSurfaceFullscreenMethodDriver:
-		return "2"
-	case ShellSurfaceFullscreenMethodFill:
-		return "3"
-	default:
-		return ""
-	}
-}
-
-func (e ShellSurfaceFullscreenMethod) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// ShellSurfacePingEvent : 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.
-type ShellSurfacePingEvent struct {
-	Serial uint32
-}
-type ShellSurfacePingHandlerFunc func(ShellSurfacePingEvent)
-
-// SetPingHandler : sets handler for ShellSurfacePingEvent
-func (i *ShellSurface) SetPingHandler(f ShellSurfacePingHandlerFunc) {
-	i.pingHandler = f
-}
-
-// ShellSurfaceConfigureEvent : 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.
-type ShellSurfaceConfigureEvent struct {
-	Edges  uint32
-	Width  int32
-	Height int32
-}
-type ShellSurfaceConfigureHandlerFunc func(ShellSurfaceConfigureEvent)
-
-// SetConfigureHandler : sets handler for ShellSurfaceConfigureEvent
-func (i *ShellSurface) SetConfigureHandler(f ShellSurfaceConfigureHandlerFunc) {
-	i.configureHandler = f
-}
-
-// ShellSurfacePopupDoneEvent : 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.
-type ShellSurfacePopupDoneEvent struct{}
-type ShellSurfacePopupDoneHandlerFunc func(ShellSurfacePopupDoneEvent)
-
-// SetPopupDoneHandler : sets handler for ShellSurfacePopupDoneEvent
-func (i *ShellSurface) SetPopupDoneHandler(f ShellSurfacePopupDoneHandlerFunc) {
-	i.popupDoneHandler = f
-}
-
-func (i *ShellSurface) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.pingHandler == nil {
-			return
-		}
-		var e ShellSurfacePingEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-
-		i.pingHandler(e)
-	case 1:
-		if i.configureHandler == nil {
-			return
-		}
-		var e ShellSurfaceConfigureEvent
-		l := 0
-		e.Edges = Uint32(data[l : l+4])
-		l += 4
-		e.Width = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Height = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.configureHandler(e)
-	case 2:
-		if i.popupDoneHandler == nil {
-			return
-		}
-		var e ShellSurfacePopupDoneEvent
-
-		i.popupDoneHandler(e)
-	}
-}
-
-// SurfaceInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const SurfaceInterfaceName = "wl_surface"
-
-// Surface : 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 wl_surface. Examples of roles are a cursor for a
-// pointer (as set by wl_pointer.set_cursor), a drag icon
-// (wl_data_device.start_drag), a sub-surface
-// (wl_subcompositor.get_subsurface), and a window as defined by a
-// shell protocol (e.g. wl_shell.get_shell_surface).
-//
-// A surface can have only one role at a time. Initially a
-// wl_surface does not have a role. Once a wl_surface is given a
-// role, it is set permanently for the whole lifetime of the
-// wl_surface 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
-// wl_pointer.set_cursor. The request should explicitly mention
-// that this request gives a role to a wl_surface. Often, this
-// request also creates a new protocol object that represents the
-// role and adds additional functionality to wl_surface. When a
-// client wants to destroy a wl_surface, they must destroy this role
-// object before the wl_surface, otherwise a defunct_role_object error is
-// sent.
-//
-// Destroying the role object does not remove the role from the
-// wl_surface, but it may stop the wl_surface from "playing the role".
-// For instance, if a wl_subsurface object is destroyed, the wl_surface
-// it was created for will be unmapped and forget its position and
-// z-order. It is allowed to create a wl_subsurface for the same
-// wl_surface again, but it is not allowed to use the wl_surface as
-// a cursor (cursor is a different role than sub-surface, and role
-// switching is not allowed).
-type Surface struct {
-	BaseProxy
-	enterHandler                    SurfaceEnterHandlerFunc
-	leaveHandler                    SurfaceLeaveHandlerFunc
-	preferredBufferScaleHandler     SurfacePreferredBufferScaleHandlerFunc
-	preferredBufferTransformHandler SurfacePreferredBufferTransformHandlerFunc
-}
-
-// NewSurface : 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 wl_surface. Examples of roles are a cursor for a
-// pointer (as set by wl_pointer.set_cursor), a drag icon
-// (wl_data_device.start_drag), a sub-surface
-// (wl_subcompositor.get_subsurface), and a window as defined by a
-// shell protocol (e.g. wl_shell.get_shell_surface).
-//
-// A surface can have only one role at a time. Initially a
-// wl_surface does not have a role. Once a wl_surface is given a
-// role, it is set permanently for the whole lifetime of the
-// wl_surface 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
-// wl_pointer.set_cursor. The request should explicitly mention
-// that this request gives a role to a wl_surface. Often, this
-// request also creates a new protocol object that represents the
-// role and adds additional functionality to wl_surface. When a
-// client wants to destroy a wl_surface, they must destroy this role
-// object before the wl_surface, otherwise a defunct_role_object error is
-// sent.
-//
-// Destroying the role object does not remove the role from the
-// wl_surface, but it may stop the wl_surface from "playing the role".
-// For instance, if a wl_subsurface object is destroyed, the wl_surface
-// it was created for will be unmapped and forget its position and
-// z-order. It is allowed to create a wl_subsurface for the same
-// wl_surface again, but it is not allowed to use the wl_surface as
-// a cursor (cursor is a different role than sub-surface, and role
-// switching is not allowed).
-func NewSurface(ctx *Context) *Surface {
-	wlSurface := &Surface{}
-	ctx.Register(wlSurface)
-	return wlSurface
-}
-
-// Destroy : delete surface
-//
-// Deletes the surface and invalidates its object ID.
-func (i *Surface) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Attach : 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 wl_surface.offset request.
-//
-// When the bound wl_surface 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 wl_surface.offset.
-//
-// Surface contents are double-buffered state, see wl_surface.commit.
-//
-// The initial surface contents are void; there is no content.
-// wl_surface.attach assigns the given wl_buffer as the pending
-// wl_buffer. wl_surface.commit makes the pending wl_buffer the new
-// surface contents, and the size of the surface becomes the size
-// calculated from the wl_buffer, as described above. After commit,
-// there is no pending buffer until the next attach.
-//
-// Committing a pending wl_buffer allows the compositor to read the
-// pixels in the wl_buffer. The compositor may access the pixels at
-// any time after the wl_surface.commit request. When the compositor
-// will not access the pixels anymore, it will send the
-// wl_buffer.release event. Only after receiving wl_buffer.release,
-// the client may reuse the wl_buffer. A wl_buffer 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 wl_buffer has been committed to more than one wl_surface,
-// the delivery of wl_buffer.release events becomes undefined. A well
-// behaved client should not rely on wl_buffer.release events in this
-// case. Alternatively, a client could create multiple wl_buffer objects
-// from the same backing storage or use a protocol extension providing
-// per-commit release notifications.
-//
-// Destroying the wl_buffer after wl_buffer.release does not change
-// the surface contents. Destroying the wl_buffer before wl_buffer.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 wl_buffer before receiving the wl_buffer.release event and
-// mutates the underlying buffer storage, the surface contents become
-// undefined immediately.
-//
-// If wl_surface.attach is sent with a NULL wl_buffer, the
-// following wl_surface.commit will remove the surface content.
-//
-// If a pending wl_buffer has been destroyed, the result is not specified.
-// Many compositors are known to remove the surface content on the following
-// wl_surface.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.
-//
-//	buffer: buffer of surface contents
-//	x: surface-local x coordinate
-//	y: surface-local y coordinate
-func (i *Surface) Attach(buffer *Buffer, x, y int32) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	if buffer == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], buffer.ID())
-		l += 4
-	}
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Damage : 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 wl_surface.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.
-// wl_surface.damage adds pending damage: the new pending damage
-// is the union of old pending damage and the given rectangle.
-//
-// wl_surface.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 wl_surface.damage_buffer which uses buffer coordinates
-// instead of surface coordinates.
-//
-//	x: surface-local x coordinate
-//	y: surface-local y coordinate
-//	width: width of damage rectangle
-//	height: height of damage rectangle
-func (i *Surface) Damage(x, y, width, height int32) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(width))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(height))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Frame : 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 wl_surface, 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 wl_surface.commit.
-// The notification will only be posted for one frame unless
-// requested again. For a wl_surface, 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.
-func (i *Surface) Frame() (*Callback, error) {
-	callback := NewCallback(i.Context())
-	const opcode = 3
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], callback.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return callback, err
-}
-
-// SetOpaqueRegion : 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 wl_surface.commit.
-//
-// wl_surface.set_opaque_region changes the pending opaque region.
-// wl_surface.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 wl_region object can be
-// destroyed immediately. A NULL wl_region causes the pending opaque
-// region to be set to empty.
-//
-//	region: opaque region of the surface
-func (i *Surface) SetOpaqueRegion(region *Region) error {
-	const opcode = 4
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	if region == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], region.ID())
-		l += 4
-	}
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetInputRegion : 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 wl_surface.commit.
-//
-// wl_surface.set_input_region changes the pending input region.
-// wl_surface.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
-// wl_pointer.set_cursor and wl_data_device.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 wl_region object can be destroyed
-// immediately. A NULL wl_region causes the input region to be set
-// to infinite.
-//
-//	region: input region of the surface
-func (i *Surface) SetInputRegion(region *Region) error {
-	const opcode = 5
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	if region == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], region.ID())
-		l += 4
-	}
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Commit : 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.
-//
-// A commit request atomically creates a content update from the pending
-// state, even if the pending state has not been touched. The content
-// update is placed in a queue until it becomes active. After commit, the
-// new pending state is as documented for each related request.
-//
-// When the content update is applied, the wl_buffer 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
-// wl_surface.attach itself. If there is no newly attached wl_buffer, the
-// coordinates are relative to the previous content update.
-//
-// 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.
-func (i *Surface) Commit() error {
-	const opcode = 6
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetBufferTransform : 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 wl_output.transform.
-//
-// The compositor applies the inverse of this transformation whenever it
-// uses the buffer contents.
-//
-// Buffer transform is double-buffered state, see wl_surface.commit.
-//
-// A newly created surface has its buffer transformation set to normal.
-//
-// wl_surface.set_buffer_transform changes the pending buffer
-// transformation. wl_surface.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
-// wl_output.transform enum the invalid_transform protocol error
-// is raised.
-//
-//	transform: transform for interpreting buffer contents
-func (i *Surface) SetBufferTransform(transform int32) error {
-	const opcode = 7
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(transform))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetBufferScale : 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 wl_surface.commit.
-//
-// A newly created surface has its buffer scale set to 1.
-//
-// wl_surface.set_buffer_scale changes the pending buffer scale.
-// wl_surface.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.
-//
-//	scale: scale for interpreting buffer contents
-func (i *Surface) SetBufferScale(scale int32) error {
-	const opcode = 8
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(scale))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// DamageBuffer : 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 wl_surface.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.
-// wl_surface.damage_buffer adds pending damage: the new pending
-// damage is the union of old pending damage and the given rectangle.
-//
-// wl_surface.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 wl_surface.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
-// wl_surface.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 wl_surface.commit.
-//
-//	x: buffer-local x coordinate
-//	y: buffer-local y coordinate
-//	width: width of damage rectangle
-//	height: height of damage rectangle
-func (i *Surface) DamageBuffer(x, y, width, height int32) error {
-	const opcode = 9
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(width))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(height))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Offset : 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 wl_surface.offset are role-specific. Refer to
-// the documentation of specific roles for more information.
-//
-// Surface location offset is double-buffered state, see
-// wl_surface.commit.
-//
-// This request is semantically equivalent to and the replaces the x and y
-// arguments in the wl_surface.attach request in wl_surface versions prior
-// to 5. See wl_surface.attach for details.
-//
-//	x: surface-local x coordinate
-//	y: surface-local y coordinate
-func (i *Surface) Offset(x, y int32) error {
-	const opcode = 10
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type SurfaceError uint32
-
-// SurfaceError : wl_surface error values
-//
-// These errors can be emitted in response to wl_surface requests.
-const (
-	// SurfaceErrorInvalidScale : buffer scale value is invalid
-	SurfaceErrorInvalidScale SurfaceError = 0
-	// SurfaceErrorInvalidTransform : buffer transform value is invalid
-	SurfaceErrorInvalidTransform SurfaceError = 1
-	// SurfaceErrorInvalidSize : buffer size is invalid
-	SurfaceErrorInvalidSize SurfaceError = 2
-	// SurfaceErrorInvalidOffset : buffer offset is invalid
-	SurfaceErrorInvalidOffset SurfaceError = 3
-	// SurfaceErrorDefunctRoleObject : surface was destroyed before its role object
-	SurfaceErrorDefunctRoleObject SurfaceError = 4
-)
-
-func (e SurfaceError) Name() string {
-	switch e {
-	case SurfaceErrorInvalidScale:
-		return "invalid_scale"
-	case SurfaceErrorInvalidTransform:
-		return "invalid_transform"
-	case SurfaceErrorInvalidSize:
-		return "invalid_size"
-	case SurfaceErrorInvalidOffset:
-		return "invalid_offset"
-	case SurfaceErrorDefunctRoleObject:
-		return "defunct_role_object"
-	default:
-		return ""
-	}
-}
-
-func (e SurfaceError) Value() string {
-	switch e {
-	case SurfaceErrorInvalidScale:
-		return "0"
-	case SurfaceErrorInvalidTransform:
-		return "1"
-	case SurfaceErrorInvalidSize:
-		return "2"
-	case SurfaceErrorInvalidOffset:
-		return "3"
-	case SurfaceErrorDefunctRoleObject:
-		return "4"
-	default:
-		return ""
-	}
-}
-
-func (e SurfaceError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// SurfaceEnterEvent : 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.
-type SurfaceEnterEvent struct {
-	Output *Output
-}
-type SurfaceEnterHandlerFunc func(SurfaceEnterEvent)
-
-// SetEnterHandler : sets handler for SurfaceEnterEvent
-func (i *Surface) SetEnterHandler(f SurfaceEnterHandlerFunc) {
-	i.enterHandler = f
-}
-
-// SurfaceLeaveEvent : 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.
-type SurfaceLeaveEvent struct {
-	Output *Output
-}
-type SurfaceLeaveHandlerFunc func(SurfaceLeaveEvent)
-
-// SetLeaveHandler : sets handler for SurfaceLeaveEvent
-func (i *Surface) SetLeaveHandler(f SurfaceLeaveHandlerFunc) {
-	i.leaveHandler = f
-}
-
-// SurfacePreferredBufferScaleEvent : 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 wl_surface.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.
-type SurfacePreferredBufferScaleEvent struct {
-	Factor int32
-}
-type SurfacePreferredBufferScaleHandlerFunc func(SurfacePreferredBufferScaleEvent)
-
-// SetPreferredBufferScaleHandler : sets handler for SurfacePreferredBufferScaleEvent
-func (i *Surface) SetPreferredBufferScaleHandler(f SurfacePreferredBufferScaleHandlerFunc) {
-	i.preferredBufferScaleHandler = f
-}
-
-// SurfacePreferredBufferTransformEvent : 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
-// wl_surface.set_buffer_transform might allow the compositor to use the
-// surface buffer more efficiently.
-type SurfacePreferredBufferTransformEvent struct {
-	Transform uint32
-}
-type SurfacePreferredBufferTransformHandlerFunc func(SurfacePreferredBufferTransformEvent)
-
-// SetPreferredBufferTransformHandler : sets handler for SurfacePreferredBufferTransformEvent
-func (i *Surface) SetPreferredBufferTransformHandler(f SurfacePreferredBufferTransformHandlerFunc) {
-	i.preferredBufferTransformHandler = f
-}
-
-func (i *Surface) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.enterHandler == nil {
-			return
-		}
-		var e SurfaceEnterEvent
-		l := 0
-		e.Output = i.Context().GetProxy(Uint32(data[l : l+4])).(*Output)
-		l += 4
-
-		i.enterHandler(e)
-	case 1:
-		if i.leaveHandler == nil {
-			return
-		}
-		var e SurfaceLeaveEvent
-		l := 0
-		e.Output = i.Context().GetProxy(Uint32(data[l : l+4])).(*Output)
-		l += 4
-
-		i.leaveHandler(e)
-	case 2:
-		if i.preferredBufferScaleHandler == nil {
-			return
-		}
-		var e SurfacePreferredBufferScaleEvent
-		l := 0
-		e.Factor = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.preferredBufferScaleHandler(e)
-	case 3:
-		if i.preferredBufferTransformHandler == nil {
-			return
-		}
-		var e SurfacePreferredBufferTransformEvent
-		l := 0
-		e.Transform = Uint32(data[l : l+4])
-		l += 4
-
-		i.preferredBufferTransformHandler(e)
-	}
-}
-
-// SeatInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const SeatInterfaceName = "wl_seat"
-
-// Seat : 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.
-type Seat struct {
-	BaseProxy
-	capabilitiesHandler SeatCapabilitiesHandlerFunc
-	nameHandler         SeatNameHandlerFunc
-}
-
-// NewSeat : 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.
-func NewSeat(ctx *Context) *Seat {
-	wlSeat := &Seat{}
-	ctx.Register(wlSeat)
-	return wlSeat
-}
-
-// GetPointer : return pointer object
-//
-// The ID provided will be initialized to the wl_pointer 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.
-func (i *Seat) GetPointer() (*Pointer, error) {
-	id := NewPointer(i.Context())
-	const opcode = 0
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// GetKeyboard : return keyboard object
-//
-// The ID provided will be initialized to the wl_keyboard 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.
-func (i *Seat) GetKeyboard() (*Keyboard, error) {
-	id := NewKeyboard(i.Context())
-	const opcode = 1
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// GetTouch : return touch object
-//
-// The ID provided will be initialized to the wl_touch 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.
-func (i *Seat) GetTouch() (*Touch, error) {
-	id := NewTouch(i.Context())
-	const opcode = 2
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// Release : release the seat object
-//
-// Using this request a client can tell the server that it is not going to
-// use the seat object anymore.
-func (i *Seat) Release() error {
-	defer i.MarkZombie()
-	const opcode = 3
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type SeatCapability uint32
-
-// SeatCapability : seat capability bitmask
-//
-// This is a bitmask of capabilities this seat has; if a member is
-// set, then it is present on the seat.
-const (
-	// SeatCapabilityPointer : the seat has pointer devices
-	SeatCapabilityPointer SeatCapability = 1
-	// SeatCapabilityKeyboard : the seat has one or more keyboards
-	SeatCapabilityKeyboard SeatCapability = 2
-	// SeatCapabilityTouch : the seat has touch devices
-	SeatCapabilityTouch SeatCapability = 4
-)
-
-func (e SeatCapability) Name() string {
-	switch e {
-	case SeatCapabilityPointer:
-		return "pointer"
-	case SeatCapabilityKeyboard:
-		return "keyboard"
-	case SeatCapabilityTouch:
-		return "touch"
-	default:
-		return ""
-	}
-}
-
-func (e SeatCapability) Value() string {
-	switch e {
-	case SeatCapabilityPointer:
-		return "1"
-	case SeatCapabilityKeyboard:
-		return "2"
-	case SeatCapabilityTouch:
-		return "4"
-	default:
-		return ""
-	}
-}
-
-func (e SeatCapability) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type SeatError uint32
-
-// SeatError : wl_seat error values
-//
-// These errors can be emitted in response to wl_seat requests.
-const (
-	// SeatErrorMissingCapability : get_pointer, get_keyboard or get_touch called on seat without the matching capability
-	SeatErrorMissingCapability SeatError = 0
-)
-
-func (e SeatError) Name() string {
-	switch e {
-	case SeatErrorMissingCapability:
-		return "missing_capability"
-	default:
-		return ""
-	}
-}
-
-func (e SeatError) Value() string {
-	switch e {
-	case SeatErrorMissingCapability:
-		return "0"
-	default:
-		return ""
-	}
-}
-
-func (e SeatError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// SeatCapabilitiesEvent : 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
-// wl_pointer object using the wl_seat.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
-// wl_pointer objects associated with the seat where the capability was
-// removed, using the wl_pointer.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 wl_pointer 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. wl_pointer 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 wl_keyboard and wl_touch with the
-// keyboard and touch capabilities, respectively.
-type SeatCapabilitiesEvent struct {
-	Capabilities uint32
-}
-type SeatCapabilitiesHandlerFunc func(SeatCapabilitiesEvent)
-
-// SetCapabilitiesHandler : sets handler for SeatCapabilitiesEvent
-func (i *Seat) SetCapabilitiesHandler(f SeatCapabilitiesHandlerFunc) {
-	i.capabilitiesHandler = f
-}
-
-// SeatNameEvent : 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 wl_seat 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 wl_seat global.
-//
-// The name event is sent after binding to the seat global, and should be sent
-// before announcing capabilities. This event only sent once per seat object,
-// and the name does not change over the lifetime of the wl_seat global.
-//
-// Compositors may re-use the same seat name if the wl_seat global is
-// destroyed and re-created later.
-type SeatNameEvent struct {
-	Name string
-}
-type SeatNameHandlerFunc func(SeatNameEvent)
-
-// SetNameHandler : sets handler for SeatNameEvent
-func (i *Seat) SetNameHandler(f SeatNameHandlerFunc) {
-	i.nameHandler = f
-}
-
-func (i *Seat) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.capabilitiesHandler == nil {
-			return
-		}
-		var e SeatCapabilitiesEvent
-		l := 0
-		e.Capabilities = Uint32(data[l : l+4])
-		l += 4
-
-		i.capabilitiesHandler(e)
-	case 1:
-		if i.nameHandler == nil {
-			return
-		}
-		var e SeatNameEvent
-		l := 0
-		nameLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Name = String(data[l : l+nameLen])
-		l += nameLen
-
-		i.nameHandler(e)
-	}
-}
-
-// PointerInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const PointerInterfaceName = "wl_pointer"
-
-// Pointer : pointer input device
-//
-// The wl_pointer interface represents one or more input devices,
-// such as mice, which control the pointer location and pointer_focus
-// of a seat.
-//
-// The wl_pointer 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.
-type Pointer struct {
-	BaseProxy
-	enterHandler                 PointerEnterHandlerFunc
-	leaveHandler                 PointerLeaveHandlerFunc
-	motionHandler                PointerMotionHandlerFunc
-	buttonHandler                PointerButtonHandlerFunc
-	axisHandler                  PointerAxisHandlerFunc
-	frameHandler                 PointerFrameHandlerFunc
-	axisSourceHandler            PointerAxisSourceHandlerFunc
-	axisStopHandler              PointerAxisStopHandlerFunc
-	axisDiscreteHandler          PointerAxisDiscreteHandlerFunc
-	axisValue120Handler          PointerAxisValue120HandlerFunc
-	axisRelativeDirectionHandler PointerAxisRelativeDirectionHandlerFunc
-}
-
-// NewPointer : pointer input device
-//
-// The wl_pointer interface represents one or more input devices,
-// such as mice, which control the pointer location and pointer_focus
-// of a seat.
-//
-// The wl_pointer 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.
-func NewPointer(ctx *Context) *Pointer {
-	wlPointer := &Pointer{}
-	ctx.Register(wlPointer)
-	return wlPointer
-}
-
-// SetCursor : 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 wl_surface.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
-// wl_surface.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 wl_surface is
-// unmapped.
-//
-// The serial parameter must match the latest wl_pointer.enter
-// serial number sent to the client. Otherwise the request will be
-// ignored.
-//
-//	serial: serial number of the enter event
-//	surface: pointer surface
-//	hotspotX: surface-local x coordinate
-//	hotspotY: surface-local y coordinate
-func (i *Pointer) SetCursor(serial uint32, surface *Surface, hotspotX, hotspotY int32) error {
-	const opcode = 0
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(serial))
-	l += 4
-	if surface == nil {
-		PutUint32(_reqBuf[l:l+4], 0)
-		l += 4
-	} else {
-		PutUint32(_reqBuf[l:l+4], surface.ID())
-		l += 4
-	}
-	PutUint32(_reqBuf[l:l+4], uint32(hotspotX))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(hotspotY))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Release : 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.
-func (i *Pointer) Release() error {
-	defer i.MarkZombie()
-	const opcode = 1
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type PointerError uint32
-
-// PointerError :
-const (
-	// PointerErrorRole : given wl_surface has another role
-	PointerErrorRole PointerError = 0
-)
-
-func (e PointerError) Name() string {
-	switch e {
-	case PointerErrorRole:
-		return "role"
-	default:
-		return ""
-	}
-}
-
-func (e PointerError) Value() string {
-	switch e {
-	case PointerErrorRole:
-		return "0"
-	default:
-		return ""
-	}
-}
-
-func (e PointerError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type PointerButtonState uint32
-
-// PointerButtonState : physical button state
-//
-// Describes the physical state of a button that produced the button
-// event.
-const (
-	// PointerButtonStateReleased : the button is not pressed
-	PointerButtonStateReleased PointerButtonState = 0
-	// PointerButtonStatePressed : the button is pressed
-	PointerButtonStatePressed PointerButtonState = 1
-)
-
-func (e PointerButtonState) Name() string {
-	switch e {
-	case PointerButtonStateReleased:
-		return "released"
-	case PointerButtonStatePressed:
-		return "pressed"
-	default:
-		return ""
-	}
-}
-
-func (e PointerButtonState) Value() string {
-	switch e {
-	case PointerButtonStateReleased:
-		return "0"
-	case PointerButtonStatePressed:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e PointerButtonState) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type PointerAxis uint32
-
-// PointerAxis : axis types
-//
-// Describes the axis types of scroll events.
-const (
-	// PointerAxisVerticalScroll : vertical axis
-	PointerAxisVerticalScroll PointerAxis = 0
-	// PointerAxisHorizontalScroll : horizontal axis
-	PointerAxisHorizontalScroll PointerAxis = 1
-)
-
-func (e PointerAxis) Name() string {
-	switch e {
-	case PointerAxisVerticalScroll:
-		return "vertical_scroll"
-	case PointerAxisHorizontalScroll:
-		return "horizontal_scroll"
-	default:
-		return ""
-	}
-}
-
-func (e PointerAxis) Value() string {
-	switch e {
-	case PointerAxisVerticalScroll:
-		return "0"
-	case PointerAxisHorizontalScroll:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e PointerAxis) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type PointerAxisSource uint32
-
-// PointerAxisSource : axis source types
-//
-// Describes the source types for axis events. This indicates to the
-// client how an axis event was physically generated; a client may
-// adjust the user interface accordingly. For example, scroll events
-// from a "finger" source may be in a smooth coordinate space with
-// kinetic scrolling whereas a "wheel" source may be in discrete steps
-// of a number of lines.
-//
-// The "continuous" axis source is a device generating events in a
-// continuous coordinate space, but using something other than a
-// finger. One example for this source is button-based scrolling where
-// the vertical motion of a device is converted to scroll events while
-// a button is held down.
-//
-// The "wheel tilt" axis source indicates that the actual device is a
-// wheel but the scroll event is not caused by a rotation but a
-// (usually sideways) tilt of the wheel.
-const (
-	// PointerAxisSourceWheel : a physical wheel rotation
-	PointerAxisSourceWheel PointerAxisSource = 0
-	// PointerAxisSourceFinger : finger on a touch surface
-	PointerAxisSourceFinger PointerAxisSource = 1
-	// PointerAxisSourceContinuous : continuous coordinate space
-	PointerAxisSourceContinuous PointerAxisSource = 2
-	// PointerAxisSourceWheelTilt : a physical wheel tilt
-	PointerAxisSourceWheelTilt PointerAxisSource = 3
-)
-
-func (e PointerAxisSource) Name() string {
-	switch e {
-	case PointerAxisSourceWheel:
-		return "wheel"
-	case PointerAxisSourceFinger:
-		return "finger"
-	case PointerAxisSourceContinuous:
-		return "continuous"
-	case PointerAxisSourceWheelTilt:
-		return "wheel_tilt"
-	default:
-		return ""
-	}
-}
-
-func (e PointerAxisSource) Value() string {
-	switch e {
-	case PointerAxisSourceWheel:
-		return "0"
-	case PointerAxisSourceFinger:
-		return "1"
-	case PointerAxisSourceContinuous:
-		return "2"
-	case PointerAxisSourceWheelTilt:
-		return "3"
-	default:
-		return ""
-	}
-}
-
-func (e PointerAxisSource) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type PointerAxisRelativeDirection uint32
-
-// PointerAxisRelativeDirection : axis relative direction
-//
-// This specifies the direction of the physical motion that caused a
-// wl_pointer.axis event, relative to the wl_pointer.axis direction.
-const (
-	// PointerAxisRelativeDirectionIdentical : physical motion matches axis direction
-	PointerAxisRelativeDirectionIdentical PointerAxisRelativeDirection = 0
-	// PointerAxisRelativeDirectionInverted : physical motion is the inverse of the axis direction
-	PointerAxisRelativeDirectionInverted PointerAxisRelativeDirection = 1
-)
-
-func (e PointerAxisRelativeDirection) Name() string {
-	switch e {
-	case PointerAxisRelativeDirectionIdentical:
-		return "identical"
-	case PointerAxisRelativeDirectionInverted:
-		return "inverted"
-	default:
-		return ""
-	}
-}
-
-func (e PointerAxisRelativeDirection) Value() string {
-	switch e {
-	case PointerAxisRelativeDirectionIdentical:
-		return "0"
-	case PointerAxisRelativeDirectionInverted:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e PointerAxisRelativeDirection) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// PointerEnterEvent : 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.
-type PointerEnterEvent struct {
-	Serial   uint32
-	Surface  *Surface
-	SurfaceX float64
-	SurfaceY float64
-}
-type PointerEnterHandlerFunc func(PointerEnterEvent)
-
-// SetEnterHandler : sets handler for PointerEnterEvent
-func (i *Pointer) SetEnterHandler(f PointerEnterHandlerFunc) {
-	i.enterHandler = f
-}
-
-// PointerLeaveEvent : 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.
-type PointerLeaveEvent struct {
-	Serial  uint32
-	Surface *Surface
-}
-type PointerLeaveHandlerFunc func(PointerLeaveEvent)
-
-// SetLeaveHandler : sets handler for PointerLeaveEvent
-func (i *Pointer) SetLeaveHandler(f PointerLeaveHandlerFunc) {
-	i.leaveHandler = f
-}
-
-// PointerMotionEvent : pointer motion event
-//
-// Notification of pointer location change. The arguments
-// surface_x and surface_y are the location relative to the
-// focused surface.
-type PointerMotionEvent struct {
-	Time     uint32
-	SurfaceX float64
-	SurfaceY float64
-}
-type PointerMotionHandlerFunc func(PointerMotionEvent)
-
-// SetMotionHandler : sets handler for PointerMotionEvent
-func (i *Pointer) SetMotionHandler(f PointerMotionHandlerFunc) {
-	i.motionHandler = f
-}
-
-// PointerButtonEvent : pointer button event
-//
-// Mouse button click and release notifications.
-//
-// The location of the click is given by the last motion 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.
-type PointerButtonEvent struct {
-	Serial uint32
-	Time   uint32
-	Button uint32
-	State  uint32
-}
-type PointerButtonHandlerFunc func(PointerButtonEvent)
-
-// SetButtonHandler : sets handler for PointerButtonEvent
-func (i *Pointer) SetButtonHandler(f PointerButtonHandlerFunc) {
-	i.buttonHandler = f
-}
-
-// PointerAxisEvent : 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.
-type PointerAxisEvent struct {
-	Time  uint32
-	Axis  uint32
-	Value float64
-}
-type PointerAxisHandlerFunc func(PointerAxisEvent)
-
-// SetAxisHandler : sets handler for PointerAxisEvent
-func (i *Pointer) SetAxisHandler(f PointerAxisHandlerFunc) {
-	i.axisHandler = f
-}
-
-// PointerFrameEvent : 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 wl_pointer events before a wl_pointer.frame event belong
-// logically together. For example, in a diagonal scroll motion the
-// compositor will send an optional wl_pointer.axis_source event, two
-// wl_pointer.axis events (horizontal and vertical) and finally a
-// wl_pointer.frame event. The client may use this information to
-// calculate a diagonal vector for scrolling.
-//
-// When multiple wl_pointer.axis events occur within the same frame,
-// the motion vector is the combined motion of all events.
-// When a wl_pointer.axis and a wl_pointer.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 wl_pointer.axis_stop events occur within the same
-// frame, this indicates that these axes stopped in the same instance.
-//
-// A wl_pointer.frame event is sent for every logical event group,
-// even if the group only contains a single wl_pointer event.
-// Specifically, a client may get a sequence: motion, frame, button,
-// frame, axis, frame, axis_stop, frame.
-//
-// The wl_pointer.enter and wl_pointer.leave events are logical events
-// generated by the compositor and not the hardware. These events are
-// also grouped by a wl_pointer.frame. When a pointer moves from one
-// surface to another, a compositor should group the
-// wl_pointer.leave event within the same wl_pointer.frame.
-// However, a client must not rely on wl_pointer.leave and
-// wl_pointer.enter being in the same wl_pointer.frame.
-// Compositor-specific policies may require the wl_pointer.leave and
-// wl_pointer.enter event being split across multiple wl_pointer.frame
-// groups.
-type PointerFrameEvent struct{}
-type PointerFrameHandlerFunc func(PointerFrameEvent)
-
-// SetFrameHandler : sets handler for PointerFrameEvent
-func (i *Pointer) SetFrameHandler(f PointerFrameHandlerFunc) {
-	i.frameHandler = f
-}
-
-// PointerAxisSourceEvent : axis source event
-//
-// Source information for scroll and other axes.
-//
-// This event does not occur on its own. It is sent before a
-// wl_pointer.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
-// wl_pointer.axis_source.finger, a wl_pointer.axis_stop event will be
-// sent when the user lifts the finger off the device.
-//
-// If the source is wl_pointer.axis_source.wheel,
-// wl_pointer.axis_source.wheel_tilt or
-// wl_pointer.axis_source.continuous, a wl_pointer.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 wl_pointer.axis_source event is permitted per frame.
-//
-// The order of wl_pointer.axis_discrete and wl_pointer.axis_source is
-// not guaranteed.
-type PointerAxisSourceEvent struct {
-	AxisSource uint32
-}
-type PointerAxisSourceHandlerFunc func(PointerAxisSourceEvent)
-
-// SetAxisSourceHandler : sets handler for PointerAxisSourceEvent
-func (i *Pointer) SetAxisSourceHandler(f PointerAxisSourceHandlerFunc) {
-	i.axisSourceHandler = f
-}
-
-// PointerAxisStopEvent : axis stop event
-//
-// Stop notification for scroll and other axes.
-//
-// For some wl_pointer.axis_source types, a wl_pointer.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 wl_pointer.axis_source documentation for information on when
-// this event may be generated.
-//
-// Any wl_pointer.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
-// wl_pointer.axis event. The timestamp value may be the same as a
-// preceding wl_pointer.axis event.
-type PointerAxisStopEvent struct {
-	Time uint32
-	Axis uint32
-}
-type PointerAxisStopHandlerFunc func(PointerAxisStopEvent)
-
-// SetAxisStopHandler : sets handler for PointerAxisStopEvent
-func (i *Pointer) SetAxisStopHandler(f PointerAxisStopHandlerFunc) {
-	i.axisStopHandler = f
-}
-
-// PointerAxisDiscreteEvent : axis click event
-//
-// Discrete step information for scroll and other axes.
-//
-// This event carries the axis value of the wl_pointer.axis event in
-// discrete steps (e.g. mouse wheel clicks).
-//
-// This event is deprecated with wl_pointer 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
-// wl_pointer.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 wl_pointer.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 wl_pointer.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 wl_pointer.axis_discrete and wl_pointer.axis_source is
-// not guaranteed.
-type PointerAxisDiscreteEvent struct {
-	Axis     uint32
-	Discrete int32
-}
-type PointerAxisDiscreteHandlerFunc func(PointerAxisDiscreteEvent)
-
-// SetAxisDiscreteHandler : sets handler for PointerAxisDiscreteEvent
-func (i *Pointer) SetAxisDiscreteHandler(f PointerAxisDiscreteHandlerFunc) {
-	i.axisDiscreteHandler = f
-}
-
-// PointerAxisValue120Event : 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 wl_pointer.axis_discrete event in clients
-// supporting wl_pointer version 8 or later.
-//
-// Where a wl_pointer.axis_source event occurs in the same
-// wl_pointer.frame, the axis source applies to this event.
-//
-// The order of wl_pointer.axis_value120 and wl_pointer.axis_source is
-// not guaranteed.
-type PointerAxisValue120Event struct {
-	Axis     uint32
-	Value120 int32
-}
-type PointerAxisValue120HandlerFunc func(PointerAxisValue120Event)
-
-// SetAxisValue120Handler : sets handler for PointerAxisValue120Event
-func (i *Pointer) SetAxisValue120Handler(f PointerAxisValue120HandlerFunc) {
-	i.axisValue120Handler = f
-}
-
-// PointerAxisRelativeDirectionEvent : axis relative physical direction event
-//
-// Relative directional information of the entity causing the axis
-// motion.
-//
-// For a wl_pointer.axis event, the wl_pointer.axis_relative_direction
-// event specifies the movement direction of the entity causing the
-// wl_pointer.axis event. For example:
-// - if a user's fingers on a touchpad move down and this
-// causes a wl_pointer.axis vertical_scroll down event, the physical
-// direction is 'identical'
-// - if a user's fingers on a touchpad move down and this causes a
-// wl_pointer.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
-// wl_pointer.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 wl_pointer.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 wl_pointer.axis_relative_direction,
-// wl_pointer.axis_discrete and wl_pointer.axis_source is not
-// guaranteed.
-type PointerAxisRelativeDirectionEvent struct {
-	Axis      uint32
-	Direction uint32
-}
-type PointerAxisRelativeDirectionHandlerFunc func(PointerAxisRelativeDirectionEvent)
-
-// SetAxisRelativeDirectionHandler : sets handler for PointerAxisRelativeDirectionEvent
-func (i *Pointer) SetAxisRelativeDirectionHandler(f PointerAxisRelativeDirectionHandlerFunc) {
-	i.axisRelativeDirectionHandler = f
-}
-
-func (i *Pointer) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.enterHandler == nil {
-			return
-		}
-		var e PointerEnterEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Surface = i.Context().GetProxy(Uint32(data[l : l+4])).(*Surface)
-		l += 4
-		e.SurfaceX = Fixed(data[l : l+4])
-		l += 4
-		e.SurfaceY = Fixed(data[l : l+4])
-		l += 4
-
-		i.enterHandler(e)
-	case 1:
-		if i.leaveHandler == nil {
-			return
-		}
-		var e PointerLeaveEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Surface = i.Context().GetProxy(Uint32(data[l : l+4])).(*Surface)
-		l += 4
-
-		i.leaveHandler(e)
-	case 2:
-		if i.motionHandler == nil {
-			return
-		}
-		var e PointerMotionEvent
-		l := 0
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.SurfaceX = Fixed(data[l : l+4])
-		l += 4
-		e.SurfaceY = Fixed(data[l : l+4])
-		l += 4
-
-		i.motionHandler(e)
-	case 3:
-		if i.buttonHandler == nil {
-			return
-		}
-		var e PointerButtonEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Button = Uint32(data[l : l+4])
-		l += 4
-		e.State = Uint32(data[l : l+4])
-		l += 4
-
-		i.buttonHandler(e)
-	case 4:
-		if i.axisHandler == nil {
-			return
-		}
-		var e PointerAxisEvent
-		l := 0
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Axis = Uint32(data[l : l+4])
-		l += 4
-		e.Value = Fixed(data[l : l+4])
-		l += 4
-
-		i.axisHandler(e)
-	case 5:
-		if i.frameHandler == nil {
-			return
-		}
-		var e PointerFrameEvent
-
-		i.frameHandler(e)
-	case 6:
-		if i.axisSourceHandler == nil {
-			return
-		}
-		var e PointerAxisSourceEvent
-		l := 0
-		e.AxisSource = Uint32(data[l : l+4])
-		l += 4
-
-		i.axisSourceHandler(e)
-	case 7:
-		if i.axisStopHandler == nil {
-			return
-		}
-		var e PointerAxisStopEvent
-		l := 0
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Axis = Uint32(data[l : l+4])
-		l += 4
-
-		i.axisStopHandler(e)
-	case 8:
-		if i.axisDiscreteHandler == nil {
-			return
-		}
-		var e PointerAxisDiscreteEvent
-		l := 0
-		e.Axis = Uint32(data[l : l+4])
-		l += 4
-		e.Discrete = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.axisDiscreteHandler(e)
-	case 9:
-		if i.axisValue120Handler == nil {
-			return
-		}
-		var e PointerAxisValue120Event
-		l := 0
-		e.Axis = Uint32(data[l : l+4])
-		l += 4
-		e.Value120 = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.axisValue120Handler(e)
-	case 10:
-		if i.axisRelativeDirectionHandler == nil {
-			return
-		}
-		var e PointerAxisRelativeDirectionEvent
-		l := 0
-		e.Axis = Uint32(data[l : l+4])
-		l += 4
-		e.Direction = Uint32(data[l : l+4])
-		l += 4
-
-		i.axisRelativeDirectionHandler(e)
-	}
-}
-
-// KeyboardInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const KeyboardInterfaceName = "wl_keyboard"
-
-// Keyboard : keyboard input device
-//
-// The wl_keyboard interface represents one or more keyboards
-// associated with a seat.
-//
-// Each wl_keyboard 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.
-type Keyboard struct {
-	BaseProxy
-	keymapHandler     KeyboardKeymapHandlerFunc
-	enterHandler      KeyboardEnterHandlerFunc
-	leaveHandler      KeyboardLeaveHandlerFunc
-	keyHandler        KeyboardKeyHandlerFunc
-	modifiersHandler  KeyboardModifiersHandlerFunc
-	repeatInfoHandler KeyboardRepeatInfoHandlerFunc
-}
-
-// NewKeyboard : keyboard input device
-//
-// The wl_keyboard interface represents one or more keyboards
-// associated with a seat.
-//
-// Each wl_keyboard 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.
-func NewKeyboard(ctx *Context) *Keyboard {
-	wlKeyboard := &Keyboard{}
-	ctx.Register(wlKeyboard)
-	return wlKeyboard
-}
-
-// Release : release the keyboard object
-func (i *Keyboard) Release() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type KeyboardKeymapFormat uint32
-
-// KeyboardKeymapFormat : keyboard mapping format
-//
-// This specifies the format of the keymap provided to the
-// client with the wl_keyboard.keymap event.
-const (
-	// KeyboardKeymapFormatNoKeymap : no keymap; client must understand how to interpret the raw keycode
-	KeyboardKeymapFormatNoKeymap KeyboardKeymapFormat = 0
-	// KeyboardKeymapFormatXkbV1 : libxkbcommon compatible, null-terminated string; to determine the xkb keycode, clients must add 8 to the key event keycode
-	KeyboardKeymapFormatXkbV1 KeyboardKeymapFormat = 1
-)
-
-func (e KeyboardKeymapFormat) Name() string {
-	switch e {
-	case KeyboardKeymapFormatNoKeymap:
-		return "no_keymap"
-	case KeyboardKeymapFormatXkbV1:
-		return "xkb_v1"
-	default:
-		return ""
-	}
-}
-
-func (e KeyboardKeymapFormat) Value() string {
-	switch e {
-	case KeyboardKeymapFormatNoKeymap:
-		return "0"
-	case KeyboardKeymapFormatXkbV1:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e KeyboardKeymapFormat) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type KeyboardKeyState uint32
-
-// KeyboardKeyState : physical key state
-//
-// Describes the physical state of a key that produced the key event.
-//
-// Since version 10, the key can be in a "repeated" pseudo-state which
-// means the same as "pressed", but is used to signal repetition in the
-// key event.
-//
-// The key may only enter the repeated state after entering the pressed
-// state and before entering the released state. This event may be
-// generated multiple times while the key is down.
-const (
-	// KeyboardKeyStateReleased : key is not pressed
-	KeyboardKeyStateReleased KeyboardKeyState = 0
-	// KeyboardKeyStatePressed : key is pressed
-	KeyboardKeyStatePressed KeyboardKeyState = 1
-	// KeyboardKeyStateRepeated : key was repeated
-	KeyboardKeyStateRepeated KeyboardKeyState = 2
-)
-
-func (e KeyboardKeyState) Name() string {
-	switch e {
-	case KeyboardKeyStateReleased:
-		return "released"
-	case KeyboardKeyStatePressed:
-		return "pressed"
-	case KeyboardKeyStateRepeated:
-		return "repeated"
-	default:
-		return ""
-	}
-}
-
-func (e KeyboardKeyState) Value() string {
-	switch e {
-	case KeyboardKeyStateReleased:
-		return "0"
-	case KeyboardKeyStatePressed:
-		return "1"
-	case KeyboardKeyStateRepeated:
-		return "2"
-	default:
-		return ""
-	}
-}
-
-func (e KeyboardKeyState) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// KeyboardKeymapEvent : 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.
-type KeyboardKeymapEvent struct {
-	Format uint32
-	Fd     int
-	Size   uint32
-}
-type KeyboardKeymapHandlerFunc func(KeyboardKeymapEvent)
-
-// SetKeymapHandler : sets handler for KeyboardKeymapEvent
-func (i *Keyboard) SetKeymapHandler(f KeyboardKeymapHandlerFunc) {
-	i.keymapHandler = f
-}
-
-// KeyboardEnterEvent : enter event
-//
-// Notification that this seat's keyboard focus is on a certain
-// surface.
-//
-// The compositor must send the wl_keyboard.modifiers event after this
-// event.
-//
-// In the wl_keyboard 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
-// wl_keyboard 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.
-type KeyboardEnterEvent struct {
-	Serial  uint32
-	Surface *Surface
-	Keys    []byte
-}
-type KeyboardEnterHandlerFunc func(KeyboardEnterEvent)
-
-// SetEnterHandler : sets handler for KeyboardEnterEvent
-func (i *Keyboard) SetEnterHandler(f KeyboardEnterHandlerFunc) {
-	i.enterHandler = f
-}
-
-// KeyboardLeaveEvent : 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 wl_keyboard logical state, this event resets all values to their
-// defaults. The compositor must not send this event if the active surface
-// of the wl_keyboard was not equal to the surface argument immediately
-// before this event.
-type KeyboardLeaveEvent struct {
-	Serial  uint32
-	Surface *Surface
-}
-type KeyboardLeaveHandlerFunc func(KeyboardLeaveEvent)
-
-// SetLeaveHandler : sets handler for KeyboardLeaveEvent
-func (i *Keyboard) SetLeaveHandler(f KeyboardLeaveHandlerFunc) {
-	i.leaveHandler = f
-}
-
-// KeyboardKeyEvent : 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
-// wl_keyboard.modifiers event must be sent after this event.
-//
-// In the wl_keyboard 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 wl_keyboard
-// 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 wl_keyboard.repeat_info event with a rate argument of
-// 0 has been received. This allows the compositor to take over the
-// responsibility of key repetition.
-type KeyboardKeyEvent struct {
-	Serial uint32
-	Time   uint32
-	Key    uint32
-	State  uint32
-}
-type KeyboardKeyHandlerFunc func(KeyboardKeyEvent)
-
-// SetKeyHandler : sets handler for KeyboardKeyEvent
-func (i *Keyboard) SetKeyHandler(f KeyboardKeyHandlerFunc) {
-	i.keyHandler = f
-}
-
-// KeyboardModifiersEvent : 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 wl_keyboard.modifiers event. In order to
-// reset the modifier state again, the compositor can send a
-// wl_keyboard.modifiers event with no pressed modifiers.
-//
-// In the wl_keyboard logical state, this event updates the modifiers and
-// group.
-type KeyboardModifiersEvent struct {
-	Serial        uint32
-	ModsDepressed uint32
-	ModsLatched   uint32
-	ModsLocked    uint32
-	Group         uint32
-}
-type KeyboardModifiersHandlerFunc func(KeyboardModifiersEvent)
-
-// SetModifiersHandler : sets handler for KeyboardModifiersEvent
-func (i *Keyboard) SetModifiersHandler(f KeyboardModifiersHandlerFunc) {
-	i.modifiersHandler = f
-}
-
-// KeyboardRepeatInfoEvent : repeat rate and delay
-//
-// Informs the client about the keyboard's repeat rate and delay.
-//
-// This event is sent as soon as the wl_keyboard 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 wl_keyboard.
-type KeyboardRepeatInfoEvent struct {
-	Rate  int32
-	Delay int32
-}
-type KeyboardRepeatInfoHandlerFunc func(KeyboardRepeatInfoEvent)
-
-// SetRepeatInfoHandler : sets handler for KeyboardRepeatInfoEvent
-func (i *Keyboard) SetRepeatInfoHandler(f KeyboardRepeatInfoHandlerFunc) {
-	i.repeatInfoHandler = f
-}
-
-func (i *Keyboard) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.keymapHandler == nil {
-			if fd != -1 {
-				unix.Close(fd)
-			}
-			return
-		}
-		var e KeyboardKeymapEvent
-		l := 0
-		e.Format = Uint32(data[l : l+4])
-		l += 4
-		e.Fd = fd
-		e.Size = Uint32(data[l : l+4])
-		l += 4
-
-		i.keymapHandler(e)
-	case 1:
-		if i.enterHandler == nil {
-			return
-		}
-		var e KeyboardEnterEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Surface = i.Context().GetProxy(Uint32(data[l : l+4])).(*Surface)
-		l += 4
-		keysLen := int(Uint32(data[l : l+4]))
-		l += 4
-		e.Keys = make([]byte, keysLen)
-		copy(e.Keys, data[l:l+keysLen])
-		l += keysLen
-
-		i.enterHandler(e)
-	case 2:
-		if i.leaveHandler == nil {
-			return
-		}
-		var e KeyboardLeaveEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Surface = i.Context().GetProxy(Uint32(data[l : l+4])).(*Surface)
-		l += 4
-
-		i.leaveHandler(e)
-	case 3:
-		if i.keyHandler == nil {
-			return
-		}
-		var e KeyboardKeyEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Key = Uint32(data[l : l+4])
-		l += 4
-		e.State = Uint32(data[l : l+4])
-		l += 4
-
-		i.keyHandler(e)
-	case 4:
-		if i.modifiersHandler == nil {
-			return
-		}
-		var e KeyboardModifiersEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.ModsDepressed = Uint32(data[l : l+4])
-		l += 4
-		e.ModsLatched = Uint32(data[l : l+4])
-		l += 4
-		e.ModsLocked = Uint32(data[l : l+4])
-		l += 4
-		e.Group = Uint32(data[l : l+4])
-		l += 4
-
-		i.modifiersHandler(e)
-	case 5:
-		if i.repeatInfoHandler == nil {
-			return
-		}
-		var e KeyboardRepeatInfoEvent
-		l := 0
-		e.Rate = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Delay = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.repeatInfoHandler(e)
-	}
-}
-
-// TouchInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const TouchInterfaceName = "wl_touch"
-
-// Touch : touchscreen input device
-//
-// The wl_touch 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.
-type Touch struct {
-	BaseProxy
-	downHandler        TouchDownHandlerFunc
-	upHandler          TouchUpHandlerFunc
-	motionHandler      TouchMotionHandlerFunc
-	frameHandler       TouchFrameHandlerFunc
-	cancelHandler      TouchCancelHandlerFunc
-	shapeHandler       TouchShapeHandlerFunc
-	orientationHandler TouchOrientationHandlerFunc
-}
-
-// NewTouch : touchscreen input device
-//
-// The wl_touch 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.
-func NewTouch(ctx *Context) *Touch {
-	wlTouch := &Touch{}
-	ctx.Register(wlTouch)
-	return wlTouch
-}
-
-// Release : release the touch object
-func (i *Touch) Release() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// TouchDownEvent : 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.
-type TouchDownEvent struct {
-	Serial  uint32
-	Time    uint32
-	Surface *Surface
-	Id      int32
-	X       float64
-	Y       float64
-}
-type TouchDownHandlerFunc func(TouchDownEvent)
-
-// SetDownHandler : sets handler for TouchDownEvent
-func (i *Touch) SetDownHandler(f TouchDownHandlerFunc) {
-	i.downHandler = f
-}
-
-// TouchUpEvent : 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.
-type TouchUpEvent struct {
-	Serial uint32
-	Time   uint32
-	Id     int32
-}
-type TouchUpHandlerFunc func(TouchUpEvent)
-
-// SetUpHandler : sets handler for TouchUpEvent
-func (i *Touch) SetUpHandler(f TouchUpHandlerFunc) {
-	i.upHandler = f
-}
-
-// TouchMotionEvent : update of touch point coordinates
-//
-// A touch point has changed coordinates.
-type TouchMotionEvent struct {
-	Time uint32
-	Id   int32
-	X    float64
-	Y    float64
-}
-type TouchMotionHandlerFunc func(TouchMotionEvent)
-
-// SetMotionHandler : sets handler for TouchMotionEvent
-func (i *Touch) SetMotionHandler(f TouchMotionHandlerFunc) {
-	i.motionHandler = f
-}
-
-// TouchFrameEvent : 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 wl_touch.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.
-type TouchFrameEvent struct{}
-type TouchFrameHandlerFunc func(TouchFrameEvent)
-
-// SetFrameHandler : sets handler for TouchFrameEvent
-func (i *Touch) SetFrameHandler(f TouchFrameHandlerFunc) {
-	i.frameHandler = f
-}
-
-// TouchCancelEvent : 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.
-type TouchCancelEvent struct{}
-type TouchCancelHandlerFunc func(TouchCancelEvent)
-
-// SetCancelHandler : sets handler for TouchCancelEvent
-func (i *Touch) SetCancelHandler(f TouchCancelHandlerFunc) {
-	i.cancelHandler = f
-}
-
-// TouchShapeEvent : 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
-// wl_touch.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 wl_touch.down,
-// wl_touch.motion or wl_touch.orientation may be sent within the
-// same wl_touch.frame. A client should treat these events as a single
-// logical touch point update. The order of wl_touch.shape,
-// wl_touch.orientation and wl_touch.motion is not guaranteed.
-// A wl_touch.down event is guaranteed to occur before the first
-// wl_touch.shape event for this touch ID but both events may occur within
-// the same wl_touch.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 wl_touch.down or wl_touch.move.
-//
-// 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.
-type TouchShapeEvent struct {
-	Id    int32
-	Major float64
-	Minor float64
-}
-type TouchShapeHandlerFunc func(TouchShapeEvent)
-
-// SetShapeHandler : sets handler for TouchShapeEvent
-func (i *Touch) SetShapeHandler(f TouchShapeHandlerFunc) {
-	i.shapeHandler = f
-}
-
-// TouchOrientationEvent : 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
-// wl_touch.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 wl_touch.down,
-// wl_touch.motion or wl_touch.shape may be sent within the
-// same wl_touch.frame. A client should treat these events as a single
-// logical touch point update. The order of wl_touch.shape,
-// wl_touch.orientation and wl_touch.motion is not guaranteed.
-// A wl_touch.down event is guaranteed to occur before the first
-// wl_touch.orientation event for this touch ID but both events may occur
-// within the same wl_touch.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.
-type TouchOrientationEvent struct {
-	Id          int32
-	Orientation float64
-}
-type TouchOrientationHandlerFunc func(TouchOrientationEvent)
-
-// SetOrientationHandler : sets handler for TouchOrientationEvent
-func (i *Touch) SetOrientationHandler(f TouchOrientationHandlerFunc) {
-	i.orientationHandler = f
-}
-
-func (i *Touch) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.downHandler == nil {
-			return
-		}
-		var e TouchDownEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Surface = i.Context().GetProxy(Uint32(data[l : l+4])).(*Surface)
-		l += 4
-		e.Id = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.X = Fixed(data[l : l+4])
-		l += 4
-		e.Y = Fixed(data[l : l+4])
-		l += 4
-
-		i.downHandler(e)
-	case 1:
-		if i.upHandler == nil {
-			return
-		}
-		var e TouchUpEvent
-		l := 0
-		e.Serial = Uint32(data[l : l+4])
-		l += 4
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Id = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.upHandler(e)
-	case 2:
-		if i.motionHandler == nil {
-			return
-		}
-		var e TouchMotionEvent
-		l := 0
-		e.Time = Uint32(data[l : l+4])
-		l += 4
-		e.Id = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.X = Fixed(data[l : l+4])
-		l += 4
-		e.Y = Fixed(data[l : l+4])
-		l += 4
-
-		i.motionHandler(e)
-	case 3:
-		if i.frameHandler == nil {
-			return
-		}
-		var e TouchFrameEvent
-
-		i.frameHandler(e)
-	case 4:
-		if i.cancelHandler == nil {
-			return
-		}
-		var e TouchCancelEvent
-
-		i.cancelHandler(e)
-	case 5:
-		if i.shapeHandler == nil {
-			return
-		}
-		var e TouchShapeEvent
-		l := 0
-		e.Id = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Major = Fixed(data[l : l+4])
-		l += 4
-		e.Minor = Fixed(data[l : l+4])
-		l += 4
-
-		i.shapeHandler(e)
-	case 6:
-		if i.orientationHandler == nil {
-			return
-		}
-		var e TouchOrientationEvent
-		l := 0
-		e.Id = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Orientation = Fixed(data[l : l+4])
-		l += 4
-
-		i.orientationHandler(e)
-	}
-}
-
-// OutputInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const OutputInterfaceName = "wl_output"
-
-// Output : 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.
-type Output struct {
-	BaseProxy
-	geometryHandler    OutputGeometryHandlerFunc
-	modeHandler        OutputModeHandlerFunc
-	doneHandler        OutputDoneHandlerFunc
-	scaleHandler       OutputScaleHandlerFunc
-	nameHandler        OutputNameHandlerFunc
-	descriptionHandler OutputDescriptionHandlerFunc
-}
-
-// NewOutput : 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.
-func NewOutput(ctx *Context) *Output {
-	wlOutput := &Output{}
-	ctx.Register(wlOutput)
-	return wlOutput
-}
-
-// Release : release the output object
-//
-// Using this request a client can tell the server that it is not going to
-// use the output object anymore.
-func (i *Output) Release() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type OutputSubpixel uint32
-
-// OutputSubpixel : subpixel geometry information
-//
-// This enumeration describes how the physical
-// pixels on an output are laid out.
-const (
-	// OutputSubpixelUnknown : unknown geometry
-	OutputSubpixelUnknown OutputSubpixel = 0
-	// OutputSubpixelNone : no geometry
-	OutputSubpixelNone OutputSubpixel = 1
-	// OutputSubpixelHorizontalRgb : horizontal RGB
-	OutputSubpixelHorizontalRgb OutputSubpixel = 2
-	// OutputSubpixelHorizontalBgr : horizontal BGR
-	OutputSubpixelHorizontalBgr OutputSubpixel = 3
-	// OutputSubpixelVerticalRgb : vertical RGB
-	OutputSubpixelVerticalRgb OutputSubpixel = 4
-	// OutputSubpixelVerticalBgr : vertical BGR
-	OutputSubpixelVerticalBgr OutputSubpixel = 5
-)
-
-func (e OutputSubpixel) Name() string {
-	switch e {
-	case OutputSubpixelUnknown:
-		return "unknown"
-	case OutputSubpixelNone:
-		return "none"
-	case OutputSubpixelHorizontalRgb:
-		return "horizontal_rgb"
-	case OutputSubpixelHorizontalBgr:
-		return "horizontal_bgr"
-	case OutputSubpixelVerticalRgb:
-		return "vertical_rgb"
-	case OutputSubpixelVerticalBgr:
-		return "vertical_bgr"
-	default:
-		return ""
-	}
-}
-
-func (e OutputSubpixel) Value() string {
-	switch e {
-	case OutputSubpixelUnknown:
-		return "0"
-	case OutputSubpixelNone:
-		return "1"
-	case OutputSubpixelHorizontalRgb:
-		return "2"
-	case OutputSubpixelHorizontalBgr:
-		return "3"
-	case OutputSubpixelVerticalRgb:
-		return "4"
-	case OutputSubpixelVerticalBgr:
-		return "5"
-	default:
-		return ""
-	}
-}
-
-func (e OutputSubpixel) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type OutputTransform uint32
-
-// OutputTransform : transformation applied to buffer contents
-//
-// This describes transformations that clients and compositors apply to
-// buffer contents.
-//
-// The flipped values correspond to an initial flip around a
-// vertical axis followed by rotation.
-//
-// The purpose is mainly to allow clients to render accordingly and
-// tell the compositor, so that for fullscreen surfaces, the
-// compositor will still be able to scan out directly from client
-// surfaces.
-const (
-	// OutputTransformNormal : no transform
-	OutputTransformNormal OutputTransform = 0
-	// OutputTransform90 : 90 degrees counter-clockwise
-	OutputTransform90 OutputTransform = 1
-	// OutputTransform180 : 180 degrees counter-clockwise
-	OutputTransform180 OutputTransform = 2
-	// OutputTransform270 : 270 degrees counter-clockwise
-	OutputTransform270 OutputTransform = 3
-	// OutputTransformFlipped : 180 degree flip around a vertical axis
-	OutputTransformFlipped OutputTransform = 4
-	// OutputTransformFlipped90 : flip and rotate 90 degrees counter-clockwise
-	OutputTransformFlipped90 OutputTransform = 5
-	// OutputTransformFlipped180 : flip and rotate 180 degrees counter-clockwise
-	OutputTransformFlipped180 OutputTransform = 6
-	// OutputTransformFlipped270 : flip and rotate 270 degrees counter-clockwise
-	OutputTransformFlipped270 OutputTransform = 7
-)
-
-func (e OutputTransform) Name() string {
-	switch e {
-	case OutputTransformNormal:
-		return "normal"
-	case OutputTransform90:
-		return "90"
-	case OutputTransform180:
-		return "180"
-	case OutputTransform270:
-		return "270"
-	case OutputTransformFlipped:
-		return "flipped"
-	case OutputTransformFlipped90:
-		return "flipped_90"
-	case OutputTransformFlipped180:
-		return "flipped_180"
-	case OutputTransformFlipped270:
-		return "flipped_270"
-	default:
-		return ""
-	}
-}
-
-func (e OutputTransform) Value() string {
-	switch e {
-	case OutputTransformNormal:
-		return "0"
-	case OutputTransform90:
-		return "1"
-	case OutputTransform180:
-		return "2"
-	case OutputTransform270:
-		return "3"
-	case OutputTransformFlipped:
-		return "4"
-	case OutputTransformFlipped90:
-		return "5"
-	case OutputTransformFlipped180:
-		return "6"
-	case OutputTransformFlipped270:
-		return "7"
-	default:
-		return ""
-	}
-}
-
-func (e OutputTransform) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-type OutputMode uint32
-
-// OutputMode : mode information
-//
-// These flags describe properties of an output mode.
-// They are used in the flags bitfield of the mode event.
-const (
-	// OutputModeCurrent : indicates this is the current mode
-	OutputModeCurrent OutputMode = 0x1
-	// OutputModePreferred : indicates this is the preferred mode
-	OutputModePreferred OutputMode = 0x2
-)
-
-func (e OutputMode) Name() string {
-	switch e {
-	case OutputModeCurrent:
-		return "current"
-	case OutputModePreferred:
-		return "preferred"
-	default:
-		return ""
-	}
-}
-
-func (e OutputMode) Value() string {
-	switch e {
-	case OutputModeCurrent:
-		return "0x1"
-	case OutputModePreferred:
-		return "0x2"
-	default:
-		return ""
-	}
-}
-
-func (e OutputMode) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// OutputGeometryEvent : 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 wl_surface.preferred_buffer_transform instead of the
-// transform advertised by this event to find the preferred buffer
-// transform to use for a surface.
-//
-// Note: wl_output 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.
-type OutputGeometryEvent struct {
-	X              int32
-	Y              int32
-	PhysicalWidth  int32
-	PhysicalHeight int32
-	Subpixel       int32
-	Make           string
-	Model          string
-	Transform      int32
-}
-type OutputGeometryHandlerFunc func(OutputGeometryEvent)
-
-// SetGeometryHandler : sets handler for OutputGeometryEvent
-func (i *Output) SetGeometryHandler(f OutputGeometryHandlerFunc) {
-	i.geometryHandler = f
-}
-
-// OutputModeEvent : 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 wl_output.scale,
-// or transformed, as described in wl_output.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 wl_surface.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.
-type OutputModeEvent struct {
-	Flags   uint32
-	Width   int32
-	Height  int32
-	Refresh int32
-}
-type OutputModeHandlerFunc func(OutputModeEvent)
-
-// SetModeHandler : sets handler for OutputModeEvent
-func (i *Output) SetModeHandler(f OutputModeHandlerFunc) {
-	i.modeHandler = f
-}
-
-// OutputDoneEvent : 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.
-type OutputDoneEvent struct{}
-type OutputDoneHandlerFunc func(OutputDoneEvent)
-
-// SetDoneHandler : sets handler for OutputDoneEvent
-func (i *Output) SetDoneHandler(f OutputDoneHandlerFunc) {
-	i.doneHandler = f
-}
-
-// OutputScaleEvent : 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 wl_surface.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.
-type OutputScaleEvent struct {
-	Factor int32
-}
-type OutputScaleHandlerFunc func(OutputScaleEvent)
-
-// SetScaleHandler : sets handler for OutputScaleEvent
-func (i *Output) SetScaleHandler(f OutputScaleHandlerFunc) {
-	i.scaleHandler = f
-}
-
-// OutputNameEvent : 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 wl_output 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 wl_output
-// global. Thus, the name can be shared across processes to refer to a
-// specific wl_output 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 wl_output global.
-//
-// Compositors may re-use the same output name if the wl_output 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.
-type OutputNameEvent struct {
-	Name string
-}
-type OutputNameHandlerFunc func(OutputNameEvent)
-
-// SetNameHandler : sets handler for OutputNameEvent
-func (i *Output) SetNameHandler(f OutputNameHandlerFunc) {
-	i.nameHandler = f
-}
-
-// OutputDescriptionEvent : 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
-// wl_output 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.
-type OutputDescriptionEvent struct {
-	Description string
-}
-type OutputDescriptionHandlerFunc func(OutputDescriptionEvent)
-
-// SetDescriptionHandler : sets handler for OutputDescriptionEvent
-func (i *Output) SetDescriptionHandler(f OutputDescriptionHandlerFunc) {
-	i.descriptionHandler = f
-}
-
-func (i *Output) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.geometryHandler == nil {
-			return
-		}
-		var e OutputGeometryEvent
-		l := 0
-		e.X = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Y = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.PhysicalWidth = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.PhysicalHeight = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Subpixel = int32(Uint32(data[l : l+4]))
-		l += 4
-		makeLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Make = String(data[l : l+makeLen])
-		l += makeLen
-		modelLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Model = String(data[l : l+modelLen])
-		l += modelLen
-		e.Transform = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.geometryHandler(e)
-	case 1:
-		if i.modeHandler == nil {
-			return
-		}
-		var e OutputModeEvent
-		l := 0
-		e.Flags = Uint32(data[l : l+4])
-		l += 4
-		e.Width = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Height = int32(Uint32(data[l : l+4]))
-		l += 4
-		e.Refresh = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.modeHandler(e)
-	case 2:
-		if i.doneHandler == nil {
-			return
-		}
-		var e OutputDoneEvent
-
-		i.doneHandler(e)
-	case 3:
-		if i.scaleHandler == nil {
-			return
-		}
-		var e OutputScaleEvent
-		l := 0
-		e.Factor = int32(Uint32(data[l : l+4]))
-		l += 4
-
-		i.scaleHandler(e)
-	case 4:
-		if i.nameHandler == nil {
-			return
-		}
-		var e OutputNameEvent
-		l := 0
-		nameLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Name = String(data[l : l+nameLen])
-		l += nameLen
-
-		i.nameHandler(e)
-	case 5:
-		if i.descriptionHandler == nil {
-			return
-		}
-		var e OutputDescriptionEvent
-		l := 0
-		descriptionLen := PaddedLen(int(Uint32(data[l : l+4])))
-		l += 4
-		e.Description = String(data[l : l+descriptionLen])
-		l += descriptionLen
-
-		i.descriptionHandler(e)
-	}
-}
-
-// RegionInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const RegionInterfaceName = "wl_region"
-
-// Region : region interface
-//
-// A region object describes an area.
-//
-// Region objects are used to describe the opaque and input
-// regions of a surface.
-type Region struct {
-	BaseProxy
-}
-
-// NewRegion : region interface
-//
-// A region object describes an area.
-//
-// Region objects are used to describe the opaque and input
-// regions of a surface.
-func NewRegion(ctx *Context) *Region {
-	wlRegion := &Region{}
-	ctx.Register(wlRegion)
-	return wlRegion
-}
-
-// Destroy : destroy region
-//
-// Destroy the region.  This will invalidate the object ID.
-func (i *Region) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Add : add rectangle to region
-//
-// Add the specified rectangle to the region.
-//
-//	x: region-local x coordinate
-//	y: region-local y coordinate
-//	width: rectangle width
-//	height: rectangle height
-func (i *Region) Add(x, y, width, height int32) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(width))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(height))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Subtract : subtract rectangle from region
-//
-// Subtract the specified rectangle from the region.
-//
-//	x: region-local x coordinate
-//	y: region-local y coordinate
-//	width: rectangle width
-//	height: rectangle height
-func (i *Region) Subtract(x, y, width, height int32) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(width))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(height))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SubcompositorInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const SubcompositorInterfaceName = "wl_subcompositor"
-
-// Subcompositor : sub-surface compositing
-//
-// The global interface exposing sub-surface compositing capabilities.
-// A wl_surface, 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 wl_surface 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 wl_surface
-// objects. This should allow the compositor to pass YUV video buffer
-// processing to dedicated overlay hardware when possible.
-type Subcompositor struct {
-	BaseProxy
-}
-
-// NewSubcompositor : sub-surface compositing
-//
-// The global interface exposing sub-surface compositing capabilities.
-// A wl_surface, 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 wl_surface 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 wl_surface
-// objects. This should allow the compositor to pass YUV video buffer
-// processing to dedicated overlay hardware when possible.
-func NewSubcompositor(ctx *Context) *Subcompositor {
-	wlSubcompositor := &Subcompositor{}
-	ctx.Register(wlSubcompositor)
-	return wlSubcompositor
-}
-
-// Destroy : 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, wl_subsurface objects included.
-func (i *Subcompositor) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// GetSubsurface : 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 wl_surface into a sub-surface.
-//
-// The to-be sub-surface must not already have another role, and it
-// must not have an existing wl_subsurface object. Otherwise the
-// bad_surface protocol error is raised.
-//
-// Adding sub-surfaces to a parent is a double-buffered operation on the
-// parent (see wl_surface.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 wl_surface.commit request on
-// the sub-surface, see the documentation on wl_subsurface interface.
-//
-//	surface: the surface to be turned into a sub-surface
-//	parent: the parent surface
-func (i *Subcompositor) GetSubsurface(surface, parent *Surface) (*Subsurface, error) {
-	id := NewSubsurface(i.Context())
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], surface.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], parent.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-type SubcompositorError uint32
-
-// SubcompositorError :
-const (
-	// SubcompositorErrorBadSurface : the to-be sub-surface is invalid
-	SubcompositorErrorBadSurface SubcompositorError = 0
-	// SubcompositorErrorBadParent : the to-be sub-surface parent is invalid
-	SubcompositorErrorBadParent SubcompositorError = 1
-)
-
-func (e SubcompositorError) Name() string {
-	switch e {
-	case SubcompositorErrorBadSurface:
-		return "bad_surface"
-	case SubcompositorErrorBadParent:
-		return "bad_parent"
-	default:
-		return ""
-	}
-}
-
-func (e SubcompositorError) Value() string {
-	switch e {
-	case SubcompositorErrorBadSurface:
-		return "0"
-	case SubcompositorErrorBadParent:
-		return "1"
-	default:
-		return ""
-	}
-}
-
-func (e SubcompositorError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// SubsurfaceInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const SubsurfaceInterfaceName = "wl_subsurface"
-
-// Subsurface : sub-surface interface to a wl_surface
-//
-// An additional interface to a wl_surface 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 wl_buffer 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 wl_buffer is applied. These rules apply
-// recursively through the tree of surfaces.
-//
-// The behaviour of a wl_surface.commit request on a sub-surface
-// depends on the sub-surface's mode. The possible modes are
-// synchronized and desynchronized, see methods
-// wl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized
-// mode caches the wl_surface state to be applied when the parent's
-// state gets applied, and desynchronized mode applies the pending
-// wl_surface state directly. A sub-surface is initially in the
-// synchronized mode.
-//
-// Sub-surfaces also have another kind of state, which is managed by
-// wl_subsurface requests, as opposed to wl_surface requests. This
-// state includes the sub-surface position relative to the parent
-// surface (wl_subsurface.set_position), and the stacking order of
-// the parent and its sub-surfaces (wl_subsurface.place_above and
-// .place_below). This state is applied when the parent surface's
-// wl_surface state is applied, regardless of the sub-surface's mode.
-// As the exception, set_sync and set_desync are effective immediately.
-//
-// The main surface can be thought to be always in desynchronized mode,
-// since it does not have a parent in the sub-surfaces sense.
-//
-// Even if a sub-surface is in desynchronized mode, it will behave as
-// in synchronized mode, if its parent surface behaves as in
-// synchronized mode. This rule is applied recursively throughout the
-// tree of surfaces. This means, that one can set a sub-surface into
-// synchronized mode, and then assume that all its child and grand-child
-// sub-surfaces are synchronized, too, without explicitly setting them.
-//
-// Destroying a sub-surface takes effect immediately. If you need to
-// synchronize the removal of a sub-surface to the parent surface update,
-// unmap the sub-surface first by attaching a NULL wl_buffer, update parent,
-// and then destroy the sub-surface.
-//
-// If the parent wl_surface object is destroyed, the sub-surface is
-// unmapped.
-//
-// A sub-surface never has the keyboard focus of any seat.
-//
-// The wl_surface.offset request is ignored: clients must use set_position
-// instead to move the sub-surface.
-type Subsurface struct {
-	BaseProxy
-}
-
-// NewSubsurface : sub-surface interface to a wl_surface
-//
-// An additional interface to a wl_surface 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 wl_buffer 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 wl_buffer is applied. These rules apply
-// recursively through the tree of surfaces.
-//
-// The behaviour of a wl_surface.commit request on a sub-surface
-// depends on the sub-surface's mode. The possible modes are
-// synchronized and desynchronized, see methods
-// wl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized
-// mode caches the wl_surface state to be applied when the parent's
-// state gets applied, and desynchronized mode applies the pending
-// wl_surface state directly. A sub-surface is initially in the
-// synchronized mode.
-//
-// Sub-surfaces also have another kind of state, which is managed by
-// wl_subsurface requests, as opposed to wl_surface requests. This
-// state includes the sub-surface position relative to the parent
-// surface (wl_subsurface.set_position), and the stacking order of
-// the parent and its sub-surfaces (wl_subsurface.place_above and
-// .place_below). This state is applied when the parent surface's
-// wl_surface state is applied, regardless of the sub-surface's mode.
-// As the exception, set_sync and set_desync are effective immediately.
-//
-// The main surface can be thought to be always in desynchronized mode,
-// since it does not have a parent in the sub-surfaces sense.
-//
-// Even if a sub-surface is in desynchronized mode, it will behave as
-// in synchronized mode, if its parent surface behaves as in
-// synchronized mode. This rule is applied recursively throughout the
-// tree of surfaces. This means, that one can set a sub-surface into
-// synchronized mode, and then assume that all its child and grand-child
-// sub-surfaces are synchronized, too, without explicitly setting them.
-//
-// Destroying a sub-surface takes effect immediately. If you need to
-// synchronize the removal of a sub-surface to the parent surface update,
-// unmap the sub-surface first by attaching a NULL wl_buffer, update parent,
-// and then destroy the sub-surface.
-//
-// If the parent wl_surface object is destroyed, the sub-surface is
-// unmapped.
-//
-// A sub-surface never has the keyboard focus of any seat.
-//
-// The wl_surface.offset request is ignored: clients must use set_position
-// instead to move the sub-surface.
-func NewSubsurface(ctx *Context) *Subsurface {
-	wlSubsurface := &Subsurface{}
-	ctx.Register(wlSubsurface)
-	return wlSubsurface
-}
-
-// Destroy : remove sub-surface interface
-//
-// The sub-surface interface is removed from the wl_surface object
-// that was turned into a sub-surface with a
-// wl_subcompositor.get_subsurface request. The wl_surface's association
-// to the parent is deleted. The wl_surface is unmapped immediately.
-func (i *Subsurface) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetPosition : reposition the sub-surface
-//
-// This schedules a sub-surface position change.
-// The sub-surface will be moved so that its origin (top left
-// corner pixel) will be at the location x, y of the parent surface
-// coordinate system. The coordinates are not restricted to the parent
-// surface area. Negative values are allowed.
-//
-// The scheduled coordinates will take effect whenever the state of the
-// parent surface is applied.
-//
-// If more than one set_position request is invoked by the client before
-// the commit of the parent surface, the position of a new request always
-// replaces the scheduled position from any previous request.
-//
-// The initial position is 0, 0.
-//
-//	x: x coordinate in the parent surface
-//	y: y coordinate in the parent surface
-func (i *Subsurface) SetPosition(x, y int32) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(x))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(y))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// PlaceAbove : restack the sub-surface
-//
-// This sub-surface is taken from the stack, and put back just
-// above the reference surface, changing the z-order of the sub-surfaces.
-// The reference surface must be one of the sibling surfaces, or the
-// parent surface. Using any other surface, including this sub-surface,
-// will cause a protocol error.
-//
-// The z-order is double-buffered. Requests are handled in order and
-// applied immediately to a pending state. The final pending state is
-// copied to the active state the next time the state of the parent
-// surface is applied.
-//
-// A new sub-surface is initially added as the top-most in the stack
-// of its siblings and parent.
-//
-//	sibling: the reference surface
-func (i *Subsurface) PlaceAbove(sibling *Surface) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], sibling.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// PlaceBelow : restack the sub-surface
-//
-// The sub-surface is placed just below the reference surface.
-// See wl_subsurface.place_above.
-//
-//	sibling: the reference surface
-func (i *Subsurface) PlaceBelow(sibling *Surface) error {
-	const opcode = 3
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], sibling.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetSync : set sub-surface to synchronized mode
-//
-// Change the commit behaviour of the sub-surface to synchronized
-// mode, also described as the parent dependent mode.
-//
-// In synchronized mode, wl_surface.commit on a sub-surface will
-// accumulate the committed state in a cache, but the state will
-// not be applied and hence will not change the compositor output.
-// The cached state is applied to the sub-surface immediately after
-// the parent surface's state is applied. This ensures atomic
-// updates of the parent and all its synchronized sub-surfaces.
-// Applying the cached state will invalidate the cache, so further
-// parent surface commits do not (re-)apply old state.
-//
-// See wl_subsurface for the recursive effect of this mode.
-func (i *Subsurface) SetSync() error {
-	const opcode = 4
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetDesync : set sub-surface to desynchronized mode
-//
-// Change the commit behaviour of the sub-surface to desynchronized
-// mode, also described as independent or freely running mode.
-//
-// In desynchronized mode, wl_surface.commit on a sub-surface will
-// apply the pending state directly, without caching, as happens
-// normally with a wl_surface. Calling wl_surface.commit on the
-// parent surface has no effect on the sub-surface's wl_surface
-// state. This mode allows a sub-surface to be updated on its own.
-//
-// If cached state exists when wl_surface.commit is called in
-// desynchronized mode, the pending state is added to the cached
-// state, and applied as a whole. This invalidates the cache.
-//
-// Note: even if a sub-surface is set to desynchronized, a parent
-// sub-surface may override it to behave as synchronized. For details,
-// see wl_subsurface.
-//
-// If a surface's parent surface behaves as desynchronized, then
-// the cached state is applied on set_desync.
-func (i *Subsurface) SetDesync() error {
-	const opcode = 5
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-type SubsurfaceError uint32
-
-// SubsurfaceError :
-const (
-	// SubsurfaceErrorBadSurface : wl_surface is not a sibling or the parent
-	SubsurfaceErrorBadSurface SubsurfaceError = 0
-)
-
-func (e SubsurfaceError) Name() string {
-	switch e {
-	case SubsurfaceErrorBadSurface:
-		return "bad_surface"
-	default:
-		return ""
-	}
-}
-
-func (e SubsurfaceError) Value() string {
-	switch e {
-	case SubsurfaceErrorBadSurface:
-		return "0"
-	default:
-		return ""
-	}
-}
-
-func (e SubsurfaceError) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// FixesInterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const FixesInterfaceName = "wl_fixes"
-
-// Fixes : wayland protocol fixes
-//
-// This global fixes problems with other core-protocol interfaces that
-// cannot be fixed in these interfaces themselves.
-type Fixes struct {
-	BaseProxy
-}
-
-// NewFixes : wayland protocol fixes
-//
-// This global fixes problems with other core-protocol interfaces that
-// cannot be fixed in these interfaces themselves.
-func NewFixes(ctx *Context) *Fixes {
-	wlFixes := &Fixes{}
-	ctx.Register(wlFixes)
-	return wlFixes
-}
-
-// Destroy : destroys this object
-func (i *Fixes) Destroy() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// DestroyRegistry : destroy a wl_registry
-//
-// This request destroys a wl_registry object.
-//
-// The client should no longer use the wl_registry after making this
-// request.
-//
-// The compositor will emit a wl_display.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
-// wl_display.delete_id event.
-//
-//	registry: the registry to destroy
-func (i *Fixes) DestroyRegistry(registry *Registry) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	PutUint32(_reqBuf[l:l+4], registry.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/common.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/common.go
deleted file mode 100644
index b97d1b8..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/common.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package client
-
-import "sync/atomic"
-
-type Dispatcher interface {
-	Dispatch(opcode uint32, fd int, data []byte)
-}
-
-type Proxy interface {
-	Context() *Context
-	SetContext(ctx *Context)
-	ID() uint32
-	SetID(id uint32)
-	IsZombie() bool
-	MarkZombie()
-}
-
-type WaylandDisplay interface {
-	Context() *Context
-	GetRegistry() (*Registry, error)
-	Roundtrip() error
-	Destroy() error
-}
-
-var _ WaylandDisplay = (*Display)(nil)
-
-type BaseProxy struct {
-	ctx    *Context
-	id     uint32
-	zombie atomic.Bool
-}
-
-func (p *BaseProxy) ID() uint32 {
-	return p.id
-}
-
-func (p *BaseProxy) SetID(id uint32) {
-	p.id = id
-}
-
-func (p *BaseProxy) Context() *Context {
-	return p.ctx
-}
-
-func (p *BaseProxy) SetContext(ctx *Context) {
-	p.ctx = ctx
-}
-
-func (p *BaseProxy) IsZombie() bool {
-	return p.zombie.Load()
-}
-
-func (p *BaseProxy) MarkZombie() {
-	p.zombie.Store(true)
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context.go
deleted file mode 100644
index 4eee2cb..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context.go
+++ /dev/null
@@ -1,143 +0,0 @@
-package client
-
-import (
-	"errors"
-	"fmt"
-	"net"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
-)
-
-type Context struct {
-	conn      *net.UnixConn
-	objects   syncmap.Map[uint32, Proxy] // map[uint32]Proxy - thread-safe concurrent map
-	currentID uint32
-	idMu      sync.Mutex // protects currentID increment
-}
-
-func (ctx *Context) Register(p Proxy) {
-	ctx.idMu.Lock()
-	ctx.currentID++
-	id := ctx.currentID
-	ctx.idMu.Unlock()
-
-	p.SetID(id)
-	p.SetContext(ctx)
-	ctx.objects.Store(id, p)
-}
-
-func (ctx *Context) RegisterWithID(p Proxy, id uint32) {
-	p.SetID(id)
-	p.SetContext(ctx)
-	ctx.objects.Store(id, p)
-}
-
-func (ctx *Context) Unregister(p Proxy) {
-	ctx.objects.Delete(p.ID())
-}
-
-func (ctx *Context) DeleteID(id uint32) {
-	ctx.objects.Delete(id)
-}
-
-func (ctx *Context) GetProxy(id uint32) Proxy {
-	if val, ok := ctx.objects.Load(id); ok {
-		return val
-	}
-	return nil
-}
-
-func (ctx *Context) Close() error {
-	return ctx.conn.Close()
-}
-
-func (ctx *Context) SetReadDeadline(t time.Time) error {
-	return ctx.conn.SetReadDeadline(t)
-}
-
-func (ctx *Context) Fd() int {
-	rawConn, err := ctx.conn.SyscallConn()
-	if err != nil {
-		return -1
-	}
-	var fd int
-	rawConn.Control(func(f uintptr) {
-		fd = int(f)
-	})
-	return fd
-}
-
-// Dispatch reads and processes incoming messages and calls [client.Dispatcher.Dispatch] on the
-// respective wayland protocol.
-// Dispatch must be called on the same goroutine as other interactions with the Context.
-// If a multi goroutine approach is desired, use [Context.GetDispatch] instead.
-// Dispatch blocks if there are no incoming messages.
-// A Dispatch loop is usually used to handle incoming messages.
-func (ctx *Context) Dispatch() error {
-	return ctx.GetDispatch()()
-}
-
-var ErrDispatchSenderNotFound = errors.New("dispatch: unable to find sender")
-var ErrDispatchSenderUnsupported = errors.New("dispatch: sender does not implement Dispatch method")
-var ErrDispatchUnableToReadMsg = errors.New("dispatch: unable to read msg")
-
-// GetDispatch reads incoming messages and returns the dispatch function which calls
-// [client.Dispatcher.Dispatch] on the respective wayland protocol.
-// This function is now thread-safe and can be called from multiple goroutines.
-// GetDispatch blocks if there are no incoming messages.
-func (ctx *Context) GetDispatch() func() error {
-	senderID, opcode, fd, data, err := ctx.ReadMsg() // Blocks if there are no incoming messages
-	if err != nil {
-		return func() error {
-			return fmt.Errorf("%w: %w", ErrDispatchUnableToReadMsg, err)
-		}
-	}
-
-	return func() error {
-		proxy, ok := ctx.objects.Load(senderID)
-		if !ok {
-			return nil // Proxy already deleted via delete_id, silently ignore
-		}
-
-		if proxy.IsZombie() {
-			return nil // Zombie proxy, discard late events
-		}
-
-		sender, ok := proxy.(Dispatcher)
-		if !ok {
-			return fmt.Errorf("%w (senderID=%d)", ErrDispatchSenderUnsupported, senderID)
-		}
-
-		sender.Dispatch(opcode, fd, data)
-		return nil
-	}
-}
-
-func Connect(addr string) (*Display, error) {
-	if addr == "" {
-		runtimeDir := os.Getenv("XDG_RUNTIME_DIR")
-		if runtimeDir == "" {
-			return nil, errors.New("env XDG_RUNTIME_DIR not set")
-		}
-		if addr == "" {
-			addr = os.Getenv("WAYLAND_DISPLAY")
-		}
-		if addr == "" {
-			addr = "wayland-0"
-		}
-		addr = runtimeDir + "/" + addr
-	}
-
-	ctx := &Context{}
-
-	conn, err := net.DialUnix("unix", nil, &net.UnixAddr{Name: addr, Net: "unix"})
-	if err != nil {
-		return nil, err
-	}
-	ctx.conn = conn
-
-	return NewDisplay(ctx), nil
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context_test.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context_test.go
deleted file mode 100644
index 380d7da..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context_test.go
+++ /dev/null
@@ -1,111 +0,0 @@
-package client_test
-
-import (
-	"errors"
-	"fmt"
-	"log"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
-)
-
-// Shows a dispatch loop that will block the goroutine.
-// This approach has no risk of data races but the loop blocks the goroutine when no messages are
-// received. This can be a valid approach if there are no more changes that need to be made after
-// setting up and starting the loop.
-// For a multi goroutine approach, use [client.Context.GetDispatch].
-func ExampleContext_Dispatch() {
-	display, err := client.Connect("")
-	if err != nil {
-		log.Fatalf("Error connecting to Wayland server: %v", err)
-	}
-
-	registry, err := display.GetRegistry()
-	if err != nil {
-		log.Fatalf("Error getting Wayland registry: %v", err)
-	}
-
-	var seat *client.Seat
-	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
-		switch e.Interface {
-		case client.SeatInterfaceName:
-			seat = client.NewSeat(display.Context())
-			err := registry.Bind(e.Name, e.Interface, e.Version, seat)
-			if err != nil {
-				log.Fatalf("unable to bind %s interface: %v", client.SeatInterfaceName, err)
-			}
-		}
-	})
-	display.Roundtrip()
-	display.Roundtrip()
-
-	keyboard, err := seat.GetKeyboard()
-	if err != nil {
-		log.Printf("Error getting keyboard: %v", err)
-	}
-	log.Printf("Got keyboard: %v\n", keyboard)
-
-	for {
-		err := display.Context().Dispatch()
-		if err != nil {
-			log.Printf("Dispatch error: %v\n", err)
-		}
-	}
-}
-
-// Shows how the dispatch loop can be done in another goroutine.
-// This prevents the goroutine from being blocked and allows making changes to wayland objects while
-// the dispatch loop is blocking another goroutine.
-func ExampleContext_GetDispatch() {
-	display, err := client.Connect("")
-	if err != nil {
-		log.Fatalf("Error connecting to Wayland server: %v", err)
-	}
-
-	registry, err := display.GetRegistry()
-	if err != nil {
-		log.Fatalf("Error getting Wayland registry: %v", err)
-	}
-
-	var seat *client.Seat
-	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
-		switch e.Interface {
-		case client.SeatInterfaceName:
-			seat = client.NewSeat(display.Context())
-			err := registry.Bind(e.Name, e.Interface, e.Version, seat)
-			if err != nil {
-				log.Fatalf("unable to bind %s interface: %v", client.SeatInterfaceName, err)
-			}
-		}
-	})
-	display.Roundtrip()
-	display.Roundtrip()
-	dispatchQueue := make(chan func() error)
-
-	go func() {
-		for {
-			dispatchQueue <- display.Context().GetDispatch()
-		}
-	}()
-
-	keyboard, err := seat.GetKeyboard()
-	if err != nil {
-		log.Printf("Error getting keyboard: %v", err)
-	}
-	log.Printf("Got keyboard: %v\n", keyboard)
-
-	err = errors.Join(keyboard.Release(), seat.Release(), display.Context().Close())
-	if err != nil {
-		fmt.Printf("Error cleaning up: %v\n", err)
-	}
-
-	for {
-		select {
-		// Add other cases here to do other things
-		case dispatchFunc := <-dispatchQueue:
-			err := dispatchFunc()
-			if err != nil {
-				log.Printf("Dispatch error: %v\n", err)
-			}
-		}
-	}
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/display.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/display.go
deleted file mode 100644
index fa2af6f..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/display.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"log"
-)
-
-// Roundtrip blocks until all pending request are processed by the server.
-// It is the implementation of [wl_display_roundtrip].
-//
-// [wl_display_roundtrip]: https://wayland.freedesktop.org/docs/html/apb.html#Client-classwl__display_1ab60f38c2f80980ac84f347e932793390
-func (i *Display) Roundtrip() error {
-	callback, err := i.Sync()
-	if err != nil {
-		return fmt.Errorf("unable to get sync callback: %w", err)
-	}
-	defer func() {
-		if err2 := callback.Destroy(); err2 != nil {
-			log.Printf("unable to destroy callback: %v\n", err2)
-		}
-	}()
-
-	done := false
-	callback.SetDoneHandler(func(_ CallbackDoneEvent) {
-		done = true
-	})
-
-	// Wait for callback to return
-	for !done {
-		err := i.Context().GetDispatch()()
-		if err != nil {
-			return fmt.Errorf("roundtrip: failed to dispatch: %w", err)
-		}
-	}
-
-	return nil
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/doc.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/doc.go
deleted file mode 100644
index 91137f9..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/doc.go
+++ /dev/null
@@ -1,6 +0,0 @@
-// Package client is Go port of wayland-client library
-// for writing pure Go GUI software for wayland supported
-// platforms.
-package client
-
-//go:generate go run github.com/yaslama/go-wayland/cmd/go-wayland-scanner -pkg client -prefix wl -o client.go -i https://gitlab.freedesktop.org/wayland/wayland/-/raw/1.23.0/protocol/wayland.xml?ref_type=tags
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/event.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/event.go
deleted file mode 100644
index e7b5cb8..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/event.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"fmt"
-	"unsafe"
-
-	"golang.org/x/sys/unix"
-
-	_ "unsafe"
-)
-
-var oobSpace = unix.CmsgSpace(4)
-
-func (ctx *Context) ReadMsg() (senderID uint32, opcode uint32, fd int, msg []byte, err error) {
-	fd = -1
-
-	oob := make([]byte, oobSpace)
-	header := make([]byte, 8)
-
-	n, oobn, _, _, err := ctx.conn.ReadMsgUnix(header, oob)
-	if err != nil {
-		return senderID, opcode, fd, msg, err
-	}
-	if n != 8 {
-		return senderID, opcode, fd, msg, fmt.Errorf("ctx.ReadMsg: incorrect number of bytes read for header (n=%d)", n)
-	}
-
-	if oobn > 0 {
-		fds, err := getFdsFromOob(oob, oobn, "header")
-		if err != nil {
-			return senderID, opcode, fd, msg, fmt.Errorf("ctx.ReadMsg: %w", err)
-		}
-
-		if len(fds) > 0 {
-			fd = fds[0]
-		}
-	}
-
-	senderID = Uint32(header[:4])
-	opcodeAndSize := Uint32(header[4:8])
-	opcode = opcodeAndSize & 0xffff
-	size := opcodeAndSize >> 16
-
-	msgSize := int(size) - 8
-	if msgSize == 0 {
-		return senderID, opcode, fd, nil, nil
-	}
-
-	msg = make([]byte, msgSize)
-
-	if fd == -1 {
-		// if something was read before, then zero it out
-		if oobn > 0 {
-			oob = make([]byte, oobSpace)
-		}
-
-		n, oobn, _, _, err = ctx.conn.ReadMsgUnix(msg, oob)
-	} else {
-		n, err = ctx.conn.Read(msg)
-	}
-	if err != nil {
-		return senderID, opcode, fd, msg, fmt.Errorf("ctx.ReadMsg: %w", err)
-	}
-	if n != msgSize {
-		return senderID, opcode, fd, msg, fmt.Errorf("ctx.ReadMsg: incorrect number of bytes read for msg (n=%d, msgSize=%d)", n, msgSize)
-	}
-
-	if fd == -1 && oobn > 0 {
-		fds, err := getFdsFromOob(oob, oobn, "msg")
-		if err != nil {
-			return senderID, opcode, fd, msg, fmt.Errorf("ctx.ReadMsg: %w", err)
-		}
-
-		if len(fds) > 0 {
-			fd = fds[0]
-		}
-	}
-
-	return senderID, opcode, fd, msg, nil
-}
-
-func getFdsFromOob(oob []byte, oobn int, source string) ([]int, error) {
-	if oobn > len(oob) {
-		return nil, fmt.Errorf("getFdsFromOob: incorrect number of bytes read from %s for oob (oobn=%d)", source, oobn)
-	}
-	scms, err := unix.ParseSocketControlMessage(oob)
-	if err != nil {
-		return nil, fmt.Errorf("getFdsFromOob: unable to parse control message from %s: %w", source, err)
-	}
-
-	var fdsRet []int
-	for _, scm := range scms {
-		fds, err := unix.ParseUnixRights(&scm)
-		if err != nil {
-			return nil, fmt.Errorf("getFdsFromOob: unable to parse unix rights from %s: %w", source, err)
-		}
-
-		fdsRet = append(fdsRet, fds...)
-	}
-
-	return fdsRet, nil
-}
-
-func Uint32(src []byte) uint32 {
-	_ = src[3]
-	return *(*uint32)(unsafe.Pointer(&src[0]))
-}
-
-func String(src []byte) string {
-	idx := bytes.IndexByte(src, 0)
-	src = src[:idx:idx]
-	return *(*string)(unsafe.Pointer(&src))
-}
-
-func Fixed(src []byte) float64 {
-	_ = src[3]
-	fx := *(*int32)(unsafe.Pointer(&src[0]))
-	return fixedToFloat64(fx)
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/request.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/request.go
deleted file mode 100644
index 3ca2317..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/request.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"unsafe"
-)
-
-func (ctx *Context) WriteMsg(b []byte, oob []byte) error {
-	n, oobn, err := ctx.conn.WriteMsgUnix(b, oob, nil)
-	if err != nil {
-		return err
-	}
-	if n != len(b) || oobn != len(oob) {
-		return fmt.Errorf("ctx.WriteMsg: incorrect number of bytes written (n=%d oobn=%d)", n, oobn)
-	}
-
-	return nil
-}
-
-func PutUint32(dst []byte, v uint32) {
-	_ = dst[3]
-	*(*uint32)(unsafe.Pointer(&dst[0])) = v
-}
-
-func PutFixed(dst []byte, f float64) {
-	fx := fixedFromfloat64(f)
-	_ = dst[3]
-	*(*int32)(unsafe.Pointer(&dst[0])) = fx
-}
-
-// PutString places a string in Wayland's wire format on the destination buffer.
-// It first places the length of the string (plus one for the null terminator) and then the string
-// followed by a null byte.
-// The length of dst must be equal to, or greater than, len(v) + 5.
-func PutString(dst []byte, v string) {
-	PutUint32(dst[:4], uint32(len(v)+1))
-	copy(dst[4:], v)
-	dst[4+len(v)] = '\x00' // To cause panic if dst is not large enough
-}
-
-func PutArray(dst []byte, a []byte) {
-	PutUint32(dst[:4], uint32(len(a)))
-	copy(dst[4:], a)
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/util.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/util.go
deleted file mode 100644
index ba3d43a..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/util.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package client
-
-import "math"
-
-// From wayland/wayland-util.h
-
-func fixedToFloat64(f int32) float64 {
-	u_i := (1023+44)<<52 + (1 << 51) + int64(f)
-	u_d := math.Float64frombits(uint64(u_i))
-	return u_d - (3 << 43)
-}
-
-func fixedFromfloat64(d float64) int32 {
-	u_d := d + (3 << (51 - 8))
-	u_i := int64(math.Float64bits(u_d))
-	return int32(u_i)
-}
-
-func PaddedLen(l int) int {
-	if (l & 0x3) != 0 {
-		return l + (4 - (l & 0x3))
-	}
-	return l
-}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/stable/xdg-shell/xdg_shell.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/stable/xdg-shell/xdg_shell.go
deleted file mode 100644
index 19a203b..0000000
--- a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/stable/xdg-shell/xdg_shell.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package xdg_shell
-
-import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
-
-type Popup struct {
-	client.BaseProxy
-}
-
-func NewPopup(ctx *client.Context) *Popup {
-	p := &Popup{}
-	ctx.Register(p)
-	return p
-}