Replaced file structures for themes in the correct format

15 files changed, 8160 insertions, 0 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
new file mode 100644
index 0000000..7b24eab
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/AUTHORS
@@ -0,0 +1,3 @@
+// 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
new file mode 100644
index 0000000..4da3300
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/LICENSE
@@ -0,0 +1,24 @@
+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
new file mode 100644
index 0000000..9e52d99
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/README.md
@@ -0,0 +1,25 @@
+# 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
new file mode 100755
index 0000000..02ad975
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generate
@@ -0,0 +1,4 @@
+#!/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
new file mode 100755
index 0000000..bd660d7
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/generatep
@@ -0,0 +1,9 @@
+#!/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
new file mode 100644
index 0000000..fd49c20
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/client.go
@@ -0,0 +1,7542 @@
+// 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
new file mode 100644
index 0000000..b97d1b8
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/common.go
@@ -0,0 +1,55 @@
+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
new file mode 100644
index 0000000..4eee2cb
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context.go
@@ -0,0 +1,143 @@
+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
new file mode 100644
index 0000000..380d7da
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/context_test.go
@@ -0,0 +1,111 @@
+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
new file mode 100644
index 0000000..fa2af6f
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/display.go
@@ -0,0 +1,37 @@
+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
new file mode 100644
index 0000000..91137f9
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/doc.go
@@ -0,0 +1,6 @@
+// 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
new file mode 100644
index 0000000..e7b5cb8
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/event.go
@@ -0,0 +1,120 @@
+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
new file mode 100644
index 0000000..3ca2317
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/request.go
@@ -0,0 +1,44 @@
+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
new file mode 100644
index 0000000..ba3d43a
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/client/util.go
@@ -0,0 +1,24 @@
+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
new file mode 100644
index 0000000..19a203b
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/pkg/go-wayland/wayland/stable/xdg-shell/xdg_shell.go
@@ -0,0 +1,13 @@
+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
+}