diff options
Diffstat (limited to 'raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto')
19 files changed, 9198 insertions, 0 deletions
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/dwl_ipc/dwl_ipc.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/dwl_ipc/dwl_ipc.go new file mode 100644 index 0000000..fc0e50b --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/dwl_ipc/dwl_ipc.go @@ -0,0 +1,791 @@ +// Generated by go-wayland-scanner +// https://github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/cmd/go-wayland-scanner +// XML file : internal/proto/xml/dwl-ipc-unstable-v2.xml +// +// dwl_ipc_unstable_v2 Protocol Copyright: + +package dwl_ipc + +import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + +// ZdwlIpcManagerV2InterfaceName 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 ZdwlIpcManagerV2InterfaceName = "zdwl_ipc_manager_v2" + +// ZdwlIpcManagerV2 : manage dwl state +// +// This interface is exposed as a global in wl_registry. +// +// Clients can use this interface to get a dwl_ipc_output. +// After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events. +// The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client. +type ZdwlIpcManagerV2 struct { + client.BaseProxy + tagsHandler ZdwlIpcManagerV2TagsHandlerFunc + layoutHandler ZdwlIpcManagerV2LayoutHandlerFunc +} + +// NewZdwlIpcManagerV2 : manage dwl state +// +// This interface is exposed as a global in wl_registry. +// +// Clients can use this interface to get a dwl_ipc_output. +// After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events. +// The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client. +func NewZdwlIpcManagerV2(ctx *client.Context) *ZdwlIpcManagerV2 { + zdwlIpcManagerV2 := &ZdwlIpcManagerV2{} + ctx.Register(zdwlIpcManagerV2) + return zdwlIpcManagerV2 +} + +// Release : release dwl_ipc_manager +// +// Indicates that the client will not the dwl_ipc_manager object anymore. +// Objects created through this instance are not affected. +func (i *ZdwlIpcManagerV2) Release() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// GetOutput : get a dwl_ipc_outout for a wl_output +// +// Get a dwl_ipc_outout for the specified wl_output. +func (i *ZdwlIpcManagerV2) GetOutput(output *client.Output) (*ZdwlIpcOutputV2, error) { + id := NewZdwlIpcOutputV2(i.Context()) + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], output.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// ZdwlIpcManagerV2TagsEvent : Announces tag amount +// +// This event is sent after binding. +// A roundtrip after binding guarantees the client recieved all tags. +type ZdwlIpcManagerV2TagsEvent struct { + Amount uint32 +} +type ZdwlIpcManagerV2TagsHandlerFunc func(ZdwlIpcManagerV2TagsEvent) + +// SetTagsHandler : sets handler for ZdwlIpcManagerV2TagsEvent +func (i *ZdwlIpcManagerV2) SetTagsHandler(f ZdwlIpcManagerV2TagsHandlerFunc) { + i.tagsHandler = f +} + +// ZdwlIpcManagerV2LayoutEvent : Announces a layout +// +// This event is sent after binding. +// A roundtrip after binding guarantees the client recieved all layouts. +type ZdwlIpcManagerV2LayoutEvent struct { + Name string +} +type ZdwlIpcManagerV2LayoutHandlerFunc func(ZdwlIpcManagerV2LayoutEvent) + +// SetLayoutHandler : sets handler for ZdwlIpcManagerV2LayoutEvent +func (i *ZdwlIpcManagerV2) SetLayoutHandler(f ZdwlIpcManagerV2LayoutHandlerFunc) { + i.layoutHandler = f +} + +func (i *ZdwlIpcManagerV2) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.tagsHandler == nil { + return + } + var e ZdwlIpcManagerV2TagsEvent + l := 0 + e.Amount = client.Uint32(data[l : l+4]) + l += 4 + + i.tagsHandler(e) + case 1: + if i.layoutHandler == nil { + return + } + var e ZdwlIpcManagerV2LayoutEvent + l := 0 + nameLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Name = client.String(data[l : l+nameLen]) + l += nameLen + + i.layoutHandler(e) + } +} + +// ZdwlIpcOutputV2InterfaceName 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 ZdwlIpcOutputV2InterfaceName = "zdwl_ipc_output_v2" + +// ZdwlIpcOutputV2 : control dwl output +// +// Observe and control a dwl output. +// +// Events are double-buffered: +// Clients should cache events and redraw when a dwl_ipc_output.frame event is sent. +// +// Request are not double-buffered: +// The compositor will update immediately upon request. +type ZdwlIpcOutputV2 struct { + client.BaseProxy + toggleVisibilityHandler ZdwlIpcOutputV2ToggleVisibilityHandlerFunc + activeHandler ZdwlIpcOutputV2ActiveHandlerFunc + tagHandler ZdwlIpcOutputV2TagHandlerFunc + layoutHandler ZdwlIpcOutputV2LayoutHandlerFunc + titleHandler ZdwlIpcOutputV2TitleHandlerFunc + appidHandler ZdwlIpcOutputV2AppidHandlerFunc + layoutSymbolHandler ZdwlIpcOutputV2LayoutSymbolHandlerFunc + frameHandler ZdwlIpcOutputV2FrameHandlerFunc + fullscreenHandler ZdwlIpcOutputV2FullscreenHandlerFunc + floatingHandler ZdwlIpcOutputV2FloatingHandlerFunc + xHandler ZdwlIpcOutputV2XHandlerFunc + yHandler ZdwlIpcOutputV2YHandlerFunc + widthHandler ZdwlIpcOutputV2WidthHandlerFunc + heightHandler ZdwlIpcOutputV2HeightHandlerFunc + lastLayerHandler ZdwlIpcOutputV2LastLayerHandlerFunc + kbLayoutHandler ZdwlIpcOutputV2KbLayoutHandlerFunc + keymodeHandler ZdwlIpcOutputV2KeymodeHandlerFunc + scalefactorHandler ZdwlIpcOutputV2ScalefactorHandlerFunc +} + +// NewZdwlIpcOutputV2 : control dwl output +// +// Observe and control a dwl output. +// +// Events are double-buffered: +// Clients should cache events and redraw when a dwl_ipc_output.frame event is sent. +// +// Request are not double-buffered: +// The compositor will update immediately upon request. +func NewZdwlIpcOutputV2(ctx *client.Context) *ZdwlIpcOutputV2 { + zdwlIpcOutputV2 := &ZdwlIpcOutputV2{} + ctx.Register(zdwlIpcOutputV2) + return zdwlIpcOutputV2 +} + +// Release : release dwl_ipc_outout +// +// Indicates to that the client no longer needs this dwl_ipc_output. +func (i *ZdwlIpcOutputV2) Release() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetTags : Set the active tags of this output +// +// tagmask: bitmask of the tags that should be set. +// toggleTagset: toggle the selected tagset, zero for invalid, nonzero for valid. +func (i *ZdwlIpcOutputV2) SetTags(tagmask, toggleTagset uint32) error { + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(tagmask)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(toggleTagset)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetClientTags : Set the tags of the focused client. +// +// The tags are updated as follows: +// new_tags = (current_tags AND and_tags) XOR xor_tags +func (i *ZdwlIpcOutputV2) SetClientTags(andTags, xorTags uint32) error { + const opcode = 2 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(andTags)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(xorTags)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetLayout : Set the layout of this output +// +// index: index of a layout recieved by dwl_ipc_manager.layout +func (i *ZdwlIpcOutputV2) SetLayout(index uint32) error { + const opcode = 3 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(index)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Quit : Quit mango +// This request allows clients to instruct the compositor to quit mango. +func (i *ZdwlIpcOutputV2) Quit() error { + const opcode = 4 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SendDispatch : Set the active tags of this output +// +// dispatch: dispatch name. +// arg1: arg1. +// arg2: arg2. +// arg3: arg3. +// arg4: arg4. +// arg5: arg5. +func (i *ZdwlIpcOutputV2) SendDispatch(dispatch, arg1, arg2, arg3, arg4, arg5 string) error { + const opcode = 5 + dispatchLen := client.PaddedLen(len(dispatch) + 1) + arg1Len := client.PaddedLen(len(arg1) + 1) + arg2Len := client.PaddedLen(len(arg2) + 1) + arg3Len := client.PaddedLen(len(arg3) + 1) + arg4Len := client.PaddedLen(len(arg4) + 1) + arg5Len := client.PaddedLen(len(arg5) + 1) + _reqBufLen := 8 + (4 + dispatchLen) + (4 + arg1Len) + (4 + arg2Len) + (4 + arg3Len) + (4 + arg4Len) + (4 + arg5Len) + _reqBuf := make([]byte, _reqBufLen) + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutString(_reqBuf[l:l+(4+dispatchLen)], dispatch) + l += (4 + dispatchLen) + client.PutString(_reqBuf[l:l+(4+arg1Len)], arg1) + l += (4 + arg1Len) + client.PutString(_reqBuf[l:l+(4+arg2Len)], arg2) + l += (4 + arg2Len) + client.PutString(_reqBuf[l:l+(4+arg3Len)], arg3) + l += (4 + arg3Len) + client.PutString(_reqBuf[l:l+(4+arg4Len)], arg4) + l += (4 + arg4Len) + client.PutString(_reqBuf[l:l+(4+arg5Len)], arg5) + l += (4 + arg5Len) + err := i.Context().WriteMsg(_reqBuf, nil) + return err +} + +type ZdwlIpcOutputV2TagState uint32 + +// ZdwlIpcOutputV2TagState : +const ( + // ZdwlIpcOutputV2TagStateNone : no state + ZdwlIpcOutputV2TagStateNone ZdwlIpcOutputV2TagState = 0 + // ZdwlIpcOutputV2TagStateActive : tag is active + ZdwlIpcOutputV2TagStateActive ZdwlIpcOutputV2TagState = 1 + // ZdwlIpcOutputV2TagStateUrgent : tag has at least one urgent client + ZdwlIpcOutputV2TagStateUrgent ZdwlIpcOutputV2TagState = 2 +) + +func (e ZdwlIpcOutputV2TagState) Name() string { + switch e { + case ZdwlIpcOutputV2TagStateNone: + return "none" + case ZdwlIpcOutputV2TagStateActive: + return "active" + case ZdwlIpcOutputV2TagStateUrgent: + return "urgent" + default: + return "" + } +} + +func (e ZdwlIpcOutputV2TagState) Value() string { + switch e { + case ZdwlIpcOutputV2TagStateNone: + return "0" + case ZdwlIpcOutputV2TagStateActive: + return "1" + case ZdwlIpcOutputV2TagStateUrgent: + return "2" + default: + return "" + } +} + +func (e ZdwlIpcOutputV2TagState) String() string { + return e.Name() + "=" + e.Value() +} + +// ZdwlIpcOutputV2ToggleVisibilityEvent : Toggle client visibilty +// +// Indicates the client should hide or show themselves. +// If the client is visible then hide, if hidden then show. +type ZdwlIpcOutputV2ToggleVisibilityEvent struct{} +type ZdwlIpcOutputV2ToggleVisibilityHandlerFunc func(ZdwlIpcOutputV2ToggleVisibilityEvent) + +// SetToggleVisibilityHandler : sets handler for ZdwlIpcOutputV2ToggleVisibilityEvent +func (i *ZdwlIpcOutputV2) SetToggleVisibilityHandler(f ZdwlIpcOutputV2ToggleVisibilityHandlerFunc) { + i.toggleVisibilityHandler = f +} + +// ZdwlIpcOutputV2ActiveEvent : Update the selected output. +// +// Indicates if the output is active. Zero is invalid, nonzero is valid. +type ZdwlIpcOutputV2ActiveEvent struct { + Active uint32 +} +type ZdwlIpcOutputV2ActiveHandlerFunc func(ZdwlIpcOutputV2ActiveEvent) + +// SetActiveHandler : sets handler for ZdwlIpcOutputV2ActiveEvent +func (i *ZdwlIpcOutputV2) SetActiveHandler(f ZdwlIpcOutputV2ActiveHandlerFunc) { + i.activeHandler = f +} + +// ZdwlIpcOutputV2TagEvent : Update the state of a tag. +// +// Indicates that a tag has been updated. +type ZdwlIpcOutputV2TagEvent struct { + Tag uint32 + State uint32 + Clients uint32 + Focused uint32 +} +type ZdwlIpcOutputV2TagHandlerFunc func(ZdwlIpcOutputV2TagEvent) + +// SetTagHandler : sets handler for ZdwlIpcOutputV2TagEvent +func (i *ZdwlIpcOutputV2) SetTagHandler(f ZdwlIpcOutputV2TagHandlerFunc) { + i.tagHandler = f +} + +// ZdwlIpcOutputV2LayoutEvent : Update the layout. +// +// Indicates a new layout is selected. +type ZdwlIpcOutputV2LayoutEvent struct { + Layout uint32 +} +type ZdwlIpcOutputV2LayoutHandlerFunc func(ZdwlIpcOutputV2LayoutEvent) + +// SetLayoutHandler : sets handler for ZdwlIpcOutputV2LayoutEvent +func (i *ZdwlIpcOutputV2) SetLayoutHandler(f ZdwlIpcOutputV2LayoutHandlerFunc) { + i.layoutHandler = f +} + +// ZdwlIpcOutputV2TitleEvent : Update the title. +// +// Indicates the title has changed. +type ZdwlIpcOutputV2TitleEvent struct { + Title string +} +type ZdwlIpcOutputV2TitleHandlerFunc func(ZdwlIpcOutputV2TitleEvent) + +// SetTitleHandler : sets handler for ZdwlIpcOutputV2TitleEvent +func (i *ZdwlIpcOutputV2) SetTitleHandler(f ZdwlIpcOutputV2TitleHandlerFunc) { + i.titleHandler = f +} + +// ZdwlIpcOutputV2AppidEvent : Update the appid. +// +// Indicates the appid has changed. +type ZdwlIpcOutputV2AppidEvent struct { + Appid string +} +type ZdwlIpcOutputV2AppidHandlerFunc func(ZdwlIpcOutputV2AppidEvent) + +// SetAppidHandler : sets handler for ZdwlIpcOutputV2AppidEvent +func (i *ZdwlIpcOutputV2) SetAppidHandler(f ZdwlIpcOutputV2AppidHandlerFunc) { + i.appidHandler = f +} + +// ZdwlIpcOutputV2LayoutSymbolEvent : Update the current layout symbol +// +// Indicates the layout has changed. Since layout symbols are dynamic. +// As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying. +// You can ignore the zdwl_ipc_output.layout event. +type ZdwlIpcOutputV2LayoutSymbolEvent struct { + Layout string +} +type ZdwlIpcOutputV2LayoutSymbolHandlerFunc func(ZdwlIpcOutputV2LayoutSymbolEvent) + +// SetLayoutSymbolHandler : sets handler for ZdwlIpcOutputV2LayoutSymbolEvent +func (i *ZdwlIpcOutputV2) SetLayoutSymbolHandler(f ZdwlIpcOutputV2LayoutSymbolHandlerFunc) { + i.layoutSymbolHandler = f +} + +// ZdwlIpcOutputV2FrameEvent : The update sequence is done. +// +// Indicates that a sequence of status updates have finished and the client should redraw. +type ZdwlIpcOutputV2FrameEvent struct{} +type ZdwlIpcOutputV2FrameHandlerFunc func(ZdwlIpcOutputV2FrameEvent) + +// SetFrameHandler : sets handler for ZdwlIpcOutputV2FrameEvent +func (i *ZdwlIpcOutputV2) SetFrameHandler(f ZdwlIpcOutputV2FrameHandlerFunc) { + i.frameHandler = f +} + +// ZdwlIpcOutputV2FullscreenEvent : Update fullscreen status +// +// Indicates if the selected client on this output is fullscreen. +type ZdwlIpcOutputV2FullscreenEvent struct { + IsFullscreen uint32 +} +type ZdwlIpcOutputV2FullscreenHandlerFunc func(ZdwlIpcOutputV2FullscreenEvent) + +// SetFullscreenHandler : sets handler for ZdwlIpcOutputV2FullscreenEvent +func (i *ZdwlIpcOutputV2) SetFullscreenHandler(f ZdwlIpcOutputV2FullscreenHandlerFunc) { + i.fullscreenHandler = f +} + +// ZdwlIpcOutputV2FloatingEvent : Update the floating status +// +// Indicates if the selected client on this output is floating. +type ZdwlIpcOutputV2FloatingEvent struct { + IsFloating uint32 +} +type ZdwlIpcOutputV2FloatingHandlerFunc func(ZdwlIpcOutputV2FloatingEvent) + +// SetFloatingHandler : sets handler for ZdwlIpcOutputV2FloatingEvent +func (i *ZdwlIpcOutputV2) SetFloatingHandler(f ZdwlIpcOutputV2FloatingHandlerFunc) { + i.floatingHandler = f +} + +// ZdwlIpcOutputV2XEvent : Update the x coordinates +// +// Indicates if x coordinates of the selected client. +type ZdwlIpcOutputV2XEvent struct { + X int32 +} +type ZdwlIpcOutputV2XHandlerFunc func(ZdwlIpcOutputV2XEvent) + +// SetXHandler : sets handler for ZdwlIpcOutputV2XEvent +func (i *ZdwlIpcOutputV2) SetXHandler(f ZdwlIpcOutputV2XHandlerFunc) { + i.xHandler = f +} + +// ZdwlIpcOutputV2YEvent : Update the y coordinates +// +// Indicates if y coordinates of the selected client. +type ZdwlIpcOutputV2YEvent struct { + Y int32 +} +type ZdwlIpcOutputV2YHandlerFunc func(ZdwlIpcOutputV2YEvent) + +// SetYHandler : sets handler for ZdwlIpcOutputV2YEvent +func (i *ZdwlIpcOutputV2) SetYHandler(f ZdwlIpcOutputV2YHandlerFunc) { + i.yHandler = f +} + +// ZdwlIpcOutputV2WidthEvent : Update the width +// +// Indicates if width of the selected client. +type ZdwlIpcOutputV2WidthEvent struct { + Width int32 +} +type ZdwlIpcOutputV2WidthHandlerFunc func(ZdwlIpcOutputV2WidthEvent) + +// SetWidthHandler : sets handler for ZdwlIpcOutputV2WidthEvent +func (i *ZdwlIpcOutputV2) SetWidthHandler(f ZdwlIpcOutputV2WidthHandlerFunc) { + i.widthHandler = f +} + +// ZdwlIpcOutputV2HeightEvent : Update the height +// +// Indicates if height of the selected client. +type ZdwlIpcOutputV2HeightEvent struct { + Height int32 +} +type ZdwlIpcOutputV2HeightHandlerFunc func(ZdwlIpcOutputV2HeightEvent) + +// SetHeightHandler : sets handler for ZdwlIpcOutputV2HeightEvent +func (i *ZdwlIpcOutputV2) SetHeightHandler(f ZdwlIpcOutputV2HeightHandlerFunc) { + i.heightHandler = f +} + +// ZdwlIpcOutputV2LastLayerEvent : last map layer. +// +// last map layer. +type ZdwlIpcOutputV2LastLayerEvent struct { + LastLayer string +} +type ZdwlIpcOutputV2LastLayerHandlerFunc func(ZdwlIpcOutputV2LastLayerEvent) + +// SetLastLayerHandler : sets handler for ZdwlIpcOutputV2LastLayerEvent +func (i *ZdwlIpcOutputV2) SetLastLayerHandler(f ZdwlIpcOutputV2LastLayerHandlerFunc) { + i.lastLayerHandler = f +} + +// ZdwlIpcOutputV2KbLayoutEvent : current keyboard layout. +// +// current keyboard layout. +type ZdwlIpcOutputV2KbLayoutEvent struct { + KbLayout string +} +type ZdwlIpcOutputV2KbLayoutHandlerFunc func(ZdwlIpcOutputV2KbLayoutEvent) + +// SetKbLayoutHandler : sets handler for ZdwlIpcOutputV2KbLayoutEvent +func (i *ZdwlIpcOutputV2) SetKbLayoutHandler(f ZdwlIpcOutputV2KbLayoutHandlerFunc) { + i.kbLayoutHandler = f +} + +// ZdwlIpcOutputV2KeymodeEvent : current keybind mode. +// +// current keybind mode. +type ZdwlIpcOutputV2KeymodeEvent struct { + Keymode string +} +type ZdwlIpcOutputV2KeymodeHandlerFunc func(ZdwlIpcOutputV2KeymodeEvent) + +// SetKeymodeHandler : sets handler for ZdwlIpcOutputV2KeymodeEvent +func (i *ZdwlIpcOutputV2) SetKeymodeHandler(f ZdwlIpcOutputV2KeymodeHandlerFunc) { + i.keymodeHandler = f +} + +// ZdwlIpcOutputV2ScalefactorEvent : scale factor of monitor. +// +// scale factor of monitor. +type ZdwlIpcOutputV2ScalefactorEvent struct { + Scalefactor uint32 +} +type ZdwlIpcOutputV2ScalefactorHandlerFunc func(ZdwlIpcOutputV2ScalefactorEvent) + +// SetScalefactorHandler : sets handler for ZdwlIpcOutputV2ScalefactorEvent +func (i *ZdwlIpcOutputV2) SetScalefactorHandler(f ZdwlIpcOutputV2ScalefactorHandlerFunc) { + i.scalefactorHandler = f +} + +func (i *ZdwlIpcOutputV2) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.toggleVisibilityHandler == nil { + return + } + var e ZdwlIpcOutputV2ToggleVisibilityEvent + + i.toggleVisibilityHandler(e) + case 1: + if i.activeHandler == nil { + return + } + var e ZdwlIpcOutputV2ActiveEvent + l := 0 + e.Active = client.Uint32(data[l : l+4]) + l += 4 + + i.activeHandler(e) + case 2: + if i.tagHandler == nil { + return + } + var e ZdwlIpcOutputV2TagEvent + l := 0 + e.Tag = client.Uint32(data[l : l+4]) + l += 4 + e.State = client.Uint32(data[l : l+4]) + l += 4 + e.Clients = client.Uint32(data[l : l+4]) + l += 4 + e.Focused = client.Uint32(data[l : l+4]) + l += 4 + + i.tagHandler(e) + case 3: + if i.layoutHandler == nil { + return + } + var e ZdwlIpcOutputV2LayoutEvent + l := 0 + e.Layout = client.Uint32(data[l : l+4]) + l += 4 + + i.layoutHandler(e) + case 4: + if i.titleHandler == nil { + return + } + var e ZdwlIpcOutputV2TitleEvent + l := 0 + titleLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Title = client.String(data[l : l+titleLen]) + l += titleLen + + i.titleHandler(e) + case 5: + if i.appidHandler == nil { + return + } + var e ZdwlIpcOutputV2AppidEvent + l := 0 + appidLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Appid = client.String(data[l : l+appidLen]) + l += appidLen + + i.appidHandler(e) + case 6: + if i.layoutSymbolHandler == nil { + return + } + var e ZdwlIpcOutputV2LayoutSymbolEvent + l := 0 + layoutLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Layout = client.String(data[l : l+layoutLen]) + l += layoutLen + + i.layoutSymbolHandler(e) + case 7: + if i.frameHandler == nil { + return + } + var e ZdwlIpcOutputV2FrameEvent + + i.frameHandler(e) + case 8: + if i.fullscreenHandler == nil { + return + } + var e ZdwlIpcOutputV2FullscreenEvent + l := 0 + e.IsFullscreen = client.Uint32(data[l : l+4]) + l += 4 + + i.fullscreenHandler(e) + case 9: + if i.floatingHandler == nil { + return + } + var e ZdwlIpcOutputV2FloatingEvent + l := 0 + e.IsFloating = client.Uint32(data[l : l+4]) + l += 4 + + i.floatingHandler(e) + case 10: + if i.xHandler == nil { + return + } + var e ZdwlIpcOutputV2XEvent + l := 0 + e.X = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.xHandler(e) + case 11: + if i.yHandler == nil { + return + } + var e ZdwlIpcOutputV2YEvent + l := 0 + e.Y = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.yHandler(e) + case 12: + if i.widthHandler == nil { + return + } + var e ZdwlIpcOutputV2WidthEvent + l := 0 + e.Width = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.widthHandler(e) + case 13: + if i.heightHandler == nil { + return + } + var e ZdwlIpcOutputV2HeightEvent + l := 0 + e.Height = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.heightHandler(e) + case 14: + if i.lastLayerHandler == nil { + return + } + var e ZdwlIpcOutputV2LastLayerEvent + l := 0 + lastLayerLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.LastLayer = client.String(data[l : l+lastLayerLen]) + l += lastLayerLen + + i.lastLayerHandler(e) + case 15: + if i.kbLayoutHandler == nil { + return + } + var e ZdwlIpcOutputV2KbLayoutEvent + l := 0 + kbLayoutLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.KbLayout = client.String(data[l : l+kbLayoutLen]) + l += kbLayoutLen + + i.kbLayoutHandler(e) + case 16: + if i.keymodeHandler == nil { + return + } + var e ZdwlIpcOutputV2KeymodeEvent + l := 0 + keymodeLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Keymode = client.String(data[l : l+keymodeLen]) + l += keymodeLen + + i.keymodeHandler(e) + case 17: + if i.scalefactorHandler == nil { + return + } + var e ZdwlIpcOutputV2ScalefactorEvent + l := 0 + e.Scalefactor = client.Uint32(data[l : l+4]) + l += 4 + + i.scalefactorHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/ext_data_control/data_control.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/ext_data_control/data_control.go new file mode 100644 index 0000000..3a4de9f --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/ext_data_control/data_control.go @@ -0,0 +1,695 @@ +// Generated by go-wayland-scanner +// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner +// XML file : internal/proto/xml/ext-data-control-v1.xml +// +// ext_data_control_v1 Protocol Copyright: +// +// Copyright © 2018 Simon Ser +// Copyright © 2019 Ivan Molodetskikh +// Copyright © 2024 Neal Gompa +// +// Permission to use, copy, modify, distribute, and sell this +// software and its documentation for any purpose is hereby granted +// without fee, provided that the above copyright notice appear in +// all copies and that both that copyright notice and this permission +// notice appear in supporting documentation, and that the name of +// the copyright holders not be used in advertising or publicity +// pertaining to distribution of the software without specific, +// written prior permission. The copyright holders make no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. +// +// THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +// SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +// SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +// THIS SOFTWARE. + +package ext_data_control + +import ( + "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + "golang.org/x/sys/unix" +) + +// ExtDataControlManagerV1InterfaceName 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 ExtDataControlManagerV1InterfaceName = "ext_data_control_manager_v1" + +// ExtDataControlManagerV1 : manager to control data devices +// +// This interface is a manager that allows creating per-seat data device +// controls. +type ExtDataControlManagerV1 struct { + client.BaseProxy +} + +// NewExtDataControlManagerV1 : manager to control data devices +// +// This interface is a manager that allows creating per-seat data device +// controls. +func NewExtDataControlManagerV1(ctx *client.Context) *ExtDataControlManagerV1 { + extDataControlManagerV1 := &ExtDataControlManagerV1{} + ctx.Register(extDataControlManagerV1) + return extDataControlManagerV1 +} + +// CreateDataSource : create a new data source +// +// Create a new data source. +func (i *ExtDataControlManagerV1) CreateDataSource() (*ExtDataControlSourceV1, error) { + id := NewExtDataControlSourceV1(i.Context()) + const opcode = 0 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// GetDataDevice : get a data device for a seat +// +// Create a data device that can be used to manage a seat's selection. +func (i *ExtDataControlManagerV1) GetDataDevice(seat *client.Seat) (*ExtDataControlDeviceV1, error) { + id := NewExtDataControlDeviceV1(i.Context()) + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], seat.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// GetDataDeviceWithProxy : get a data device for a seat using a pre-created proxy +// +// Like GetDataDevice, but uses a pre-created ExtDataControlDeviceV1 proxy. +// This allows setting up event handlers before the request is sent. +func (i *ExtDataControlManagerV1) GetDataDeviceWithProxy(device *ExtDataControlDeviceV1, seat *client.Seat) error { + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], device.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], seat.ID()) + l += 4 + return i.Context().WriteMsg(_reqBuf[:], nil) +} + +// Destroy : destroy the manager +// +// All objects created by the manager will still remain valid, until their +// appropriate destroy request has been called. +func (i *ExtDataControlManagerV1) Destroy() error { + defer i.MarkZombie() + const opcode = 2 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ExtDataControlDeviceV1InterfaceName 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 ExtDataControlDeviceV1InterfaceName = "ext_data_control_device_v1" + +// ExtDataControlDeviceV1 : manage a data device for a seat +// +// This interface allows a client to manage a seat's selection. +// +// When the seat is destroyed, this object becomes inert. +type ExtDataControlDeviceV1 struct { + client.BaseProxy + dataOfferHandler ExtDataControlDeviceV1DataOfferHandlerFunc + selectionHandler ExtDataControlDeviceV1SelectionHandlerFunc + finishedHandler ExtDataControlDeviceV1FinishedHandlerFunc + primarySelectionHandler ExtDataControlDeviceV1PrimarySelectionHandlerFunc +} + +// NewExtDataControlDeviceV1 : manage a data device for a seat +// +// This interface allows a client to manage a seat's selection. +// +// When the seat is destroyed, this object becomes inert. +func NewExtDataControlDeviceV1(ctx *client.Context) *ExtDataControlDeviceV1 { + extDataControlDeviceV1 := &ExtDataControlDeviceV1{} + ctx.Register(extDataControlDeviceV1) + return extDataControlDeviceV1 +} + +// 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. +// +// The given source may not be used in any further set_selection or +// set_primary_selection requests. Attempting to use a previously used +// source triggers the used_source protocol error. +// +// To unset the selection, set the source to NULL. +func (i *ExtDataControlDeviceV1) SetSelection(source *ExtDataControlSourceV1) error { + const opcode = 0 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + if source == nil { + client.PutUint32(_reqBuf[l:l+4], 0) + l += 4 + } else { + client.PutUint32(_reqBuf[l:l+4], source.ID()) + l += 4 + } + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Destroy : destroy this data device +// +// Destroys the data device object. +func (i *ExtDataControlDeviceV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetPrimarySelection : copy data to the primary selection +// +// This request asks the compositor to set the primary selection to the +// data from the source on behalf of the client. +// +// The given source may not be used in any further set_selection or +// set_primary_selection requests. Attempting to use a previously used +// source triggers the used_source protocol error. +// +// To unset the primary selection, set the source to NULL. +// +// The compositor will ignore this request if it does not support primary +// selection. +func (i *ExtDataControlDeviceV1) SetPrimarySelection(source *ExtDataControlSourceV1) error { + const opcode = 2 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + if source == nil { + client.PutUint32(_reqBuf[l:l+4], 0) + l += 4 + } else { + client.PutUint32(_reqBuf[l:l+4], source.ID()) + l += 4 + } + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ExtDataControlDeviceV1Error uint32 + +// ExtDataControlDeviceV1Error : +const ( + // ExtDataControlDeviceV1ErrorUsedSource : source given to set_selection or set_primary_selection was already used before + ExtDataControlDeviceV1ErrorUsedSource ExtDataControlDeviceV1Error = 1 +) + +func (e ExtDataControlDeviceV1Error) Name() string { + switch e { + case ExtDataControlDeviceV1ErrorUsedSource: + return "used_source" + default: + return "" + } +} + +func (e ExtDataControlDeviceV1Error) Value() string { + switch e { + case ExtDataControlDeviceV1ErrorUsedSource: + return "1" + default: + return "" + } +} + +func (e ExtDataControlDeviceV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +// ExtDataControlDeviceV1DataOfferEvent : introduce a new ext_data_control_offer +// +// The data_offer event introduces a new ext_data_control_offer object, +// which will subsequently be used in either the +// ext_data_control_device.selection event (for the regular clipboard +// selections) or the ext_data_control_device.primary_selection event (for +// the primary clipboard selections). Immediately following the +// ext_data_control_device.data_offer event, the new data_offer object +// will send out ext_data_control_offer.offer events to describe the MIME +// types it offers. +type ExtDataControlDeviceV1DataOfferEvent struct { + Id *ExtDataControlOfferV1 +} +type ExtDataControlDeviceV1DataOfferHandlerFunc func(ExtDataControlDeviceV1DataOfferEvent) + +// SetDataOfferHandler : sets handler for ExtDataControlDeviceV1DataOfferEvent +func (i *ExtDataControlDeviceV1) SetDataOfferHandler(f ExtDataControlDeviceV1DataOfferHandlerFunc) { + i.dataOfferHandler = f +} + +// ExtDataControlDeviceV1SelectionEvent : advertise new selection +// +// The selection event is sent out to notify the client of a new +// ext_data_control_offer for the selection for this device. The +// ext_data_control_device.data_offer and the ext_data_control_offer.offer +// events are sent out immediately before this event to introduce the data +// offer object. The selection event is sent to a client when a new +// selection is set. The ext_data_control_offer is valid until a new +// ext_data_control_offer or NULL is received. The client must destroy the +// previous selection ext_data_control_offer, if any, upon receiving this +// event. Regardless, the previous selection will be ignored once a new +// selection ext_data_control_offer is received. +// +// The first selection event is sent upon binding the +// ext_data_control_device object. +type ExtDataControlDeviceV1SelectionEvent struct { + Id *ExtDataControlOfferV1 + OfferId uint32 // Raw object ID for external registry lookups +} +type ExtDataControlDeviceV1SelectionHandlerFunc func(ExtDataControlDeviceV1SelectionEvent) + +// SetSelectionHandler : sets handler for ExtDataControlDeviceV1SelectionEvent +func (i *ExtDataControlDeviceV1) SetSelectionHandler(f ExtDataControlDeviceV1SelectionHandlerFunc) { + i.selectionHandler = f +} + +// ExtDataControlDeviceV1FinishedEvent : this data control is no longer valid +// +// This data control object is no longer valid and should be destroyed by +// the client. +type ExtDataControlDeviceV1FinishedEvent struct{} +type ExtDataControlDeviceV1FinishedHandlerFunc func(ExtDataControlDeviceV1FinishedEvent) + +// SetFinishedHandler : sets handler for ExtDataControlDeviceV1FinishedEvent +func (i *ExtDataControlDeviceV1) SetFinishedHandler(f ExtDataControlDeviceV1FinishedHandlerFunc) { + i.finishedHandler = f +} + +// ExtDataControlDeviceV1PrimarySelectionEvent : advertise new primary selection +// +// The primary_selection event is sent out to notify the client of a new +// ext_data_control_offer for the primary selection for this device. The +// ext_data_control_device.data_offer and the ext_data_control_offer.offer +// events are sent out immediately before this event to introduce the data +// offer object. The primary_selection event is sent to a client when a +// new primary selection is set. The ext_data_control_offer is valid until +// a new ext_data_control_offer or NULL is received. The client must +// destroy the previous primary selection ext_data_control_offer, if any, +// upon receiving this event. Regardless, the previous primary selection +// will be ignored once a new primary selection ext_data_control_offer is +// received. +// +// If the compositor supports primary selection, the first +// primary_selection event is sent upon binding the +// ext_data_control_device object. +type ExtDataControlDeviceV1PrimarySelectionEvent struct { + Id *ExtDataControlOfferV1 + OfferId uint32 // Raw object ID for external registry lookups +} +type ExtDataControlDeviceV1PrimarySelectionHandlerFunc func(ExtDataControlDeviceV1PrimarySelectionEvent) + +// SetPrimarySelectionHandler : sets handler for ExtDataControlDeviceV1PrimarySelectionEvent +func (i *ExtDataControlDeviceV1) SetPrimarySelectionHandler(f ExtDataControlDeviceV1PrimarySelectionHandlerFunc) { + i.primarySelectionHandler = f +} + +func (i *ExtDataControlDeviceV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + // data_offer event: server creates a new object (new_id) + if i.dataOfferHandler == nil { + return + } + var e ExtDataControlDeviceV1DataOfferEvent + l := 0 + newID := client.Uint32(data[l : l+4]) + l += 4 + + ctx := i.Context() + offer := &ExtDataControlOfferV1{} + offer.SetContext(ctx) + offer.SetID(newID) + ctx.RegisterWithID(offer, newID) + e.Id = offer + + i.dataOfferHandler(e) + case 1: + // selection event: nullable object reference + if i.selectionHandler == nil { + return + } + var e ExtDataControlDeviceV1SelectionEvent + l := 0 + objID := client.Uint32(data[l : l+4]) + l += 4 + + e.OfferId = objID + if objID != 0 { + if p := i.Context().GetProxy(objID); p != nil { + e.Id = p.(*ExtDataControlOfferV1) + } + } + + i.selectionHandler(e) + case 2: + if i.finishedHandler == nil { + return + } + var e ExtDataControlDeviceV1FinishedEvent + + i.finishedHandler(e) + case 3: + // primary_selection event: nullable object reference + if i.primarySelectionHandler == nil { + return + } + var e ExtDataControlDeviceV1PrimarySelectionEvent + l := 0 + objID := client.Uint32(data[l : l+4]) + l += 4 + + e.OfferId = objID + if objID != 0 { + if p := i.Context().GetProxy(objID); p != nil { + e.Id = p.(*ExtDataControlOfferV1) + } + } + + i.primarySelectionHandler(e) + } +} + +// ExtDataControlSourceV1InterfaceName 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 ExtDataControlSourceV1InterfaceName = "ext_data_control_source_v1" + +// ExtDataControlSourceV1 : offer to transfer data +// +// The ext_data_control_source object is the source side of a +// ext_data_control_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 ExtDataControlSourceV1 struct { + client.BaseProxy + sendHandler ExtDataControlSourceV1SendHandlerFunc + cancelledHandler ExtDataControlSourceV1CancelledHandlerFunc +} + +// NewExtDataControlSourceV1 : offer to transfer data +// +// The ext_data_control_source object is the source side of a +// ext_data_control_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 NewExtDataControlSourceV1(ctx *client.Context) *ExtDataControlSourceV1 { + extDataControlSourceV1 := &ExtDataControlSourceV1{} + ctx.Register(extDataControlSourceV1) + return extDataControlSourceV1 +} + +// 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. +// +// Calling this after ext_data_control_device.set_selection is a protocol +// error. +// +// mimeType: MIME type offered by the data source +func (i *ExtDataControlSourceV1) Offer(mimeType string) error { + const opcode = 0 + mimeTypeLen := client.PaddedLen(len(mimeType) + 1) + _reqBufLen := 8 + (4 + mimeTypeLen) + _reqBuf := make([]byte, _reqBufLen) + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutString(_reqBuf[l:l+(4+mimeTypeLen)], mimeType) + l += (4 + mimeTypeLen) + err := i.Context().WriteMsg(_reqBuf, nil) + return err +} + +// Destroy : destroy this source +// +// Destroys the data source object. +func (i *ExtDataControlSourceV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ExtDataControlSourceV1Error uint32 + +// ExtDataControlSourceV1Error : +const ( + // ExtDataControlSourceV1ErrorInvalidOffer : offer sent after ext_data_control_device.set_selection + ExtDataControlSourceV1ErrorInvalidOffer ExtDataControlSourceV1Error = 1 +) + +func (e ExtDataControlSourceV1Error) Name() string { + switch e { + case ExtDataControlSourceV1ErrorInvalidOffer: + return "invalid_offer" + default: + return "" + } +} + +func (e ExtDataControlSourceV1Error) Value() string { + switch e { + case ExtDataControlSourceV1ErrorInvalidOffer: + return "1" + default: + return "" + } +} + +func (e ExtDataControlSourceV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +// ExtDataControlSourceV1SendEvent : 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 ExtDataControlSourceV1SendEvent struct { + MimeType string + Fd int +} +type ExtDataControlSourceV1SendHandlerFunc func(ExtDataControlSourceV1SendEvent) + +// SetSendHandler : sets handler for ExtDataControlSourceV1SendEvent +func (i *ExtDataControlSourceV1) SetSendHandler(f ExtDataControlSourceV1SendHandlerFunc) { + i.sendHandler = f +} + +// ExtDataControlSourceV1CancelledEvent : selection was cancelled +// +// This data source is no longer valid. The data source has been replaced +// by another data source. +// +// The client should clean up and destroy this data source. +type ExtDataControlSourceV1CancelledEvent struct{} +type ExtDataControlSourceV1CancelledHandlerFunc func(ExtDataControlSourceV1CancelledEvent) + +// SetCancelledHandler : sets handler for ExtDataControlSourceV1CancelledEvent +func (i *ExtDataControlSourceV1) SetCancelledHandler(f ExtDataControlSourceV1CancelledHandlerFunc) { + i.cancelledHandler = f +} + +func (i *ExtDataControlSourceV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.sendHandler == nil { + if fd != -1 { + unix.Close(fd) + } + return + } + var e ExtDataControlSourceV1SendEvent + l := 0 + mimeTypeLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.MimeType = client.String(data[l : l+mimeTypeLen]) + l += mimeTypeLen + e.Fd = fd + + i.sendHandler(e) + case 1: + if i.cancelledHandler == nil { + return + } + var e ExtDataControlSourceV1CancelledEvent + + i.cancelledHandler(e) + } +} + +// ExtDataControlOfferV1InterfaceName 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 ExtDataControlOfferV1InterfaceName = "ext_data_control_offer_v1" + +// ExtDataControlOfferV1 : offer to transfer data +// +// A ext_data_control_offer represents a piece of data offered for transfer +// by another client (the source client). 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 ExtDataControlOfferV1 struct { + client.BaseProxy + offerHandler ExtDataControlOfferV1OfferHandlerFunc +} + +// NewExtDataControlOfferV1 : offer to transfer data +// +// A ext_data_control_offer represents a piece of data offered for transfer +// by another client (the source client). 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 NewExtDataControlOfferV1(ctx *client.Context) *ExtDataControlOfferV1 { + extDataControlOfferV1 := &ExtDataControlOfferV1{} + ctx.Register(extDataControlOfferV1) + return extDataControlOfferV1 +} + +// 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. +// +// mimeType: MIME type desired by receiver +// fd: file descriptor for data transfer +func (i *ExtDataControlOfferV1) Receive(mimeType string, fd int) error { + const opcode = 0 + mimeTypeLen := client.PaddedLen(len(mimeType) + 1) + _reqBufLen := 8 + (4 + mimeTypeLen) + _reqBuf := make([]byte, _reqBufLen) + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.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 this offer +// +// Destroys the data offer object. +func (i *ExtDataControlOfferV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ExtDataControlOfferV1OfferEvent : advertise offered MIME type +// +// Sent immediately after creating the ext_data_control_offer object. +// One event per offered MIME type. +type ExtDataControlOfferV1OfferEvent struct { + MimeType string +} +type ExtDataControlOfferV1OfferHandlerFunc func(ExtDataControlOfferV1OfferEvent) + +// SetOfferHandler : sets handler for ExtDataControlOfferV1OfferEvent +func (i *ExtDataControlOfferV1) SetOfferHandler(f ExtDataControlOfferV1OfferHandlerFunc) { + i.offerHandler = f +} + +func (i *ExtDataControlOfferV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.offerHandler == nil { + return + } + var e ExtDataControlOfferV1OfferEvent + l := 0 + mimeTypeLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.MimeType = client.String(data[l : l+mimeTypeLen]) + l += mimeTypeLen + + i.offerHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/ext_workspace/workspace.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/ext_workspace/workspace.go new file mode 100644 index 0000000..c76ab98 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/ext_workspace/workspace.go @@ -0,0 +1,1040 @@ +// Generated by go-wayland-scanner +// https://github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/cmd/go-wayland-scanner +// XML file : ext-workspace-v1.xml +// +// ext_workspace_v1 Protocol Copyright: +// +// Copyright © 2019 Christopher Billington +// Copyright © 2020 Ilia Bozhinov +// Copyright © 2022 Victoria Brekenfeld +// +// Permission to use, copy, modify, distribute, and sell this +// software and its documentation for any purpose is hereby granted +// without fee, provided that the above copyright notice appear in +// all copies and that both that copyright notice and this permission +// notice appear in supporting documentation, and that the name of +// the copyright holders not be used in advertising or publicity +// pertaining to distribution of the software without specific, +// written prior permission. The copyright holders make no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. +// +// THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +// SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +// SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +// THIS SOFTWARE. + +package ext_workspace + +import ( + "reflect" + "unsafe" + + "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + "github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap" +) + +// registerServerProxy registers a proxy with a server-assigned ID. +// This is necessary because go-wayland-scanner doesn't properly handle new_id arguments in events. +// In requests (like DWL), the client creates the ID via NewXxx(ctx) which calls ctx.Register(). +// In events (like ext-workspace), the server creates the ID and sends it, requiring manual registration. +// The Context.objects map is private with no public API for server IDs, requiring reflection. +func registerServerProxy(ctx *client.Context, proxy client.Proxy, serverID uint32) { + defer func() { + if r := recover(); r != nil { + return + } + }() + + ctxVal := reflect.ValueOf(ctx) + if ctxVal.Kind() != reflect.Ptr || ctxVal.IsNil() { + return + } + + ctxElem := ctxVal.Elem() + objectsField := ctxElem.FieldByName("objects") + if !objectsField.IsValid() { + return + } + + objectsMapPtr := unsafe.Pointer(objectsField.UnsafeAddr()) + objectsMap := (*syncmap.Map[uint32, client.Proxy])(objectsMapPtr) + objectsMap.Store(serverID, proxy) +} + +// ExtWorkspaceManagerV1InterfaceName 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 ExtWorkspaceManagerV1InterfaceName = "ext_workspace_manager_v1" + +// ExtWorkspaceManagerV1 : list and control workspaces +// +// Workspaces, also called virtual desktops, are groups of surfaces. A +// compositor with a concept of workspaces may only show some such groups of +// surfaces (those of 'active' workspaces) at a time. 'Activating' a +// workspace is a request for the compositor to display that workspace's +// surfaces as normal, whereas the compositor may hide or otherwise +// de-emphasise surfaces that are associated only with 'inactive' workspaces. +// Workspaces are grouped by which sets of outputs they correspond to, and +// may contain surfaces only from those outputs. In this way, it is possible +// for each output to have its own set of workspaces, or for all outputs (or +// any other arbitrary grouping) to share workspaces. Compositors may +// optionally conceptually arrange each group of workspaces in an +// N-dimensional grid. +// +// The purpose of this protocol is to enable the creation of taskbars and +// docks by providing them with a list of workspaces and their properties, +// and allowing them to activate and deactivate workspaces. +// +// After a client binds the ext_workspace_manager_v1, each workspace will be +// sent via the workspace event. +type ExtWorkspaceManagerV1 struct { + client.BaseProxy + workspaceGroupHandler ExtWorkspaceManagerV1WorkspaceGroupHandlerFunc + workspaceHandler ExtWorkspaceManagerV1WorkspaceHandlerFunc + doneHandler ExtWorkspaceManagerV1DoneHandlerFunc + finishedHandler ExtWorkspaceManagerV1FinishedHandlerFunc +} + +// NewExtWorkspaceManagerV1 : list and control workspaces +// +// Workspaces, also called virtual desktops, are groups of surfaces. A +// compositor with a concept of workspaces may only show some such groups of +// surfaces (those of 'active' workspaces) at a time. 'Activating' a +// workspace is a request for the compositor to display that workspace's +// surfaces as normal, whereas the compositor may hide or otherwise +// de-emphasise surfaces that are associated only with 'inactive' workspaces. +// Workspaces are grouped by which sets of outputs they correspond to, and +// may contain surfaces only from those outputs. In this way, it is possible +// for each output to have its own set of workspaces, or for all outputs (or +// any other arbitrary grouping) to share workspaces. Compositors may +// optionally conceptually arrange each group of workspaces in an +// N-dimensional grid. +// +// The purpose of this protocol is to enable the creation of taskbars and +// docks by providing them with a list of workspaces and their properties, +// and allowing them to activate and deactivate workspaces. +// +// After a client binds the ext_workspace_manager_v1, each workspace will be +// sent via the workspace event. +func NewExtWorkspaceManagerV1(ctx *client.Context) *ExtWorkspaceManagerV1 { + extWorkspaceManagerV1 := &ExtWorkspaceManagerV1{} + ctx.Register(extWorkspaceManagerV1) + return extWorkspaceManagerV1 +} + +// Commit : all requests about the workspaces have been sent +// +// The client must send this request after it has finished sending other +// requests. The compositor must process a series of requests preceding a +// commit request atomically. +// +// This allows changes to the workspace properties to be seen as atomic, +// even if they happen via multiple events, and even if they involve +// multiple ext_workspace_handle_v1 objects, for example, deactivating one +// workspace and activating another. +func (i *ExtWorkspaceManagerV1) Commit() error { + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Stop : stop sending events +// +// Indicates the client no longer wishes to receive events for new +// workspace groups. However the compositor may emit further workspace +// events, until the finished event is emitted. The compositor is expected +// to send the finished event eventually once the stop request has been processed. +// +// The client must not send any requests after this one, doing so will raise a wl_display +// invalid_object error. +func (i *ExtWorkspaceManagerV1) Stop() error { + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +func (i *ExtWorkspaceManagerV1) Destroy() error { + i.MarkZombie() + return nil +} + +// ExtWorkspaceManagerV1WorkspaceGroupEvent : a workspace group has been created +// +// This event is emitted whenever a new workspace group has been created. +// +// All initial details of the workspace group (outputs) will be +// sent immediately after this event via the corresponding events in +// ext_workspace_group_handle_v1 and ext_workspace_handle_v1. +type ExtWorkspaceManagerV1WorkspaceGroupEvent struct { + WorkspaceGroup *ExtWorkspaceGroupHandleV1 +} +type ExtWorkspaceManagerV1WorkspaceGroupHandlerFunc func(ExtWorkspaceManagerV1WorkspaceGroupEvent) + +// SetWorkspaceGroupHandler : sets handler for ExtWorkspaceManagerV1WorkspaceGroupEvent +func (i *ExtWorkspaceManagerV1) SetWorkspaceGroupHandler(f ExtWorkspaceManagerV1WorkspaceGroupHandlerFunc) { + i.workspaceGroupHandler = f +} + +// ExtWorkspaceManagerV1WorkspaceEvent : workspace has been created +// +// This event is emitted whenever a new workspace has been created. +// +// All initial details of the workspace (name, coordinates, state) will +// be sent immediately after this event via the corresponding events in +// ext_workspace_handle_v1. +// +// Workspaces start off unassigned to any workspace group. +type ExtWorkspaceManagerV1WorkspaceEvent struct { + Workspace *ExtWorkspaceHandleV1 +} +type ExtWorkspaceManagerV1WorkspaceHandlerFunc func(ExtWorkspaceManagerV1WorkspaceEvent) + +// SetWorkspaceHandler : sets handler for ExtWorkspaceManagerV1WorkspaceEvent +func (i *ExtWorkspaceManagerV1) SetWorkspaceHandler(f ExtWorkspaceManagerV1WorkspaceHandlerFunc) { + i.workspaceHandler = f +} + +// ExtWorkspaceManagerV1DoneEvent : all information about the workspaces and workspace groups has been sent +// +// This event is sent after all changes in all workspaces and workspace groups have been +// sent. +// +// This allows changes to one or more ext_workspace_group_handle_v1 +// properties and ext_workspace_handle_v1 properties +// to be seen as atomic, even if they happen via multiple events. +// In particular, an output moving from one workspace group to +// another sends an output_enter event and an output_leave event to the two +// ext_workspace_group_handle_v1 objects in question. The compositor sends +// the done event only after updating the output information in both +// workspace groups. +type ExtWorkspaceManagerV1DoneEvent struct{} +type ExtWorkspaceManagerV1DoneHandlerFunc func(ExtWorkspaceManagerV1DoneEvent) + +// SetDoneHandler : sets handler for ExtWorkspaceManagerV1DoneEvent +func (i *ExtWorkspaceManagerV1) SetDoneHandler(f ExtWorkspaceManagerV1DoneHandlerFunc) { + i.doneHandler = f +} + +// ExtWorkspaceManagerV1FinishedEvent : the compositor has finished with the workspace_manager +// +// This event indicates that the compositor is done sending events to the +// ext_workspace_manager_v1. The server will destroy the object +// immediately after sending this request. +type ExtWorkspaceManagerV1FinishedEvent struct{} +type ExtWorkspaceManagerV1FinishedHandlerFunc func(ExtWorkspaceManagerV1FinishedEvent) + +// SetFinishedHandler : sets handler for ExtWorkspaceManagerV1FinishedEvent +func (i *ExtWorkspaceManagerV1) SetFinishedHandler(f ExtWorkspaceManagerV1FinishedHandlerFunc) { + i.finishedHandler = f +} + +func (i *ExtWorkspaceManagerV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.workspaceGroupHandler == nil { + return + } + var e ExtWorkspaceManagerV1WorkspaceGroupEvent + l := 0 + objectID := client.Uint32(data[l : l+4]) + proxy := i.Context().GetProxy(objectID) + if proxy != nil && !proxy.IsZombie() { + e.WorkspaceGroup = proxy.(*ExtWorkspaceGroupHandleV1) + } else { + groupHandle := &ExtWorkspaceGroupHandleV1{} + groupHandle.SetContext(i.Context()) + groupHandle.SetID(objectID) + registerServerProxy(i.Context(), groupHandle, objectID) + e.WorkspaceGroup = groupHandle + } + l += 4 + + i.workspaceGroupHandler(e) + case 1: + if i.workspaceHandler == nil { + return + } + var e ExtWorkspaceManagerV1WorkspaceEvent + l := 0 + objectID := client.Uint32(data[l : l+4]) + proxy := i.Context().GetProxy(objectID) + if proxy != nil && !proxy.IsZombie() { + e.Workspace = proxy.(*ExtWorkspaceHandleV1) + } else { + wsHandle := &ExtWorkspaceHandleV1{} + wsHandle.SetContext(i.Context()) + wsHandle.SetID(objectID) + registerServerProxy(i.Context(), wsHandle, objectID) + e.Workspace = wsHandle + } + l += 4 + + i.workspaceHandler(e) + case 2: + if i.doneHandler == nil { + return + } + var e ExtWorkspaceManagerV1DoneEvent + + i.doneHandler(e) + case 3: + if i.finishedHandler == nil { + return + } + var e ExtWorkspaceManagerV1FinishedEvent + + i.finishedHandler(e) + } +} + +// ExtWorkspaceGroupHandleV1InterfaceName 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 ExtWorkspaceGroupHandleV1InterfaceName = "ext_workspace_group_handle_v1" + +// ExtWorkspaceGroupHandleV1 : a workspace group assigned to a set of outputs +// +// A ext_workspace_group_handle_v1 object represents a workspace group +// that is assigned a set of outputs and contains a number of workspaces. +// +// The set of outputs assigned to the workspace group is conveyed to the client via +// output_enter and output_leave events, and its workspaces are conveyed with +// workspace events. +// +// For example, a compositor which has a set of workspaces for each output may +// advertise a workspace group (and its workspaces) per output, whereas a compositor +// where a workspace spans all outputs may advertise a single workspace group for all +// outputs. +type ExtWorkspaceGroupHandleV1 struct { + client.BaseProxy + capabilitiesHandler ExtWorkspaceGroupHandleV1CapabilitiesHandlerFunc + outputEnterHandler ExtWorkspaceGroupHandleV1OutputEnterHandlerFunc + outputLeaveHandler ExtWorkspaceGroupHandleV1OutputLeaveHandlerFunc + workspaceEnterHandler ExtWorkspaceGroupHandleV1WorkspaceEnterHandlerFunc + workspaceLeaveHandler ExtWorkspaceGroupHandleV1WorkspaceLeaveHandlerFunc + removedHandler ExtWorkspaceGroupHandleV1RemovedHandlerFunc +} + +// NewExtWorkspaceGroupHandleV1 : a workspace group assigned to a set of outputs +// +// A ext_workspace_group_handle_v1 object represents a workspace group +// that is assigned a set of outputs and contains a number of workspaces. +// +// The set of outputs assigned to the workspace group is conveyed to the client via +// output_enter and output_leave events, and its workspaces are conveyed with +// workspace events. +// +// For example, a compositor which has a set of workspaces for each output may +// advertise a workspace group (and its workspaces) per output, whereas a compositor +// where a workspace spans all outputs may advertise a single workspace group for all +// outputs. +func NewExtWorkspaceGroupHandleV1(ctx *client.Context) *ExtWorkspaceGroupHandleV1 { + extWorkspaceGroupHandleV1 := &ExtWorkspaceGroupHandleV1{} + ctx.Register(extWorkspaceGroupHandleV1) + return extWorkspaceGroupHandleV1 +} + +// CreateWorkspace : create a new workspace +// +// Request that the compositor create a new workspace with the given name +// and assign it to this group. +// +// There is no guarantee that the compositor will create a new workspace, +// or that the created workspace will have the provided name. +func (i *ExtWorkspaceGroupHandleV1) CreateWorkspace(workspace string) error { + const opcode = 0 + workspaceLen := client.PaddedLen(len(workspace) + 1) + _reqBufLen := 8 + (4 + workspaceLen) + _reqBuf := make([]byte, _reqBufLen) + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutString(_reqBuf[l:l+(4+workspaceLen)], workspace) + l += (4 + workspaceLen) + err := i.Context().WriteMsg(_reqBuf, nil) + return err +} + +// Destroy : destroy the ext_workspace_group_handle_v1 object +// +// Destroys the ext_workspace_group_handle_v1 object. +// +// This request should be send either when the client does not want to +// use the workspace group object any more or after the removed event to finalize +// the destruction of the object. +func (i *ExtWorkspaceGroupHandleV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ExtWorkspaceGroupHandleV1GroupCapabilities uint32 + +// ExtWorkspaceGroupHandleV1GroupCapabilities : +const ( + // ExtWorkspaceGroupHandleV1GroupCapabilitiesCreateWorkspace : create_workspace request is available + ExtWorkspaceGroupHandleV1GroupCapabilitiesCreateWorkspace ExtWorkspaceGroupHandleV1GroupCapabilities = 1 +) + +func (e ExtWorkspaceGroupHandleV1GroupCapabilities) Name() string { + switch e { + case ExtWorkspaceGroupHandleV1GroupCapabilitiesCreateWorkspace: + return "create_workspace" + default: + return "" + } +} + +func (e ExtWorkspaceGroupHandleV1GroupCapabilities) Value() string { + switch e { + case ExtWorkspaceGroupHandleV1GroupCapabilitiesCreateWorkspace: + return "1" + default: + return "" + } +} + +func (e ExtWorkspaceGroupHandleV1GroupCapabilities) String() string { + return e.Name() + "=" + e.Value() +} + +// ExtWorkspaceGroupHandleV1CapabilitiesEvent : compositor capabilities +// +// This event advertises the capabilities supported by the compositor. If +// a capability isn't supported, clients should hide or disable the UI +// elements that expose this functionality. For instance, if the +// compositor doesn't advertise support for creating workspaces, a button +// triggering the create_workspace request should not be displayed. +// +// The compositor will ignore requests it doesn't support. For instance, +// a compositor which doesn't advertise support for creating workspaces will ignore +// create_workspace requests. +// +// Compositors must send this event once after creation of an +// ext_workspace_group_handle_v1. When the capabilities change, compositors +// must send this event again. +type ExtWorkspaceGroupHandleV1CapabilitiesEvent struct { + Capabilities uint32 +} +type ExtWorkspaceGroupHandleV1CapabilitiesHandlerFunc func(ExtWorkspaceGroupHandleV1CapabilitiesEvent) + +// SetCapabilitiesHandler : sets handler for ExtWorkspaceGroupHandleV1CapabilitiesEvent +func (i *ExtWorkspaceGroupHandleV1) SetCapabilitiesHandler(f ExtWorkspaceGroupHandleV1CapabilitiesHandlerFunc) { + i.capabilitiesHandler = f +} + +// ExtWorkspaceGroupHandleV1OutputEnterEvent : output assigned to workspace group +// +// This event is emitted whenever an output is assigned to the workspace +// group or a new `wl_output` object is bound by the client, which was already +// assigned to this workspace_group. +type ExtWorkspaceGroupHandleV1OutputEnterEvent struct { + Output *client.Output +} +type ExtWorkspaceGroupHandleV1OutputEnterHandlerFunc func(ExtWorkspaceGroupHandleV1OutputEnterEvent) + +// SetOutputEnterHandler : sets handler for ExtWorkspaceGroupHandleV1OutputEnterEvent +func (i *ExtWorkspaceGroupHandleV1) SetOutputEnterHandler(f ExtWorkspaceGroupHandleV1OutputEnterHandlerFunc) { + i.outputEnterHandler = f +} + +// ExtWorkspaceGroupHandleV1OutputLeaveEvent : output removed from workspace group +// +// This event is emitted whenever an output is removed from the workspace +// group. +type ExtWorkspaceGroupHandleV1OutputLeaveEvent struct { + Output *client.Output +} +type ExtWorkspaceGroupHandleV1OutputLeaveHandlerFunc func(ExtWorkspaceGroupHandleV1OutputLeaveEvent) + +// SetOutputLeaveHandler : sets handler for ExtWorkspaceGroupHandleV1OutputLeaveEvent +func (i *ExtWorkspaceGroupHandleV1) SetOutputLeaveHandler(f ExtWorkspaceGroupHandleV1OutputLeaveHandlerFunc) { + i.outputLeaveHandler = f +} + +// ExtWorkspaceGroupHandleV1WorkspaceEnterEvent : workspace added to workspace group +// +// This event is emitted whenever a workspace is assigned to this group. +// A workspace may only ever be assigned to a single group at a single point +// in time, but can be re-assigned during it's lifetime. +type ExtWorkspaceGroupHandleV1WorkspaceEnterEvent struct { + Workspace *ExtWorkspaceHandleV1 +} +type ExtWorkspaceGroupHandleV1WorkspaceEnterHandlerFunc func(ExtWorkspaceGroupHandleV1WorkspaceEnterEvent) + +// SetWorkspaceEnterHandler : sets handler for ExtWorkspaceGroupHandleV1WorkspaceEnterEvent +func (i *ExtWorkspaceGroupHandleV1) SetWorkspaceEnterHandler(f ExtWorkspaceGroupHandleV1WorkspaceEnterHandlerFunc) { + i.workspaceEnterHandler = f +} + +// ExtWorkspaceGroupHandleV1WorkspaceLeaveEvent : workspace removed from workspace group +// +// This event is emitted whenever a workspace is removed from this group. +type ExtWorkspaceGroupHandleV1WorkspaceLeaveEvent struct { + Workspace *ExtWorkspaceHandleV1 +} +type ExtWorkspaceGroupHandleV1WorkspaceLeaveHandlerFunc func(ExtWorkspaceGroupHandleV1WorkspaceLeaveEvent) + +// SetWorkspaceLeaveHandler : sets handler for ExtWorkspaceGroupHandleV1WorkspaceLeaveEvent +func (i *ExtWorkspaceGroupHandleV1) SetWorkspaceLeaveHandler(f ExtWorkspaceGroupHandleV1WorkspaceLeaveHandlerFunc) { + i.workspaceLeaveHandler = f +} + +// ExtWorkspaceGroupHandleV1RemovedEvent : this workspace group has been removed +// +// This event is send when the group associated with the ext_workspace_group_handle_v1 +// has been removed. After sending this request the compositor will immediately consider +// the object inert. Any requests will be ignored except the destroy request. +// It is guaranteed there won't be any more events referencing this +// ext_workspace_group_handle_v1. +// +// The compositor must remove all workspaces belonging to a workspace group +// via a workspace_leave event before removing the workspace group. +type ExtWorkspaceGroupHandleV1RemovedEvent struct{} +type ExtWorkspaceGroupHandleV1RemovedHandlerFunc func(ExtWorkspaceGroupHandleV1RemovedEvent) + +// SetRemovedHandler : sets handler for ExtWorkspaceGroupHandleV1RemovedEvent +func (i *ExtWorkspaceGroupHandleV1) SetRemovedHandler(f ExtWorkspaceGroupHandleV1RemovedHandlerFunc) { + i.removedHandler = f +} + +func (i *ExtWorkspaceGroupHandleV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.capabilitiesHandler == nil { + return + } + var e ExtWorkspaceGroupHandleV1CapabilitiesEvent + l := 0 + e.Capabilities = client.Uint32(data[l : l+4]) + l += 4 + + i.capabilitiesHandler(e) + case 1: + if i.outputEnterHandler == nil { + return + } + var e ExtWorkspaceGroupHandleV1OutputEnterEvent + l := 0 + e.Output = i.Context().GetProxy(client.Uint32(data[l : l+4])).(*client.Output) + l += 4 + + i.outputEnterHandler(e) + case 2: + if i.outputLeaveHandler == nil { + return + } + var e ExtWorkspaceGroupHandleV1OutputLeaveEvent + l := 0 + e.Output = i.Context().GetProxy(client.Uint32(data[l : l+4])).(*client.Output) + l += 4 + + i.outputLeaveHandler(e) + case 3: + if i.workspaceEnterHandler == nil { + return + } + var e ExtWorkspaceGroupHandleV1WorkspaceEnterEvent + l := 0 + e.Workspace = i.Context().GetProxy(client.Uint32(data[l : l+4])).(*ExtWorkspaceHandleV1) + l += 4 + + i.workspaceEnterHandler(e) + case 4: + if i.workspaceLeaveHandler == nil { + return + } + var e ExtWorkspaceGroupHandleV1WorkspaceLeaveEvent + l := 0 + e.Workspace = i.Context().GetProxy(client.Uint32(data[l : l+4])).(*ExtWorkspaceHandleV1) + l += 4 + + i.workspaceLeaveHandler(e) + case 5: + if i.removedHandler == nil { + return + } + var e ExtWorkspaceGroupHandleV1RemovedEvent + + i.removedHandler(e) + } +} + +// ExtWorkspaceHandleV1InterfaceName 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 ExtWorkspaceHandleV1InterfaceName = "ext_workspace_handle_v1" + +// ExtWorkspaceHandleV1 : a workspace handing a group of surfaces +// +// A ext_workspace_handle_v1 object represents a workspace that handles a +// group of surfaces. +// +// Each workspace has: +// - a name, conveyed to the client with the name event +// - potentially an id conveyed with the id event +// - a list of states, conveyed to the client with the state event +// - and optionally a set of coordinates, conveyed to the client with the +// coordinates event +// +// The client may request that the compositor activate or deactivate the workspace. +// +// Each workspace can belong to only a single workspace group. +// Depending on the compositor policy, there might be workspaces with +// the same name in different workspace groups, but these workspaces are still +// separate (e.g. one of them might be active while the other is not). +type ExtWorkspaceHandleV1 struct { + client.BaseProxy + idHandler ExtWorkspaceHandleV1IdHandlerFunc + nameHandler ExtWorkspaceHandleV1NameHandlerFunc + coordinatesHandler ExtWorkspaceHandleV1CoordinatesHandlerFunc + stateHandler ExtWorkspaceHandleV1StateHandlerFunc + capabilitiesHandler ExtWorkspaceHandleV1CapabilitiesHandlerFunc + removedHandler ExtWorkspaceHandleV1RemovedHandlerFunc +} + +// NewExtWorkspaceHandleV1 : a workspace handing a group of surfaces +// +// A ext_workspace_handle_v1 object represents a workspace that handles a +// group of surfaces. +// +// Each workspace has: +// - a name, conveyed to the client with the name event +// - potentially an id conveyed with the id event +// - a list of states, conveyed to the client with the state event +// - and optionally a set of coordinates, conveyed to the client with the +// coordinates event +// +// The client may request that the compositor activate or deactivate the workspace. +// +// Each workspace can belong to only a single workspace group. +// Depending on the compositor policy, there might be workspaces with +// the same name in different workspace groups, but these workspaces are still +// separate (e.g. one of them might be active while the other is not). +func NewExtWorkspaceHandleV1(ctx *client.Context) *ExtWorkspaceHandleV1 { + extWorkspaceHandleV1 := &ExtWorkspaceHandleV1{} + ctx.Register(extWorkspaceHandleV1) + return extWorkspaceHandleV1 +} + +// Destroy : destroy the ext_workspace_handle_v1 object +// +// Destroys the ext_workspace_handle_v1 object. +// +// This request should be made either when the client does not want to +// use the workspace object any more or after the remove event to finalize +// the destruction of the object. +func (i *ExtWorkspaceHandleV1) Destroy() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Activate : activate the workspace +// +// Request that this workspace be activated. +// +// There is no guarantee the workspace will be actually activated, and +// behaviour may be compositor-dependent. For example, activating a +// workspace may or may not deactivate all other workspaces in the same +// group. +func (i *ExtWorkspaceHandleV1) Activate() error { + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Deactivate : deactivate the workspace +// +// Request that this workspace be deactivated. +// +// There is no guarantee the workspace will be actually deactivated. +func (i *ExtWorkspaceHandleV1) Deactivate() error { + const opcode = 2 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Assign : assign workspace to group +// +// Requests that this workspace is assigned to the given workspace group. +// +// There is no guarantee the workspace will be assigned. +func (i *ExtWorkspaceHandleV1) Assign(workspaceGroup *ExtWorkspaceGroupHandleV1) error { + const opcode = 3 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], workspaceGroup.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Remove : remove the workspace +// +// Request that this workspace be removed. +// +// There is no guarantee the workspace will be actually removed. +func (i *ExtWorkspaceHandleV1) Remove() error { + const opcode = 4 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ExtWorkspaceHandleV1State uint32 + +// ExtWorkspaceHandleV1State : types of states on the workspace +// +// The different states that a workspace can have. +const ( + // ExtWorkspaceHandleV1StateActive : the workspace is active + ExtWorkspaceHandleV1StateActive ExtWorkspaceHandleV1State = 1 + // ExtWorkspaceHandleV1StateUrgent : the workspace requests attention + ExtWorkspaceHandleV1StateUrgent ExtWorkspaceHandleV1State = 2 + ExtWorkspaceHandleV1StateHidden ExtWorkspaceHandleV1State = 4 +) + +func (e ExtWorkspaceHandleV1State) Name() string { + switch e { + case ExtWorkspaceHandleV1StateActive: + return "active" + case ExtWorkspaceHandleV1StateUrgent: + return "urgent" + case ExtWorkspaceHandleV1StateHidden: + return "hidden" + default: + return "" + } +} + +func (e ExtWorkspaceHandleV1State) Value() string { + switch e { + case ExtWorkspaceHandleV1StateActive: + return "1" + case ExtWorkspaceHandleV1StateUrgent: + return "2" + case ExtWorkspaceHandleV1StateHidden: + return "4" + default: + return "" + } +} + +func (e ExtWorkspaceHandleV1State) String() string { + return e.Name() + "=" + e.Value() +} + +type ExtWorkspaceHandleV1WorkspaceCapabilities uint32 + +// ExtWorkspaceHandleV1WorkspaceCapabilities : +const ( + // ExtWorkspaceHandleV1WorkspaceCapabilitiesActivate : activate request is available + ExtWorkspaceHandleV1WorkspaceCapabilitiesActivate ExtWorkspaceHandleV1WorkspaceCapabilities = 1 + // ExtWorkspaceHandleV1WorkspaceCapabilitiesDeactivate : deactivate request is available + ExtWorkspaceHandleV1WorkspaceCapabilitiesDeactivate ExtWorkspaceHandleV1WorkspaceCapabilities = 2 + // ExtWorkspaceHandleV1WorkspaceCapabilitiesRemove : remove request is available + ExtWorkspaceHandleV1WorkspaceCapabilitiesRemove ExtWorkspaceHandleV1WorkspaceCapabilities = 4 + // ExtWorkspaceHandleV1WorkspaceCapabilitiesAssign : assign request is available + ExtWorkspaceHandleV1WorkspaceCapabilitiesAssign ExtWorkspaceHandleV1WorkspaceCapabilities = 8 +) + +func (e ExtWorkspaceHandleV1WorkspaceCapabilities) Name() string { + switch e { + case ExtWorkspaceHandleV1WorkspaceCapabilitiesActivate: + return "activate" + case ExtWorkspaceHandleV1WorkspaceCapabilitiesDeactivate: + return "deactivate" + case ExtWorkspaceHandleV1WorkspaceCapabilitiesRemove: + return "remove" + case ExtWorkspaceHandleV1WorkspaceCapabilitiesAssign: + return "assign" + default: + return "" + } +} + +func (e ExtWorkspaceHandleV1WorkspaceCapabilities) Value() string { + switch e { + case ExtWorkspaceHandleV1WorkspaceCapabilitiesActivate: + return "1" + case ExtWorkspaceHandleV1WorkspaceCapabilitiesDeactivate: + return "2" + case ExtWorkspaceHandleV1WorkspaceCapabilitiesRemove: + return "4" + case ExtWorkspaceHandleV1WorkspaceCapabilitiesAssign: + return "8" + default: + return "" + } +} + +func (e ExtWorkspaceHandleV1WorkspaceCapabilities) String() string { + return e.Name() + "=" + e.Value() +} + +// ExtWorkspaceHandleV1IdEvent : workspace id +// +// If this event is emitted, it will be send immediately after the +// ext_workspace_handle_v1 is created or when an id is assigned to +// a workspace (at most once during it's lifetime). +// +// An id will never change during the lifetime of the `ext_workspace_handle_v1` +// and is guaranteed to be unique during it's lifetime. +// +// Ids are not human-readable and shouldn't be displayed, use `name` for that purpose. +// +// Compositors are expected to only send ids for workspaces likely stable across multiple +// sessions and can be used by clients to store preferences for workspaces. Workspaces without +// ids should be considered temporary and any data associated with them should be deleted once +// the respective object is lost. +type ExtWorkspaceHandleV1IdEvent struct { + Id string +} +type ExtWorkspaceHandleV1IdHandlerFunc func(ExtWorkspaceHandleV1IdEvent) + +// SetIdHandler : sets handler for ExtWorkspaceHandleV1IdEvent +func (i *ExtWorkspaceHandleV1) SetIdHandler(f ExtWorkspaceHandleV1IdHandlerFunc) { + i.idHandler = f +} + +// ExtWorkspaceHandleV1NameEvent : workspace name changed +// +// This event is emitted immediately after the ext_workspace_handle_v1 is +// created and whenever the name of the workspace changes. +// +// A name is meant to be human-readable and can be displayed to a user. +// Unlike the id it is neither stable nor unique. +type ExtWorkspaceHandleV1NameEvent struct { + Name string +} +type ExtWorkspaceHandleV1NameHandlerFunc func(ExtWorkspaceHandleV1NameEvent) + +// SetNameHandler : sets handler for ExtWorkspaceHandleV1NameEvent +func (i *ExtWorkspaceHandleV1) SetNameHandler(f ExtWorkspaceHandleV1NameHandlerFunc) { + i.nameHandler = f +} + +// ExtWorkspaceHandleV1CoordinatesEvent : workspace coordinates changed +// +// This event is used to organize workspaces into an N-dimensional grid +// within a workspace group, and if supported, is emitted immediately after +// the ext_workspace_handle_v1 is created and whenever the coordinates of +// the workspace change. Compositors may not send this event if they do not +// conceptually arrange workspaces in this way. If compositors simply +// number workspaces, without any geometric interpretation, they may send +// 1D coordinates, which clients should not interpret as implying any +// geometry. Sending an empty array means that the compositor no longer +// orders the workspace geometrically. +// +// Coordinates have an arbitrary number of dimensions N with an uint32 +// position along each dimension. By convention if N > 1, the first +// dimension is X, the second Y, the third Z, and so on. The compositor may +// chose to utilize these events for a more novel workspace layout +// convention, however. No guarantee is made about the grid being filled or +// bounded; there may be a workspace at coordinate 1 and another at +// coordinate 1000 and none in between. Within a workspace group, however, +// workspaces must have unique coordinates of equal dimensionality. +type ExtWorkspaceHandleV1CoordinatesEvent struct { + Coordinates []byte +} +type ExtWorkspaceHandleV1CoordinatesHandlerFunc func(ExtWorkspaceHandleV1CoordinatesEvent) + +// SetCoordinatesHandler : sets handler for ExtWorkspaceHandleV1CoordinatesEvent +func (i *ExtWorkspaceHandleV1) SetCoordinatesHandler(f ExtWorkspaceHandleV1CoordinatesHandlerFunc) { + i.coordinatesHandler = f +} + +// ExtWorkspaceHandleV1StateEvent : the state of the workspace changed +// +// This event is emitted immediately after the ext_workspace_handle_v1 is +// created and each time the workspace state changes, either because of a +// compositor action or because of a request in this protocol. +// +// Missing states convey the opposite meaning, e.g. an unset active bit +// means the workspace is currently inactive. +type ExtWorkspaceHandleV1StateEvent struct { + State uint32 +} +type ExtWorkspaceHandleV1StateHandlerFunc func(ExtWorkspaceHandleV1StateEvent) + +// SetStateHandler : sets handler for ExtWorkspaceHandleV1StateEvent +func (i *ExtWorkspaceHandleV1) SetStateHandler(f ExtWorkspaceHandleV1StateHandlerFunc) { + i.stateHandler = f +} + +// ExtWorkspaceHandleV1CapabilitiesEvent : compositor capabilities +// +// This event advertises the capabilities supported by the compositor. If +// a capability isn't supported, clients should hide or disable the UI +// elements that expose this functionality. For instance, if the +// compositor doesn't advertise support for removing workspaces, a button +// triggering the remove request should not be displayed. +// +// The compositor will ignore requests it doesn't support. For instance, +// a compositor which doesn't advertise support for remove will ignore +// remove requests. +// +// Compositors must send this event once after creation of an +// ext_workspace_handle_v1 . When the capabilities change, compositors +// must send this event again. +type ExtWorkspaceHandleV1CapabilitiesEvent struct { + Capabilities uint32 +} +type ExtWorkspaceHandleV1CapabilitiesHandlerFunc func(ExtWorkspaceHandleV1CapabilitiesEvent) + +// SetCapabilitiesHandler : sets handler for ExtWorkspaceHandleV1CapabilitiesEvent +func (i *ExtWorkspaceHandleV1) SetCapabilitiesHandler(f ExtWorkspaceHandleV1CapabilitiesHandlerFunc) { + i.capabilitiesHandler = f +} + +// ExtWorkspaceHandleV1RemovedEvent : this workspace has been removed +// +// This event is send when the workspace associated with the ext_workspace_handle_v1 +// has been removed. After sending this request, the compositor will immediately consider +// the object inert. Any requests will be ignored except the destroy request. +// +// It is guaranteed there won't be any more events referencing this +// ext_workspace_handle_v1. +// +// The compositor must only remove a workspaces not currently belonging to any +// workspace_group. +type ExtWorkspaceHandleV1RemovedEvent struct{} +type ExtWorkspaceHandleV1RemovedHandlerFunc func(ExtWorkspaceHandleV1RemovedEvent) + +// SetRemovedHandler : sets handler for ExtWorkspaceHandleV1RemovedEvent +func (i *ExtWorkspaceHandleV1) SetRemovedHandler(f ExtWorkspaceHandleV1RemovedHandlerFunc) { + i.removedHandler = f +} + +func (i *ExtWorkspaceHandleV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.idHandler == nil { + return + } + var e ExtWorkspaceHandleV1IdEvent + l := 0 + idLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Id = client.String(data[l : l+idLen]) + l += idLen + + i.idHandler(e) + case 1: + if i.nameHandler == nil { + return + } + var e ExtWorkspaceHandleV1NameEvent + l := 0 + nameLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Name = client.String(data[l : l+nameLen]) + l += nameLen + + i.nameHandler(e) + case 2: + if i.coordinatesHandler == nil { + return + } + var e ExtWorkspaceHandleV1CoordinatesEvent + l := 0 + coordinatesLen := int(client.Uint32(data[l : l+4])) + l += 4 + e.Coordinates = make([]byte, coordinatesLen) + copy(e.Coordinates, data[l:l+coordinatesLen]) + l += coordinatesLen + + i.coordinatesHandler(e) + case 3: + if i.stateHandler == nil { + return + } + var e ExtWorkspaceHandleV1StateEvent + l := 0 + e.State = client.Uint32(data[l : l+4]) + l += 4 + + i.stateHandler(e) + case 4: + if i.capabilitiesHandler == nil { + return + } + var e ExtWorkspaceHandleV1CapabilitiesEvent + l := 0 + e.Capabilities = client.Uint32(data[l : l+4]) + l += 4 + + i.capabilitiesHandler(e) + case 5: + if i.removedHandler == nil { + return + } + var e ExtWorkspaceHandleV1RemovedEvent + + i.removedHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/keyboard_shortcuts_inhibit/keyboard_shortcuts_inhibit.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/keyboard_shortcuts_inhibit/keyboard_shortcuts_inhibit.go new file mode 100644 index 0000000..0a23bb2 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/keyboard_shortcuts_inhibit/keyboard_shortcuts_inhibit.go @@ -0,0 +1,284 @@ +// Generated by go-wayland-scanner +// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner +// XML file : internal/proto/xml/keyboard-shortcuts-inhibit-unstable-v1.xml +// +// keyboard_shortcuts_inhibit_unstable_v1 Protocol Copyright: +// +// Copyright © 2017 Red Hat Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice (including the next +// paragraph) shall be included in all copies or substantial portions of the +// Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +package keyboard_shortcuts_inhibit + +import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + +// ZwpKeyboardShortcutsInhibitManagerV1InterfaceName 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 ZwpKeyboardShortcutsInhibitManagerV1InterfaceName = "zwp_keyboard_shortcuts_inhibit_manager_v1" + +// ZwpKeyboardShortcutsInhibitManagerV1 : context object for keyboard grab_manager +// +// A global interface used for inhibiting the compositor keyboard shortcuts. +type ZwpKeyboardShortcutsInhibitManagerV1 struct { + client.BaseProxy +} + +// NewZwpKeyboardShortcutsInhibitManagerV1 : context object for keyboard grab_manager +// +// A global interface used for inhibiting the compositor keyboard shortcuts. +func NewZwpKeyboardShortcutsInhibitManagerV1(ctx *client.Context) *ZwpKeyboardShortcutsInhibitManagerV1 { + zwpKeyboardShortcutsInhibitManagerV1 := &ZwpKeyboardShortcutsInhibitManagerV1{} + ctx.Register(zwpKeyboardShortcutsInhibitManagerV1) + return zwpKeyboardShortcutsInhibitManagerV1 +} + +// Destroy : destroy the keyboard shortcuts inhibitor object +// +// Destroy the keyboard shortcuts inhibitor manager. +func (i *ZwpKeyboardShortcutsInhibitManagerV1) Destroy() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// InhibitShortcuts : create a new keyboard shortcuts inhibitor object +// +// Create a new keyboard shortcuts inhibitor object associated with +// the given surface for the given seat. +// +// If shortcuts are already inhibited for the specified seat and surface, +// a protocol error "already_inhibited" is raised by the compositor. +// +// surface: the surface that inhibits the keyboard shortcuts behavior +// seat: the wl_seat for which keyboard shortcuts should be disabled +func (i *ZwpKeyboardShortcutsInhibitManagerV1) InhibitShortcuts(surface *client.Surface, seat *client.Seat) (*ZwpKeyboardShortcutsInhibitorV1, error) { + id := NewZwpKeyboardShortcutsInhibitorV1(i.Context()) + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], surface.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], seat.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +type ZwpKeyboardShortcutsInhibitManagerV1Error uint32 + +// ZwpKeyboardShortcutsInhibitManagerV1Error : +const ( + // ZwpKeyboardShortcutsInhibitManagerV1ErrorAlreadyInhibited : the shortcuts are already inhibited for this surface + ZwpKeyboardShortcutsInhibitManagerV1ErrorAlreadyInhibited ZwpKeyboardShortcutsInhibitManagerV1Error = 0 +) + +func (e ZwpKeyboardShortcutsInhibitManagerV1Error) Name() string { + switch e { + case ZwpKeyboardShortcutsInhibitManagerV1ErrorAlreadyInhibited: + return "already_inhibited" + default: + return "" + } +} + +func (e ZwpKeyboardShortcutsInhibitManagerV1Error) Value() string { + switch e { + case ZwpKeyboardShortcutsInhibitManagerV1ErrorAlreadyInhibited: + return "0" + default: + return "" + } +} + +func (e ZwpKeyboardShortcutsInhibitManagerV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwpKeyboardShortcutsInhibitorV1InterfaceName 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 ZwpKeyboardShortcutsInhibitorV1InterfaceName = "zwp_keyboard_shortcuts_inhibitor_v1" + +// ZwpKeyboardShortcutsInhibitorV1 : context object for keyboard shortcuts inhibitor +// +// A keyboard shortcuts inhibitor instructs the compositor to ignore +// its own keyboard shortcuts when the associated surface has keyboard +// focus. As a result, when the surface has keyboard focus on the given +// seat, it will receive all key events originating from the specified +// seat, even those which would normally be caught by the compositor for +// its own shortcuts. +// +// The Wayland compositor is however under no obligation to disable +// all of its shortcuts, and may keep some special key combo for its own +// use, including but not limited to one allowing the user to forcibly +// restore normal keyboard events routing in the case of an unwilling +// client. The compositor may also use the same key combo to reactivate +// an existing shortcut inhibitor that was previously deactivated on +// user request. +// +// When the compositor restores its own keyboard shortcuts, an +// "inactive" event is emitted to notify the client that the keyboard +// shortcuts inhibitor is not effectively active for the surface and +// seat any more, and the client should not expect to receive all +// keyboard events. +// +// When the keyboard shortcuts inhibitor is inactive, the client has +// no way to forcibly reactivate the keyboard shortcuts inhibitor. +// +// The user can chose to re-enable a previously deactivated keyboard +// shortcuts inhibitor using any mechanism the compositor may offer, +// in which case the compositor will send an "active" event to notify +// the client. +// +// If the surface is destroyed, unmapped, or loses the seat's keyboard +// focus, the keyboard shortcuts inhibitor becomes irrelevant and the +// compositor will restore its own keyboard shortcuts but no "inactive" +// event is emitted in this case. +type ZwpKeyboardShortcutsInhibitorV1 struct { + client.BaseProxy + activeHandler ZwpKeyboardShortcutsInhibitorV1ActiveHandlerFunc + inactiveHandler ZwpKeyboardShortcutsInhibitorV1InactiveHandlerFunc +} + +// NewZwpKeyboardShortcutsInhibitorV1 : context object for keyboard shortcuts inhibitor +// +// A keyboard shortcuts inhibitor instructs the compositor to ignore +// its own keyboard shortcuts when the associated surface has keyboard +// focus. As a result, when the surface has keyboard focus on the given +// seat, it will receive all key events originating from the specified +// seat, even those which would normally be caught by the compositor for +// its own shortcuts. +// +// The Wayland compositor is however under no obligation to disable +// all of its shortcuts, and may keep some special key combo for its own +// use, including but not limited to one allowing the user to forcibly +// restore normal keyboard events routing in the case of an unwilling +// client. The compositor may also use the same key combo to reactivate +// an existing shortcut inhibitor that was previously deactivated on +// user request. +// +// When the compositor restores its own keyboard shortcuts, an +// "inactive" event is emitted to notify the client that the keyboard +// shortcuts inhibitor is not effectively active for the surface and +// seat any more, and the client should not expect to receive all +// keyboard events. +// +// When the keyboard shortcuts inhibitor is inactive, the client has +// no way to forcibly reactivate the keyboard shortcuts inhibitor. +// +// The user can chose to re-enable a previously deactivated keyboard +// shortcuts inhibitor using any mechanism the compositor may offer, +// in which case the compositor will send an "active" event to notify +// the client. +// +// If the surface is destroyed, unmapped, or loses the seat's keyboard +// focus, the keyboard shortcuts inhibitor becomes irrelevant and the +// compositor will restore its own keyboard shortcuts but no "inactive" +// event is emitted in this case. +func NewZwpKeyboardShortcutsInhibitorV1(ctx *client.Context) *ZwpKeyboardShortcutsInhibitorV1 { + zwpKeyboardShortcutsInhibitorV1 := &ZwpKeyboardShortcutsInhibitorV1{} + ctx.Register(zwpKeyboardShortcutsInhibitorV1) + return zwpKeyboardShortcutsInhibitorV1 +} + +// Destroy : destroy the keyboard shortcuts inhibitor object +// +// Remove the keyboard shortcuts inhibitor from the associated wl_surface. +func (i *ZwpKeyboardShortcutsInhibitorV1) Destroy() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ZwpKeyboardShortcutsInhibitorV1ActiveEvent : shortcuts are inhibited +// +// This event indicates that the shortcut inhibitor is active. +// +// The compositor sends this event every time compositor shortcuts +// are inhibited on behalf of the surface. When active, the client +// may receive input events normally reserved by the compositor +// (see zwp_keyboard_shortcuts_inhibitor_v1). +// +// This occurs typically when the initial request "inhibit_shortcuts" +// first becomes active or when the user instructs the compositor to +// re-enable and existing shortcuts inhibitor using any mechanism +// offered by the compositor. +type ZwpKeyboardShortcutsInhibitorV1ActiveEvent struct{} +type ZwpKeyboardShortcutsInhibitorV1ActiveHandlerFunc func(ZwpKeyboardShortcutsInhibitorV1ActiveEvent) + +// SetActiveHandler : sets handler for ZwpKeyboardShortcutsInhibitorV1ActiveEvent +func (i *ZwpKeyboardShortcutsInhibitorV1) SetActiveHandler(f ZwpKeyboardShortcutsInhibitorV1ActiveHandlerFunc) { + i.activeHandler = f +} + +// ZwpKeyboardShortcutsInhibitorV1InactiveEvent : shortcuts are restored +// +// This event indicates that the shortcuts inhibitor is inactive, +// normal shortcuts processing is restored by the compositor. +type ZwpKeyboardShortcutsInhibitorV1InactiveEvent struct{} +type ZwpKeyboardShortcutsInhibitorV1InactiveHandlerFunc func(ZwpKeyboardShortcutsInhibitorV1InactiveEvent) + +// SetInactiveHandler : sets handler for ZwpKeyboardShortcutsInhibitorV1InactiveEvent +func (i *ZwpKeyboardShortcutsInhibitorV1) SetInactiveHandler(f ZwpKeyboardShortcutsInhibitorV1InactiveHandlerFunc) { + i.inactiveHandler = f +} + +func (i *ZwpKeyboardShortcutsInhibitorV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.activeHandler == nil { + return + } + var e ZwpKeyboardShortcutsInhibitorV1ActiveEvent + + i.activeHandler(e) + case 1: + if i.inactiveHandler == nil { + return + } + var e ZwpKeyboardShortcutsInhibitorV1InactiveEvent + + i.inactiveHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_gamma_control/gamma_control.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_gamma_control/gamma_control.go new file mode 100644 index 0000000..a1cb429 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_gamma_control/gamma_control.go @@ -0,0 +1,268 @@ +// Generated by go-wayland-scanner +// https://github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/cmd/go-wayland-scanner +// XML file : wayland-protocols/wlr-gamma-control-unstable-v1.xml +// +// wlr_gamma_control_unstable_v1 Protocol Copyright: +// +// Copyright © 2015 Giulio camuffo +// Copyright © 2018 Simon Ser +// +// Permission to use, copy, modify, distribute, and sell this +// software and its documentation for any purpose is hereby granted +// without fee, provided that the above copyright notice appear in +// all copies and that both that copyright notice and this permission +// notice appear in supporting documentation, and that the name of +// the copyright holders not be used in advertising or publicity +// pertaining to distribution of the software without specific, +// written prior permission. The copyright holders make no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. +// +// THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +// SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +// SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +// THIS SOFTWARE. + +package wlr_gamma_control + +import ( + "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + "golang.org/x/sys/unix" +) + +// ZwlrGammaControlManagerV1InterfaceName 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 ZwlrGammaControlManagerV1InterfaceName = "zwlr_gamma_control_manager_v1" + +// ZwlrGammaControlManagerV1 : manager to create per-output gamma controls +// +// This interface is a manager that allows creating per-output gamma +// controls. +type ZwlrGammaControlManagerV1 struct { + client.BaseProxy +} + +// NewZwlrGammaControlManagerV1 : manager to create per-output gamma controls +// +// This interface is a manager that allows creating per-output gamma +// controls. +func NewZwlrGammaControlManagerV1(ctx *client.Context) *ZwlrGammaControlManagerV1 { + zwlrGammaControlManagerV1 := &ZwlrGammaControlManagerV1{} + ctx.Register(zwlrGammaControlManagerV1) + return zwlrGammaControlManagerV1 +} + +// GetGammaControl : get a gamma control for an output +// +// Create a gamma control that can be used to adjust gamma tables for the +// provided output. +func (i *ZwlrGammaControlManagerV1) GetGammaControl(output *client.Output) (*ZwlrGammaControlV1, error) { + id := NewZwlrGammaControlV1(i.Context()) + const opcode = 0 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], output.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// Destroy : destroy the manager +// +// All objects created by the manager will still remain valid, until their +// appropriate destroy request has been called. +func (i *ZwlrGammaControlManagerV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ZwlrGammaControlV1InterfaceName 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 ZwlrGammaControlV1InterfaceName = "zwlr_gamma_control_v1" + +// ZwlrGammaControlV1 : adjust gamma tables for an output +// +// This interface allows a client to adjust gamma tables for a particular +// output. +// +// The client will receive the gamma size, and will then be able to set gamma +// tables. At any time the compositor can send a failed event indicating that +// this object is no longer valid. +// +// There can only be at most one gamma control object per output, which +// has exclusive access to this particular output. When the gamma control +// object is destroyed, the gamma table is restored to its original value. +type ZwlrGammaControlV1 struct { + client.BaseProxy + gammaSizeHandler ZwlrGammaControlV1GammaSizeHandlerFunc + failedHandler ZwlrGammaControlV1FailedHandlerFunc +} + +// NewZwlrGammaControlV1 : adjust gamma tables for an output +// +// This interface allows a client to adjust gamma tables for a particular +// output. +// +// The client will receive the gamma size, and will then be able to set gamma +// tables. At any time the compositor can send a failed event indicating that +// this object is no longer valid. +// +// There can only be at most one gamma control object per output, which +// has exclusive access to this particular output. When the gamma control +// object is destroyed, the gamma table is restored to its original value. +func NewZwlrGammaControlV1(ctx *client.Context) *ZwlrGammaControlV1 { + zwlrGammaControlV1 := &ZwlrGammaControlV1{} + ctx.Register(zwlrGammaControlV1) + return zwlrGammaControlV1 +} + +// SetGamma : set the gamma table +// +// Set the gamma table. The file descriptor can be memory-mapped to provide +// the raw gamma table, which contains successive gamma ramps for the red, +// green and blue channels. Each gamma ramp is an array of 16-byte unsigned +// integers which has the same length as the gamma size. +// +// The file descriptor data must have the same length as three times the +// gamma size. +// +// fd: gamma table file descriptor +func (i *ZwlrGammaControlV1) SetGamma(fd int) error { + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + oob := unix.UnixRights(int(fd)) + err := i.Context().WriteMsg(_reqBuf[:], oob) + return err +} + +// Destroy : destroy this control +// +// Destroys the gamma control object. If the object is still valid, this +// restores the original gamma tables. +func (i *ZwlrGammaControlV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrGammaControlV1Error uint32 + +// ZwlrGammaControlV1Error : +const ( + // ZwlrGammaControlV1ErrorInvalidGamma : invalid gamma tables + ZwlrGammaControlV1ErrorInvalidGamma ZwlrGammaControlV1Error = 1 +) + +func (e ZwlrGammaControlV1Error) Name() string { + switch e { + case ZwlrGammaControlV1ErrorInvalidGamma: + return "invalid_gamma" + default: + return "" + } +} + +func (e ZwlrGammaControlV1Error) Value() string { + switch e { + case ZwlrGammaControlV1ErrorInvalidGamma: + return "1" + default: + return "" + } +} + +func (e ZwlrGammaControlV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrGammaControlV1GammaSizeEvent : size of gamma ramps +// +// Advertise the size of each gamma ramp. +// +// This event is sent immediately when the gamma control object is created. +type ZwlrGammaControlV1GammaSizeEvent struct { + Size uint32 +} +type ZwlrGammaControlV1GammaSizeHandlerFunc func(ZwlrGammaControlV1GammaSizeEvent) + +// SetGammaSizeHandler : sets handler for ZwlrGammaControlV1GammaSizeEvent +func (i *ZwlrGammaControlV1) SetGammaSizeHandler(f ZwlrGammaControlV1GammaSizeHandlerFunc) { + i.gammaSizeHandler = f +} + +// ZwlrGammaControlV1FailedEvent : object no longer valid +// +// This event indicates that the gamma control is no longer valid. This +// can happen for a number of reasons, including: +// - The output doesn't support gamma tables +// - Setting the gamma tables failed +// - Another client already has exclusive gamma control for this output +// - The compositor has transferred gamma control to another client +// +// Upon receiving this event, the client should destroy this object. +type ZwlrGammaControlV1FailedEvent struct{} +type ZwlrGammaControlV1FailedHandlerFunc func(ZwlrGammaControlV1FailedEvent) + +// SetFailedHandler : sets handler for ZwlrGammaControlV1FailedEvent +func (i *ZwlrGammaControlV1) SetFailedHandler(f ZwlrGammaControlV1FailedHandlerFunc) { + i.failedHandler = f +} + +func (i *ZwlrGammaControlV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.gammaSizeHandler == nil { + return + } + var e ZwlrGammaControlV1GammaSizeEvent + l := 0 + e.Size = client.Uint32(data[l : l+4]) + l += 4 + + i.gammaSizeHandler(e) + case 1: + if i.failedHandler == nil { + return + } + var e ZwlrGammaControlV1FailedEvent + + i.failedHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_layer_shell/layer_shell.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_layer_shell/layer_shell.go new file mode 100644 index 0000000..6fea165 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_layer_shell/layer_shell.go @@ -0,0 +1,792 @@ +// Generated by go-wayland-scanner +// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner +// XML file : internal/proto/xml/wlr-layer-shell-unstable-v1.xml +// +// wlr_layer_shell_unstable_v1 Protocol Copyright: +// +// Copyright © 2017 Drew DeVault +// +// Permission to use, copy, modify, distribute, and sell this +// software and its documentation for any purpose is hereby granted +// without fee, provided that the above copyright notice appear in +// all copies and that both that copyright notice and this permission +// notice appear in supporting documentation, and that the name of +// the copyright holders not be used in advertising or publicity +// pertaining to distribution of the software without specific, +// written prior permission. The copyright holders make no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. +// +// THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +// SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +// SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +// THIS SOFTWARE. + +package wlr_layer_shell + +import ( + "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + xdg_shell "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/stable/xdg-shell" +) + +// ZwlrLayerShellV1InterfaceName 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 ZwlrLayerShellV1InterfaceName = "zwlr_layer_shell_v1" + +// ZwlrLayerShellV1 : create surfaces that are layers of the desktop +// +// Clients can use this interface to assign the surface_layer role to +// wl_surfaces. Such surfaces are assigned to a "layer" of the output and +// rendered with a defined z-depth respective to each other. They may also be +// anchored to the edges and corners of a screen and specify input handling +// semantics. This interface should be suitable for the implementation of +// many desktop shell components, and a broad number of other applications +// that interact with the desktop. +type ZwlrLayerShellV1 struct { + client.BaseProxy +} + +// NewZwlrLayerShellV1 : create surfaces that are layers of the desktop +// +// Clients can use this interface to assign the surface_layer role to +// wl_surfaces. Such surfaces are assigned to a "layer" of the output and +// rendered with a defined z-depth respective to each other. They may also be +// anchored to the edges and corners of a screen and specify input handling +// semantics. This interface should be suitable for the implementation of +// many desktop shell components, and a broad number of other applications +// that interact with the desktop. +func NewZwlrLayerShellV1(ctx *client.Context) *ZwlrLayerShellV1 { + zwlrLayerShellV1 := &ZwlrLayerShellV1{} + ctx.Register(zwlrLayerShellV1) + return zwlrLayerShellV1 +} + +// GetLayerSurface : create a layer_surface from a surface +// +// Create a layer surface for an existing surface. This assigns the role of +// layer_surface, or raises a protocol error if another role is already +// assigned. +// +// Creating a layer surface from a wl_surface which has a buffer attached +// or committed is a client error, and any attempts by a client to attach +// or manipulate a buffer prior to the first layer_surface.configure call +// must also be treated as errors. +// +// After creating a layer_surface object and setting it up, the client +// must perform an initial commit without any buffer attached. +// The compositor will reply with a layer_surface.configure event. +// The client must acknowledge it and is then allowed to attach a buffer +// to map the surface. +// +// You may pass NULL for output to allow the compositor to decide which +// output to use. Generally this will be the one that the user most +// recently interacted with. +// +// Clients can specify a namespace that defines the purpose of the layer +// surface. +// +// layer: layer to add this surface to +// namespace: namespace for the layer surface +func (i *ZwlrLayerShellV1) GetLayerSurface(surface *client.Surface, output *client.Output, layer uint32, namespace string) (*ZwlrLayerSurfaceV1, error) { + id := NewZwlrLayerSurfaceV1(i.Context()) + const opcode = 0 + namespaceLen := client.PaddedLen(len(namespace) + 1) + _reqBufLen := 8 + 4 + 4 + 4 + 4 + (4 + namespaceLen) + _reqBuf := make([]byte, _reqBufLen) + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], surface.ID()) + l += 4 + if output == nil { + client.PutUint32(_reqBuf[l:l+4], 0) + l += 4 + } else { + client.PutUint32(_reqBuf[l:l+4], output.ID()) + l += 4 + } + client.PutUint32(_reqBuf[l:l+4], uint32(layer)) + l += 4 + client.PutString(_reqBuf[l:l+(4+namespaceLen)], namespace) + l += (4 + namespaceLen) + err := i.Context().WriteMsg(_reqBuf, nil) + return id, err +} + +// Destroy : destroy the layer_shell object +// +// This request indicates that the client will not use the layer_shell +// object any more. Objects that have been created through this instance +// are not affected. +func (i *ZwlrLayerShellV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrLayerShellV1Error uint32 + +// ZwlrLayerShellV1Error : +const ( + // ZwlrLayerShellV1ErrorRole : wl_surface has another role + ZwlrLayerShellV1ErrorRole ZwlrLayerShellV1Error = 0 + // ZwlrLayerShellV1ErrorInvalidLayer : layer value is invalid + ZwlrLayerShellV1ErrorInvalidLayer ZwlrLayerShellV1Error = 1 + // ZwlrLayerShellV1ErrorAlreadyConstructed : wl_surface has a buffer attached or committed + ZwlrLayerShellV1ErrorAlreadyConstructed ZwlrLayerShellV1Error = 2 +) + +func (e ZwlrLayerShellV1Error) Name() string { + switch e { + case ZwlrLayerShellV1ErrorRole: + return "role" + case ZwlrLayerShellV1ErrorInvalidLayer: + return "invalid_layer" + case ZwlrLayerShellV1ErrorAlreadyConstructed: + return "already_constructed" + default: + return "" + } +} + +func (e ZwlrLayerShellV1Error) Value() string { + switch e { + case ZwlrLayerShellV1ErrorRole: + return "0" + case ZwlrLayerShellV1ErrorInvalidLayer: + return "1" + case ZwlrLayerShellV1ErrorAlreadyConstructed: + return "2" + default: + return "" + } +} + +func (e ZwlrLayerShellV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +type ZwlrLayerShellV1Layer uint32 + +// ZwlrLayerShellV1Layer : available layers for surfaces +// +// These values indicate which layers a surface can be rendered in. They +// are ordered by z depth, bottom-most first. Traditional shell surfaces +// will typically be rendered between the bottom and top layers. +// Fullscreen shell surfaces are typically rendered at the top layer. +// Multiple surfaces can share a single layer, and ordering within a +// single layer is undefined. +const ( + ZwlrLayerShellV1LayerBackground ZwlrLayerShellV1Layer = 0 + ZwlrLayerShellV1LayerBottom ZwlrLayerShellV1Layer = 1 + ZwlrLayerShellV1LayerTop ZwlrLayerShellV1Layer = 2 + ZwlrLayerShellV1LayerOverlay ZwlrLayerShellV1Layer = 3 +) + +func (e ZwlrLayerShellV1Layer) Name() string { + switch e { + case ZwlrLayerShellV1LayerBackground: + return "background" + case ZwlrLayerShellV1LayerBottom: + return "bottom" + case ZwlrLayerShellV1LayerTop: + return "top" + case ZwlrLayerShellV1LayerOverlay: + return "overlay" + default: + return "" + } +} + +func (e ZwlrLayerShellV1Layer) Value() string { + switch e { + case ZwlrLayerShellV1LayerBackground: + return "0" + case ZwlrLayerShellV1LayerBottom: + return "1" + case ZwlrLayerShellV1LayerTop: + return "2" + case ZwlrLayerShellV1LayerOverlay: + return "3" + default: + return "" + } +} + +func (e ZwlrLayerShellV1Layer) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrLayerSurfaceV1InterfaceName 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 ZwlrLayerSurfaceV1InterfaceName = "zwlr_layer_surface_v1" + +// ZwlrLayerSurfaceV1 : layer metadata interface +// +// An interface that may be implemented by a wl_surface, for surfaces that +// are designed to be rendered as a layer of a stacked desktop-like +// environment. +// +// Layer surface state (layer, size, anchor, exclusive zone, +// margin, interactivity) is double-buffered, and will be applied at the +// time wl_surface.commit of the corresponding wl_surface is called. +// +// Attaching a null buffer to a layer surface unmaps it. +// +// Unmapping a layer_surface means that the surface cannot be shown by the +// compositor until it is explicitly mapped again. The layer_surface +// returns to the state it had right after layer_shell.get_layer_surface. +// The client can re-map the surface by performing a commit without any +// buffer attached, waiting for a configure event and handling it as usual. +type ZwlrLayerSurfaceV1 struct { + client.BaseProxy + configureHandler ZwlrLayerSurfaceV1ConfigureHandlerFunc + closedHandler ZwlrLayerSurfaceV1ClosedHandlerFunc +} + +// NewZwlrLayerSurfaceV1 : layer metadata interface +// +// An interface that may be implemented by a wl_surface, for surfaces that +// are designed to be rendered as a layer of a stacked desktop-like +// environment. +// +// Layer surface state (layer, size, anchor, exclusive zone, +// margin, interactivity) is double-buffered, and will be applied at the +// time wl_surface.commit of the corresponding wl_surface is called. +// +// Attaching a null buffer to a layer surface unmaps it. +// +// Unmapping a layer_surface means that the surface cannot be shown by the +// compositor until it is explicitly mapped again. The layer_surface +// returns to the state it had right after layer_shell.get_layer_surface. +// The client can re-map the surface by performing a commit without any +// buffer attached, waiting for a configure event and handling it as usual. +func NewZwlrLayerSurfaceV1(ctx *client.Context) *ZwlrLayerSurfaceV1 { + zwlrLayerSurfaceV1 := &ZwlrLayerSurfaceV1{} + ctx.Register(zwlrLayerSurfaceV1) + return zwlrLayerSurfaceV1 +} + +// SetSize : sets the size of the surface +// +// Sets the size of the surface in surface-local coordinates. The +// compositor will display the surface centered with respect to its +// anchors. +// +// If you pass 0 for either value, the compositor will assign it and +// inform you of the assignment in the configure event. You must set your +// anchor to opposite edges in the dimensions you omit; not doing so is a +// protocol error. Both values are 0 by default. +// +// Size is double-buffered, see wl_surface.commit. +func (i *ZwlrLayerSurfaceV1) SetSize(width, height uint32) error { + const opcode = 0 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(width)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(height)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetAnchor : configures the anchor point of the surface +// +// Requests that the compositor anchor the surface to the specified edges +// and corners. If two orthogonal edges are specified (e.g. 'top' and +// 'left'), then the anchor point will be the intersection of the edges +// (e.g. the top left corner of the output); otherwise the anchor point +// will be centered on that edge, or in the center if none is specified. +// +// Anchor is double-buffered, see wl_surface.commit. +func (i *ZwlrLayerSurfaceV1) SetAnchor(anchor uint32) error { + const opcode = 1 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(anchor)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetExclusiveZone : configures the exclusive geometry of this surface +// +// Requests that the compositor avoids occluding an area with other +// surfaces. The compositor's use of this information is +// implementation-dependent - do not assume that this region will not +// actually be occluded. +// +// A positive value is only meaningful if the surface is anchored to one +// edge or an edge and both perpendicular edges. If the surface is not +// anchored, anchored to only two perpendicular edges (a corner), anchored +// to only two parallel edges or anchored to all edges, a positive value +// will be treated the same as zero. +// +// A positive zone is the distance from the edge in surface-local +// coordinates to consider exclusive. +// +// Surfaces that do not wish to have an exclusive zone may instead specify +// how they should interact with surfaces that do. If set to zero, the +// surface indicates that it would like to be moved to avoid occluding +// surfaces with a positive exclusive zone. If set to -1, the surface +// indicates that it would not like to be moved to accommodate for other +// surfaces, and the compositor should extend it all the way to the edges +// it is anchored to. +// +// For example, a panel might set its exclusive zone to 10, so that +// maximized shell surfaces are not shown on top of it. A notification +// might set its exclusive zone to 0, so that it is moved to avoid +// occluding the panel, but shell surfaces are shown underneath it. A +// wallpaper or lock screen might set their exclusive zone to -1, so that +// they stretch below or over the panel. +// +// The default value is 0. +// +// Exclusive zone is double-buffered, see wl_surface.commit. +func (i *ZwlrLayerSurfaceV1) SetExclusiveZone(zone int32) error { + const opcode = 2 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(zone)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetMargin : sets a margin from the anchor point +// +// Requests that the surface be placed some distance away from the anchor +// point on the output, in surface-local coordinates. Setting this value +// for edges you are not anchored to has no effect. +// +// The exclusive zone includes the margin. +// +// Margin is double-buffered, see wl_surface.commit. +func (i *ZwlrLayerSurfaceV1) SetMargin(top, right, bottom, left int32) error { + const opcode = 3 + const _reqBufLen = 8 + 4 + 4 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(top)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(right)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(bottom)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(left)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetKeyboardInteractivity : requests keyboard events +// +// Set how keyboard events are delivered to this surface. By default, +// layer shell surfaces do not receive keyboard events; this request can +// be used to change this. +// +// This setting is inherited by child surfaces set by the get_popup +// request. +// +// Layer surfaces receive pointer, touch, and tablet events normally. If +// you do not want to receive them, set the input region on your surface +// to an empty region. +// +// Keyboard interactivity is double-buffered, see wl_surface.commit. +func (i *ZwlrLayerSurfaceV1) SetKeyboardInteractivity(keyboardInteractivity uint32) error { + const opcode = 4 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(keyboardInteractivity)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// GetPopup : assign this layer_surface as an xdg_popup parent +// +// This assigns an xdg_popup's parent to this layer_surface. This popup +// should have been created via xdg_surface::get_popup with the parent set +// to NULL, and this request must be invoked before committing the popup's +// initial state. +// +// See the documentation of xdg_popup for more details about what an +// xdg_popup is and how it is used. +func (i *ZwlrLayerSurfaceV1) GetPopup(popup *xdg_shell.Popup) error { + const opcode = 5 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], popup.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// AckConfigure : ack a configure event +// +// When a configure event is received, if a client commits the +// surface in response to the configure event, then the client +// must make an ack_configure request sometime before the commit +// request, passing along the serial of the configure event. +// +// If the client receives multiple configure events before it +// can respond to one, it only has to ack the last configure event. +// +// A client is not required to commit immediately after sending +// an ack_configure request - it may even ack_configure several times +// before its next surface commit. +// +// A client may send multiple ack_configure requests before committing, but +// only the last request sent before a commit indicates which configure +// event the client really is responding to. +// +// serial: the serial from the configure event +func (i *ZwlrLayerSurfaceV1) AckConfigure(serial uint32) error { + const opcode = 6 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(serial)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Destroy : destroy the layer_surface +// +// This request destroys the layer surface. +func (i *ZwlrLayerSurfaceV1) Destroy() error { + defer i.MarkZombie() + const opcode = 7 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetLayer : change the layer of the surface +// +// Change the layer that the surface is rendered on. +// +// Layer is double-buffered, see wl_surface.commit. +// +// layer: layer to move this surface to +func (i *ZwlrLayerSurfaceV1) SetLayer(layer uint32) error { + const opcode = 8 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(layer)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetExclusiveEdge : set the edge the exclusive zone will be applied to +// +// Requests an edge for the exclusive zone to apply. The exclusive +// edge will be automatically deduced from anchor points when possible, +// but when the surface is anchored to a corner, it will be necessary +// to set it explicitly to disambiguate, as it is not possible to deduce +// which one of the two corner edges should be used. +// +// The edge must be one the surface is anchored to, otherwise the +// invalid_exclusive_edge protocol error will be raised. +func (i *ZwlrLayerSurfaceV1) SetExclusiveEdge(edge uint32) error { + const opcode = 9 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(edge)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrLayerSurfaceV1KeyboardInteractivity uint32 + +// ZwlrLayerSurfaceV1KeyboardInteractivity : types of keyboard interaction possible for a layer shell surface +// +// Types of keyboard interaction possible for layer shell surfaces. The +// rationale for this is twofold: (1) some applications are not interested +// in keyboard events and not allowing them to be focused can improve the +// desktop experience; (2) some applications will want to take exclusive +// keyboard focus. +const ( + ZwlrLayerSurfaceV1KeyboardInteractivityNone ZwlrLayerSurfaceV1KeyboardInteractivity = 0 + ZwlrLayerSurfaceV1KeyboardInteractivityExclusive ZwlrLayerSurfaceV1KeyboardInteractivity = 1 + ZwlrLayerSurfaceV1KeyboardInteractivityOnDemand ZwlrLayerSurfaceV1KeyboardInteractivity = 2 +) + +func (e ZwlrLayerSurfaceV1KeyboardInteractivity) Name() string { + switch e { + case ZwlrLayerSurfaceV1KeyboardInteractivityNone: + return "none" + case ZwlrLayerSurfaceV1KeyboardInteractivityExclusive: + return "exclusive" + case ZwlrLayerSurfaceV1KeyboardInteractivityOnDemand: + return "on_demand" + default: + return "" + } +} + +func (e ZwlrLayerSurfaceV1KeyboardInteractivity) Value() string { + switch e { + case ZwlrLayerSurfaceV1KeyboardInteractivityNone: + return "0" + case ZwlrLayerSurfaceV1KeyboardInteractivityExclusive: + return "1" + case ZwlrLayerSurfaceV1KeyboardInteractivityOnDemand: + return "2" + default: + return "" + } +} + +func (e ZwlrLayerSurfaceV1KeyboardInteractivity) String() string { + return e.Name() + "=" + e.Value() +} + +type ZwlrLayerSurfaceV1Error uint32 + +// ZwlrLayerSurfaceV1Error : +const ( + // ZwlrLayerSurfaceV1ErrorInvalidSurfaceState : provided surface state is invalid + ZwlrLayerSurfaceV1ErrorInvalidSurfaceState ZwlrLayerSurfaceV1Error = 0 + // ZwlrLayerSurfaceV1ErrorInvalidSize : size is invalid + ZwlrLayerSurfaceV1ErrorInvalidSize ZwlrLayerSurfaceV1Error = 1 + // ZwlrLayerSurfaceV1ErrorInvalidAnchor : anchor bitfield is invalid + ZwlrLayerSurfaceV1ErrorInvalidAnchor ZwlrLayerSurfaceV1Error = 2 + // ZwlrLayerSurfaceV1ErrorInvalidKeyboardInteractivity : keyboard interactivity is invalid + ZwlrLayerSurfaceV1ErrorInvalidKeyboardInteractivity ZwlrLayerSurfaceV1Error = 3 + // ZwlrLayerSurfaceV1ErrorInvalidExclusiveEdge : exclusive edge is invalid given the surface anchors + ZwlrLayerSurfaceV1ErrorInvalidExclusiveEdge ZwlrLayerSurfaceV1Error = 4 +) + +func (e ZwlrLayerSurfaceV1Error) Name() string { + switch e { + case ZwlrLayerSurfaceV1ErrorInvalidSurfaceState: + return "invalid_surface_state" + case ZwlrLayerSurfaceV1ErrorInvalidSize: + return "invalid_size" + case ZwlrLayerSurfaceV1ErrorInvalidAnchor: + return "invalid_anchor" + case ZwlrLayerSurfaceV1ErrorInvalidKeyboardInteractivity: + return "invalid_keyboard_interactivity" + case ZwlrLayerSurfaceV1ErrorInvalidExclusiveEdge: + return "invalid_exclusive_edge" + default: + return "" + } +} + +func (e ZwlrLayerSurfaceV1Error) Value() string { + switch e { + case ZwlrLayerSurfaceV1ErrorInvalidSurfaceState: + return "0" + case ZwlrLayerSurfaceV1ErrorInvalidSize: + return "1" + case ZwlrLayerSurfaceV1ErrorInvalidAnchor: + return "2" + case ZwlrLayerSurfaceV1ErrorInvalidKeyboardInteractivity: + return "3" + case ZwlrLayerSurfaceV1ErrorInvalidExclusiveEdge: + return "4" + default: + return "" + } +} + +func (e ZwlrLayerSurfaceV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +type ZwlrLayerSurfaceV1Anchor uint32 + +// ZwlrLayerSurfaceV1Anchor : +const ( + // ZwlrLayerSurfaceV1AnchorTop : the top edge of the anchor rectangle + ZwlrLayerSurfaceV1AnchorTop ZwlrLayerSurfaceV1Anchor = 1 + // ZwlrLayerSurfaceV1AnchorBottom : the bottom edge of the anchor rectangle + ZwlrLayerSurfaceV1AnchorBottom ZwlrLayerSurfaceV1Anchor = 2 + // ZwlrLayerSurfaceV1AnchorLeft : the left edge of the anchor rectangle + ZwlrLayerSurfaceV1AnchorLeft ZwlrLayerSurfaceV1Anchor = 4 + // ZwlrLayerSurfaceV1AnchorRight : the right edge of the anchor rectangle + ZwlrLayerSurfaceV1AnchorRight ZwlrLayerSurfaceV1Anchor = 8 +) + +func (e ZwlrLayerSurfaceV1Anchor) Name() string { + switch e { + case ZwlrLayerSurfaceV1AnchorTop: + return "top" + case ZwlrLayerSurfaceV1AnchorBottom: + return "bottom" + case ZwlrLayerSurfaceV1AnchorLeft: + return "left" + case ZwlrLayerSurfaceV1AnchorRight: + return "right" + default: + return "" + } +} + +func (e ZwlrLayerSurfaceV1Anchor) Value() string { + switch e { + case ZwlrLayerSurfaceV1AnchorTop: + return "1" + case ZwlrLayerSurfaceV1AnchorBottom: + return "2" + case ZwlrLayerSurfaceV1AnchorLeft: + return "4" + case ZwlrLayerSurfaceV1AnchorRight: + return "8" + default: + return "" + } +} + +func (e ZwlrLayerSurfaceV1Anchor) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrLayerSurfaceV1ConfigureEvent : suggest a surface change +// +// The configure event asks the client to resize its surface. +// +// Clients should arrange their surface for the new states, and then send +// an ack_configure request with the serial sent in this configure event at +// some point before committing the new surface. +// +// 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. +// +// 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). If the client picks a smaller size and +// is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the +// surface will be centered on this axis. +// +// If the width or height arguments are zero, it means the client should +// decide its own window dimension. +type ZwlrLayerSurfaceV1ConfigureEvent struct { + Serial uint32 + Width uint32 + Height uint32 +} +type ZwlrLayerSurfaceV1ConfigureHandlerFunc func(ZwlrLayerSurfaceV1ConfigureEvent) + +// SetConfigureHandler : sets handler for ZwlrLayerSurfaceV1ConfigureEvent +func (i *ZwlrLayerSurfaceV1) SetConfigureHandler(f ZwlrLayerSurfaceV1ConfigureHandlerFunc) { + i.configureHandler = f +} + +// ZwlrLayerSurfaceV1ClosedEvent : surface should be closed +// +// The closed event is sent by the compositor when the surface will no +// longer be shown. The output may have been destroyed or the user may +// have asked for it to be removed. Further changes to the surface will be +// ignored. The client should destroy the resource after receiving this +// event, and create a new surface if they so choose. +type ZwlrLayerSurfaceV1ClosedEvent struct{} +type ZwlrLayerSurfaceV1ClosedHandlerFunc func(ZwlrLayerSurfaceV1ClosedEvent) + +// SetClosedHandler : sets handler for ZwlrLayerSurfaceV1ClosedEvent +func (i *ZwlrLayerSurfaceV1) SetClosedHandler(f ZwlrLayerSurfaceV1ClosedHandlerFunc) { + i.closedHandler = f +} + +func (i *ZwlrLayerSurfaceV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.configureHandler == nil { + return + } + var e ZwlrLayerSurfaceV1ConfigureEvent + l := 0 + e.Serial = client.Uint32(data[l : l+4]) + l += 4 + e.Width = client.Uint32(data[l : l+4]) + l += 4 + e.Height = client.Uint32(data[l : l+4]) + l += 4 + + i.configureHandler(e) + case 1: + if i.closedHandler == nil { + return + } + var e ZwlrLayerSurfaceV1ClosedEvent + + i.closedHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_output_management/output_management.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_output_management/output_management.go new file mode 100644 index 0000000..23f934f --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_output_management/output_management.go @@ -0,0 +1,1515 @@ +// Generated by go-wayland-scanner +// https://github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/cmd/go-wayland-scanner +// XML file : /home/brandon/repos/dankdots/wlr-output-management-unstable-v1.xml +// +// wlr_output_management_unstable_v1 Protocol Copyright: +// +// Copyright © 2019 Purism SPC +// +// Permission to use, copy, modify, distribute, and sell this +// software and its documentation for any purpose is hereby granted +// without fee, provided that the above copyright notice appear in +// all copies and that both that copyright notice and this permission +// notice appear in supporting documentation, and that the name of +// the copyright holders not be used in advertising or publicity +// pertaining to distribution of the software without specific, +// written prior permission. The copyright holders make no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. +// +// THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +// SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +// SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +// THIS SOFTWARE. + +package wlr_output_management + +import ( + "reflect" + "unsafe" + + "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + "github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap" +) + +func registerServerProxy(ctx *client.Context, proxy client.Proxy, serverID uint32) { + defer func() { + if r := recover(); r != nil { + return + } + }() + ctxVal := reflect.ValueOf(ctx).Elem() + objectsField := ctxVal.FieldByName("objects") + if !objectsField.IsValid() { + return + } + objectsMapPtr := unsafe.Pointer(objectsField.UnsafeAddr()) + objectsMap := (*syncmap.Map[uint32, client.Proxy])(objectsMapPtr) + objectsMap.Store(serverID, proxy) +} + +// ZwlrOutputManagerV1InterfaceName 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 ZwlrOutputManagerV1InterfaceName = "zwlr_output_manager_v1" + +// ZwlrOutputManagerV1 : output device configuration manager +// +// This interface is a manager that allows reading and writing the current +// output device configuration. +// +// Output devices that display pixels (e.g. a physical monitor or a virtual +// output in a window) are represented as heads. Heads cannot be created nor +// destroyed by the client, but they can be enabled or disabled and their +// properties can be changed. Each head may have one or more available modes. +// +// Whenever a head appears (e.g. a monitor is plugged in), it will be +// advertised via the head event. Immediately after the output manager is +// bound, all current heads are advertised. +// +// Whenever a head's properties change, the relevant wlr_output_head events +// will be sent. Not all head properties will be sent: only properties that +// have changed need to. +// +// Whenever a head disappears (e.g. a monitor is unplugged), a +// wlr_output_head.finished event will be sent. +// +// After one or more heads appear, change or disappear, the done event will +// be sent. It carries a serial which can be used in a create_configuration +// request to update heads properties. +// +// The information obtained from this protocol should only be used for output +// configuration purposes. This protocol is not designed to be a generic +// output property advertisement protocol for regular clients. Instead, +// protocols such as xdg-output should be used. +type ZwlrOutputManagerV1 struct { + client.BaseProxy + headHandler ZwlrOutputManagerV1HeadHandlerFunc + doneHandler ZwlrOutputManagerV1DoneHandlerFunc + finishedHandler ZwlrOutputManagerV1FinishedHandlerFunc +} + +// NewZwlrOutputManagerV1 : output device configuration manager +// +// This interface is a manager that allows reading and writing the current +// output device configuration. +// +// Output devices that display pixels (e.g. a physical monitor or a virtual +// output in a window) are represented as heads. Heads cannot be created nor +// destroyed by the client, but they can be enabled or disabled and their +// properties can be changed. Each head may have one or more available modes. +// +// Whenever a head appears (e.g. a monitor is plugged in), it will be +// advertised via the head event. Immediately after the output manager is +// bound, all current heads are advertised. +// +// Whenever a head's properties change, the relevant wlr_output_head events +// will be sent. Not all head properties will be sent: only properties that +// have changed need to. +// +// Whenever a head disappears (e.g. a monitor is unplugged), a +// wlr_output_head.finished event will be sent. +// +// After one or more heads appear, change or disappear, the done event will +// be sent. It carries a serial which can be used in a create_configuration +// request to update heads properties. +// +// The information obtained from this protocol should only be used for output +// configuration purposes. This protocol is not designed to be a generic +// output property advertisement protocol for regular clients. Instead, +// protocols such as xdg-output should be used. +func NewZwlrOutputManagerV1(ctx *client.Context) *ZwlrOutputManagerV1 { + zwlrOutputManagerV1 := &ZwlrOutputManagerV1{} + ctx.Register(zwlrOutputManagerV1) + return zwlrOutputManagerV1 +} + +// CreateConfiguration : create a new output configuration object +// +// Create a new output configuration object. This allows to update head +// properties. +func (i *ZwlrOutputManagerV1) CreateConfiguration(serial uint32) (*ZwlrOutputConfigurationV1, error) { + id := NewZwlrOutputConfigurationV1(i.Context()) + const opcode = 0 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(serial)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// Stop : stop sending events +// +// Indicates the client no longer wishes to receive events for output +// configuration changes. However the compositor may emit further events, +// until the finished event is emitted. +// +// The client must not send any more requests after this one. +func (i *ZwlrOutputManagerV1) Stop() error { + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +func (i *ZwlrOutputManagerV1) Destroy() error { + i.MarkZombie() + return nil +} + +// ZwlrOutputManagerV1HeadEvent : introduce a new head +// +// This event introduces a new head. This happens whenever a new head +// appears (e.g. a monitor is plugged in) or after the output manager is +// bound. +type ZwlrOutputManagerV1HeadEvent struct { + Head *ZwlrOutputHeadV1 +} +type ZwlrOutputManagerV1HeadHandlerFunc func(ZwlrOutputManagerV1HeadEvent) + +// SetHeadHandler : sets handler for ZwlrOutputManagerV1HeadEvent +func (i *ZwlrOutputManagerV1) SetHeadHandler(f ZwlrOutputManagerV1HeadHandlerFunc) { + i.headHandler = f +} + +// ZwlrOutputManagerV1DoneEvent : sent all information about current configuration +// +// This event is sent after all information has been sent after binding to +// the output manager object and after any subsequent changes. This applies +// to child head and mode objects as well. In other words, this event is +// sent whenever a head or mode is created or destroyed and whenever one of +// their properties has been changed. Not all state is re-sent each time +// the current configuration changes: only the actual changes are sent. +// +// This allows changes to the output configuration to be seen as atomic, +// even if they happen via multiple events. +// +// A serial is sent to be used in a future create_configuration request. +type ZwlrOutputManagerV1DoneEvent struct { + Serial uint32 +} +type ZwlrOutputManagerV1DoneHandlerFunc func(ZwlrOutputManagerV1DoneEvent) + +// SetDoneHandler : sets handler for ZwlrOutputManagerV1DoneEvent +func (i *ZwlrOutputManagerV1) SetDoneHandler(f ZwlrOutputManagerV1DoneHandlerFunc) { + i.doneHandler = f +} + +// ZwlrOutputManagerV1FinishedEvent : the compositor has finished with the manager +// +// This event indicates that the compositor is done sending manager events. +// The compositor will destroy the object immediately after sending this +// event, so it will become invalid and the client should release any +// resources associated with it. +type ZwlrOutputManagerV1FinishedEvent struct{} +type ZwlrOutputManagerV1FinishedHandlerFunc func(ZwlrOutputManagerV1FinishedEvent) + +// SetFinishedHandler : sets handler for ZwlrOutputManagerV1FinishedEvent +func (i *ZwlrOutputManagerV1) SetFinishedHandler(f ZwlrOutputManagerV1FinishedHandlerFunc) { + i.finishedHandler = f +} + +func (i *ZwlrOutputManagerV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.headHandler == nil { + return + } + var e ZwlrOutputManagerV1HeadEvent + l := 0 + objectID := client.Uint32(data[l : l+4]) + proxy := i.Context().GetProxy(objectID) + if proxy == nil || proxy.IsZombie() { + head := &ZwlrOutputHeadV1{} + head.SetContext(i.Context()) + head.SetID(objectID) + registerServerProxy(i.Context(), head, objectID) + e.Head = head + } else if head, ok := proxy.(*ZwlrOutputHeadV1); ok { + e.Head = head + } else { + // Stale proxy of wrong type (can happen after suspend/resume) + // Replace it with the correct type + head := &ZwlrOutputHeadV1{} + head.SetContext(i.Context()) + head.SetID(objectID) + registerServerProxy(i.Context(), head, objectID) + e.Head = head + } + l += 4 + + i.headHandler(e) + case 1: + if i.doneHandler == nil { + return + } + var e ZwlrOutputManagerV1DoneEvent + l := 0 + e.Serial = client.Uint32(data[l : l+4]) + l += 4 + + i.doneHandler(e) + case 2: + if i.finishedHandler == nil { + return + } + var e ZwlrOutputManagerV1FinishedEvent + + i.finishedHandler(e) + } +} + +// ZwlrOutputHeadV1InterfaceName 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 ZwlrOutputHeadV1InterfaceName = "zwlr_output_head_v1" + +// ZwlrOutputHeadV1 : output device +// +// A head is an output device. The difference between a wl_output object and +// a head is that heads are advertised even if they are turned off. A head +// object only advertises properties and cannot be used directly to change +// them. +// +// A head has some read-only properties: modes, name, description and +// physical_size. These cannot be changed by clients. +// +// Other properties can be updated via a wlr_output_configuration object. +// +// Properties sent via this interface are applied atomically via the +// wlr_output_manager.done event. No guarantees are made regarding the order +// in which properties are sent. +type ZwlrOutputHeadV1 struct { + client.BaseProxy + nameHandler ZwlrOutputHeadV1NameHandlerFunc + descriptionHandler ZwlrOutputHeadV1DescriptionHandlerFunc + physicalSizeHandler ZwlrOutputHeadV1PhysicalSizeHandlerFunc + modeHandler ZwlrOutputHeadV1ModeHandlerFunc + enabledHandler ZwlrOutputHeadV1EnabledHandlerFunc + currentModeHandler ZwlrOutputHeadV1CurrentModeHandlerFunc + positionHandler ZwlrOutputHeadV1PositionHandlerFunc + transformHandler ZwlrOutputHeadV1TransformHandlerFunc + scaleHandler ZwlrOutputHeadV1ScaleHandlerFunc + finishedHandler ZwlrOutputHeadV1FinishedHandlerFunc + makeHandler ZwlrOutputHeadV1MakeHandlerFunc + modelHandler ZwlrOutputHeadV1ModelHandlerFunc + serialNumberHandler ZwlrOutputHeadV1SerialNumberHandlerFunc + adaptiveSyncHandler ZwlrOutputHeadV1AdaptiveSyncHandlerFunc +} + +// NewZwlrOutputHeadV1 : output device +// +// A head is an output device. The difference between a wl_output object and +// a head is that heads are advertised even if they are turned off. A head +// object only advertises properties and cannot be used directly to change +// them. +// +// A head has some read-only properties: modes, name, description and +// physical_size. These cannot be changed by clients. +// +// Other properties can be updated via a wlr_output_configuration object. +// +// Properties sent via this interface are applied atomically via the +// wlr_output_manager.done event. No guarantees are made regarding the order +// in which properties are sent. +func NewZwlrOutputHeadV1(ctx *client.Context) *ZwlrOutputHeadV1 { + zwlrOutputHeadV1 := &ZwlrOutputHeadV1{} + ctx.Register(zwlrOutputHeadV1) + return zwlrOutputHeadV1 +} + +// Release : destroy the head object +// +// This request indicates that the client will no longer use this head +// object. +func (i *ZwlrOutputHeadV1) Release() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrOutputHeadV1AdaptiveSyncState uint32 + +// ZwlrOutputHeadV1AdaptiveSyncState : +const ( + // ZwlrOutputHeadV1AdaptiveSyncStateDisabled : adaptive sync is disabled + ZwlrOutputHeadV1AdaptiveSyncStateDisabled ZwlrOutputHeadV1AdaptiveSyncState = 0 + // ZwlrOutputHeadV1AdaptiveSyncStateEnabled : adaptive sync is enabled + ZwlrOutputHeadV1AdaptiveSyncStateEnabled ZwlrOutputHeadV1AdaptiveSyncState = 1 +) + +func (e ZwlrOutputHeadV1AdaptiveSyncState) Name() string { + switch e { + case ZwlrOutputHeadV1AdaptiveSyncStateDisabled: + return "disabled" + case ZwlrOutputHeadV1AdaptiveSyncStateEnabled: + return "enabled" + default: + return "" + } +} + +func (e ZwlrOutputHeadV1AdaptiveSyncState) Value() string { + switch e { + case ZwlrOutputHeadV1AdaptiveSyncStateDisabled: + return "0" + case ZwlrOutputHeadV1AdaptiveSyncStateEnabled: + return "1" + default: + return "" + } +} + +func (e ZwlrOutputHeadV1AdaptiveSyncState) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrOutputHeadV1NameEvent : head name +// +// This event describes the head name. +// +// The naming convention is compositor defined, but limited to alphanumeric +// characters and dashes (-). Each name is unique among all wlr_output_head +// objects, but if a wlr_output_head object is destroyed the same name may +// be reused later. The names will also remain consistent across sessions +// with the same hardware and software configuration. +// +// 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. +// +// If this head matches a wl_output, the wl_output.name event must report +// the same name. +// +// The name event is sent after a wlr_output_head object is created. This +// event is only sent once per object, and the name does not change over +// the lifetime of the wlr_output_head object. +type ZwlrOutputHeadV1NameEvent struct { + Name string +} +type ZwlrOutputHeadV1NameHandlerFunc func(ZwlrOutputHeadV1NameEvent) + +// SetNameHandler : sets handler for ZwlrOutputHeadV1NameEvent +func (i *ZwlrOutputHeadV1) SetNameHandler(f ZwlrOutputHeadV1NameHandlerFunc) { + i.nameHandler = f +} + +// ZwlrOutputHeadV1DescriptionEvent : head description +// +// This event describes a human-readable description of the head. +// +// The description is a UTF-8 string with no convention defined for its +// contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 +// output via :1'. However, do not assume that the name is a reflection of +// the make, model, serial of the underlying DRM connector or the display +// name of the underlying X11 connection, etc. +// +// If this head matches a wl_output, the wl_output.description event must +// report the same name. +// +// The description event is sent after a wlr_output_head object is created. +// This event is only sent once per object, and the description does not +// change over the lifetime of the wlr_output_head object. +type ZwlrOutputHeadV1DescriptionEvent struct { + Description string +} +type ZwlrOutputHeadV1DescriptionHandlerFunc func(ZwlrOutputHeadV1DescriptionEvent) + +// SetDescriptionHandler : sets handler for ZwlrOutputHeadV1DescriptionEvent +func (i *ZwlrOutputHeadV1) SetDescriptionHandler(f ZwlrOutputHeadV1DescriptionHandlerFunc) { + i.descriptionHandler = f +} + +// ZwlrOutputHeadV1PhysicalSizeEvent : head physical size +// +// This event describes the physical size of the head. This event is only +// sent if the head has a physical size (e.g. is not a projector or a +// virtual device). +// +// The physical size event is sent after a wlr_output_head object is created. This +// event is only sent once per object, and the physical size does not change over +// the lifetime of the wlr_output_head object. +type ZwlrOutputHeadV1PhysicalSizeEvent struct { + Width int32 + Height int32 +} +type ZwlrOutputHeadV1PhysicalSizeHandlerFunc func(ZwlrOutputHeadV1PhysicalSizeEvent) + +// SetPhysicalSizeHandler : sets handler for ZwlrOutputHeadV1PhysicalSizeEvent +func (i *ZwlrOutputHeadV1) SetPhysicalSizeHandler(f ZwlrOutputHeadV1PhysicalSizeHandlerFunc) { + i.physicalSizeHandler = f +} + +// ZwlrOutputHeadV1ModeEvent : introduce a mode +// +// This event introduces a mode for this head. It is sent once per +// supported mode. +type ZwlrOutputHeadV1ModeEvent struct { + Mode *ZwlrOutputModeV1 +} +type ZwlrOutputHeadV1ModeHandlerFunc func(ZwlrOutputHeadV1ModeEvent) + +// SetModeHandler : sets handler for ZwlrOutputHeadV1ModeEvent +func (i *ZwlrOutputHeadV1) SetModeHandler(f ZwlrOutputHeadV1ModeHandlerFunc) { + i.modeHandler = f +} + +// ZwlrOutputHeadV1EnabledEvent : head is enabled or disabled +// +// This event describes whether the head is enabled. A disabled head is not +// mapped to a region of the global compositor space. +// +// When a head is disabled, some properties (current_mode, position, +// transform and scale) are irrelevant. +type ZwlrOutputHeadV1EnabledEvent struct { + Enabled int32 +} +type ZwlrOutputHeadV1EnabledHandlerFunc func(ZwlrOutputHeadV1EnabledEvent) + +// SetEnabledHandler : sets handler for ZwlrOutputHeadV1EnabledEvent +func (i *ZwlrOutputHeadV1) SetEnabledHandler(f ZwlrOutputHeadV1EnabledHandlerFunc) { + i.enabledHandler = f +} + +// ZwlrOutputHeadV1CurrentModeEvent : current mode +// +// This event describes the mode currently in use for this head. It is only +// sent if the output is enabled. +type ZwlrOutputHeadV1CurrentModeEvent struct { + Mode *ZwlrOutputModeV1 +} +type ZwlrOutputHeadV1CurrentModeHandlerFunc func(ZwlrOutputHeadV1CurrentModeEvent) + +// SetCurrentModeHandler : sets handler for ZwlrOutputHeadV1CurrentModeEvent +func (i *ZwlrOutputHeadV1) SetCurrentModeHandler(f ZwlrOutputHeadV1CurrentModeHandlerFunc) { + i.currentModeHandler = f +} + +// ZwlrOutputHeadV1PositionEvent : current position +// +// This events describes the position of the head in the global compositor +// space. It is only sent if the output is enabled. +type ZwlrOutputHeadV1PositionEvent struct { + X int32 + Y int32 +} +type ZwlrOutputHeadV1PositionHandlerFunc func(ZwlrOutputHeadV1PositionEvent) + +// SetPositionHandler : sets handler for ZwlrOutputHeadV1PositionEvent +func (i *ZwlrOutputHeadV1) SetPositionHandler(f ZwlrOutputHeadV1PositionHandlerFunc) { + i.positionHandler = f +} + +// ZwlrOutputHeadV1TransformEvent : current transformation +// +// This event describes the transformation currently applied to the head. +// It is only sent if the output is enabled. +type ZwlrOutputHeadV1TransformEvent struct { + Transform int32 +} +type ZwlrOutputHeadV1TransformHandlerFunc func(ZwlrOutputHeadV1TransformEvent) + +// SetTransformHandler : sets handler for ZwlrOutputHeadV1TransformEvent +func (i *ZwlrOutputHeadV1) SetTransformHandler(f ZwlrOutputHeadV1TransformHandlerFunc) { + i.transformHandler = f +} + +// ZwlrOutputHeadV1ScaleEvent : current scale +// +// This events describes the scale of the head in the global compositor +// space. It is only sent if the output is enabled. +type ZwlrOutputHeadV1ScaleEvent struct { + Scale float64 +} +type ZwlrOutputHeadV1ScaleHandlerFunc func(ZwlrOutputHeadV1ScaleEvent) + +// SetScaleHandler : sets handler for ZwlrOutputHeadV1ScaleEvent +func (i *ZwlrOutputHeadV1) SetScaleHandler(f ZwlrOutputHeadV1ScaleHandlerFunc) { + i.scaleHandler = f +} + +// ZwlrOutputHeadV1FinishedEvent : the head has disappeared +// +// This event indicates that the head is no longer available. The head +// object becomes inert. Clients should send a destroy request and release +// any resources associated with it. +type ZwlrOutputHeadV1FinishedEvent struct{} +type ZwlrOutputHeadV1FinishedHandlerFunc func(ZwlrOutputHeadV1FinishedEvent) + +// SetFinishedHandler : sets handler for ZwlrOutputHeadV1FinishedEvent +func (i *ZwlrOutputHeadV1) SetFinishedHandler(f ZwlrOutputHeadV1FinishedHandlerFunc) { + i.finishedHandler = f +} + +// ZwlrOutputHeadV1MakeEvent : head manufacturer +// +// This event describes the manufacturer of the head. +// +// Together with the model and serial_number events the purpose is to +// allow clients to recognize heads from previous sessions and for example +// load head-specific configurations back. +// +// It is not guaranteed this event will be ever sent. A reason for that +// can be that the compositor does not have information about the make of +// the head or the definition of a make is not sensible in the current +// setup, for example in a virtual session. Clients can still try to +// identify the head by available information from other events but should +// be aware that there is an increased risk of false positives. +// +// If sent, the make event is sent after a wlr_output_head object is +// created and only sent once per object. The make does not change over +// the lifetime of the wlr_output_head object. +// +// It is not recommended to display the make string in UI to users. For +// that the string provided by the description event should be preferred. +type ZwlrOutputHeadV1MakeEvent struct { + Make string +} +type ZwlrOutputHeadV1MakeHandlerFunc func(ZwlrOutputHeadV1MakeEvent) + +// SetMakeHandler : sets handler for ZwlrOutputHeadV1MakeEvent +func (i *ZwlrOutputHeadV1) SetMakeHandler(f ZwlrOutputHeadV1MakeHandlerFunc) { + i.makeHandler = f +} + +// ZwlrOutputHeadV1ModelEvent : head model +// +// This event describes the model of the head. +// +// Together with the make and serial_number events the purpose is to +// allow clients to recognize heads from previous sessions and for example +// load head-specific configurations back. +// +// It is not guaranteed this event will be ever sent. A reason for that +// can be that the compositor does not have information about the model of +// the head or the definition of a model is not sensible in the current +// setup, for example in a virtual session. Clients can still try to +// identify the head by available information from other events but should +// be aware that there is an increased risk of false positives. +// +// If sent, the model event is sent after a wlr_output_head object is +// created and only sent once per object. The model does not change over +// the lifetime of the wlr_output_head object. +// +// It is not recommended to display the model string in UI to users. For +// that the string provided by the description event should be preferred. +type ZwlrOutputHeadV1ModelEvent struct { + Model string +} +type ZwlrOutputHeadV1ModelHandlerFunc func(ZwlrOutputHeadV1ModelEvent) + +// SetModelHandler : sets handler for ZwlrOutputHeadV1ModelEvent +func (i *ZwlrOutputHeadV1) SetModelHandler(f ZwlrOutputHeadV1ModelHandlerFunc) { + i.modelHandler = f +} + +// ZwlrOutputHeadV1SerialNumberEvent : head serial number +// +// This event describes the serial number of the head. +// +// Together with the make and model events the purpose is to allow clients +// to recognize heads from previous sessions and for example load head- +// specific configurations back. +// +// It is not guaranteed this event will be ever sent. A reason for that +// can be that the compositor does not have information about the serial +// number of the head or the definition of a serial number is not sensible +// in the current setup. Clients can still try to identify the head by +// available information from other events but should be aware that there +// is an increased risk of false positives. +// +// If sent, the serial number event is sent after a wlr_output_head object +// is created and only sent once per object. The serial number does not +// change over the lifetime of the wlr_output_head object. +// +// It is not recommended to display the serial_number string in UI to +// users. For that the string provided by the description event should be +// preferred. +type ZwlrOutputHeadV1SerialNumberEvent struct { + SerialNumber string +} +type ZwlrOutputHeadV1SerialNumberHandlerFunc func(ZwlrOutputHeadV1SerialNumberEvent) + +// SetSerialNumberHandler : sets handler for ZwlrOutputHeadV1SerialNumberEvent +func (i *ZwlrOutputHeadV1) SetSerialNumberHandler(f ZwlrOutputHeadV1SerialNumberHandlerFunc) { + i.serialNumberHandler = f +} + +// ZwlrOutputHeadV1AdaptiveSyncEvent : current adaptive sync state +// +// This event describes whether adaptive sync is currently enabled for +// the head or not. Adaptive sync is also known as Variable Refresh +// Rate or VRR. +type ZwlrOutputHeadV1AdaptiveSyncEvent struct { + State uint32 +} +type ZwlrOutputHeadV1AdaptiveSyncHandlerFunc func(ZwlrOutputHeadV1AdaptiveSyncEvent) + +// SetAdaptiveSyncHandler : sets handler for ZwlrOutputHeadV1AdaptiveSyncEvent +func (i *ZwlrOutputHeadV1) SetAdaptiveSyncHandler(f ZwlrOutputHeadV1AdaptiveSyncHandlerFunc) { + i.adaptiveSyncHandler = f +} + +func (i *ZwlrOutputHeadV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.nameHandler == nil { + return + } + var e ZwlrOutputHeadV1NameEvent + l := 0 + nameLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Name = client.String(data[l : l+nameLen]) + l += nameLen + + i.nameHandler(e) + case 1: + if i.descriptionHandler == nil { + return + } + var e ZwlrOutputHeadV1DescriptionEvent + l := 0 + descriptionLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Description = client.String(data[l : l+descriptionLen]) + l += descriptionLen + + i.descriptionHandler(e) + case 2: + if i.physicalSizeHandler == nil { + return + } + var e ZwlrOutputHeadV1PhysicalSizeEvent + l := 0 + e.Width = int32(client.Uint32(data[l : l+4])) + l += 4 + e.Height = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.physicalSizeHandler(e) + case 3: + if i.modeHandler == nil { + return + } + var e ZwlrOutputHeadV1ModeEvent + l := 0 + objectID := client.Uint32(data[l : l+4]) + proxy := i.Context().GetProxy(objectID) + if proxy == nil || proxy.IsZombie() { + mode := &ZwlrOutputModeV1{} + mode.SetContext(i.Context()) + mode.SetID(objectID) + registerServerProxy(i.Context(), mode, objectID) + e.Mode = mode + } else if mode, ok := proxy.(*ZwlrOutputModeV1); ok { + e.Mode = mode + } else { + // Stale proxy of wrong type (can happen after suspend/resume) + // Replace it with the correct type + mode := &ZwlrOutputModeV1{} + mode.SetContext(i.Context()) + mode.SetID(objectID) + registerServerProxy(i.Context(), mode, objectID) + e.Mode = mode + } + l += 4 + + i.modeHandler(e) + case 4: + if i.enabledHandler == nil { + return + } + var e ZwlrOutputHeadV1EnabledEvent + l := 0 + e.Enabled = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.enabledHandler(e) + case 5: + if i.currentModeHandler == nil { + return + } + var e ZwlrOutputHeadV1CurrentModeEvent + l := 0 + objectID := client.Uint32(data[l : l+4]) + proxy := i.Context().GetProxy(objectID) + if proxy == nil || proxy.IsZombie() { + // Mode not yet registered or zombie, create fresh + mode := &ZwlrOutputModeV1{} + mode.SetContext(i.Context()) + mode.SetID(objectID) + registerServerProxy(i.Context(), mode, objectID) + e.Mode = mode + } else if mode, ok := proxy.(*ZwlrOutputModeV1); ok { + e.Mode = mode + } else { + // Stale proxy of wrong type (can happen after suspend/resume) + // Replace it with the correct type + mode := &ZwlrOutputModeV1{} + mode.SetContext(i.Context()) + mode.SetID(objectID) + registerServerProxy(i.Context(), mode, objectID) + e.Mode = mode + } + l += 4 + + i.currentModeHandler(e) + case 6: + if i.positionHandler == nil { + return + } + var e ZwlrOutputHeadV1PositionEvent + l := 0 + e.X = int32(client.Uint32(data[l : l+4])) + l += 4 + e.Y = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.positionHandler(e) + case 7: + if i.transformHandler == nil { + return + } + var e ZwlrOutputHeadV1TransformEvent + l := 0 + e.Transform = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.transformHandler(e) + case 8: + if i.scaleHandler == nil { + return + } + var e ZwlrOutputHeadV1ScaleEvent + l := 0 + e.Scale = client.Fixed(data[l : l+4]) + l += 4 + + i.scaleHandler(e) + case 9: + if i.finishedHandler == nil { + return + } + var e ZwlrOutputHeadV1FinishedEvent + + i.finishedHandler(e) + case 10: + if i.makeHandler == nil { + return + } + var e ZwlrOutputHeadV1MakeEvent + l := 0 + makeLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Make = client.String(data[l : l+makeLen]) + l += makeLen + + i.makeHandler(e) + case 11: + if i.modelHandler == nil { + return + } + var e ZwlrOutputHeadV1ModelEvent + l := 0 + modelLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.Model = client.String(data[l : l+modelLen]) + l += modelLen + + i.modelHandler(e) + case 12: + if i.serialNumberHandler == nil { + return + } + var e ZwlrOutputHeadV1SerialNumberEvent + l := 0 + serialNumberLen := client.PaddedLen(int(client.Uint32(data[l : l+4]))) + l += 4 + e.SerialNumber = client.String(data[l : l+serialNumberLen]) + l += serialNumberLen + + i.serialNumberHandler(e) + case 13: + if i.adaptiveSyncHandler == nil { + return + } + var e ZwlrOutputHeadV1AdaptiveSyncEvent + l := 0 + e.State = client.Uint32(data[l : l+4]) + l += 4 + + i.adaptiveSyncHandler(e) + } +} + +// ZwlrOutputModeV1InterfaceName 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 ZwlrOutputModeV1InterfaceName = "zwlr_output_mode_v1" + +// ZwlrOutputModeV1 : output mode +// +// This object describes an output mode. +// +// Some heads don't support output modes, in which case modes won't be +// advertised. +// +// Properties sent via this interface are applied atomically via the +// wlr_output_manager.done event. No guarantees are made regarding the order +// in which properties are sent. +type ZwlrOutputModeV1 struct { + client.BaseProxy + sizeHandler ZwlrOutputModeV1SizeHandlerFunc + refreshHandler ZwlrOutputModeV1RefreshHandlerFunc + preferredHandler ZwlrOutputModeV1PreferredHandlerFunc + finishedHandler ZwlrOutputModeV1FinishedHandlerFunc +} + +// NewZwlrOutputModeV1 : output mode +// +// This object describes an output mode. +// +// Some heads don't support output modes, in which case modes won't be +// advertised. +// +// Properties sent via this interface are applied atomically via the +// wlr_output_manager.done event. No guarantees are made regarding the order +// in which properties are sent. +func NewZwlrOutputModeV1(ctx *client.Context) *ZwlrOutputModeV1 { + zwlrOutputModeV1 := &ZwlrOutputModeV1{} + ctx.Register(zwlrOutputModeV1) + return zwlrOutputModeV1 +} + +// Release : destroy the mode object +// +// This request indicates that the client will no longer use this mode +// object. +func (i *ZwlrOutputModeV1) Release() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ZwlrOutputModeV1SizeEvent : mode size +// +// This event describes the mode size. The size 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 or transformed. +type ZwlrOutputModeV1SizeEvent struct { + Width int32 + Height int32 +} +type ZwlrOutputModeV1SizeHandlerFunc func(ZwlrOutputModeV1SizeEvent) + +// SetSizeHandler : sets handler for ZwlrOutputModeV1SizeEvent +func (i *ZwlrOutputModeV1) SetSizeHandler(f ZwlrOutputModeV1SizeHandlerFunc) { + i.sizeHandler = f +} + +// ZwlrOutputModeV1RefreshEvent : mode refresh rate +// +// This event describes the mode's fixed vertical refresh rate. It is only +// sent if the mode has a fixed refresh rate. +type ZwlrOutputModeV1RefreshEvent struct { + Refresh int32 +} +type ZwlrOutputModeV1RefreshHandlerFunc func(ZwlrOutputModeV1RefreshEvent) + +// SetRefreshHandler : sets handler for ZwlrOutputModeV1RefreshEvent +func (i *ZwlrOutputModeV1) SetRefreshHandler(f ZwlrOutputModeV1RefreshHandlerFunc) { + i.refreshHandler = f +} + +// ZwlrOutputModeV1PreferredEvent : mode is preferred +// +// This event advertises this mode as preferred. +type ZwlrOutputModeV1PreferredEvent struct{} +type ZwlrOutputModeV1PreferredHandlerFunc func(ZwlrOutputModeV1PreferredEvent) + +// SetPreferredHandler : sets handler for ZwlrOutputModeV1PreferredEvent +func (i *ZwlrOutputModeV1) SetPreferredHandler(f ZwlrOutputModeV1PreferredHandlerFunc) { + i.preferredHandler = f +} + +// ZwlrOutputModeV1FinishedEvent : the mode has disappeared +// +// This event indicates that the mode is no longer available. The mode +// object becomes inert. Clients should send a destroy request and release +// any resources associated with it. +type ZwlrOutputModeV1FinishedEvent struct{} +type ZwlrOutputModeV1FinishedHandlerFunc func(ZwlrOutputModeV1FinishedEvent) + +// SetFinishedHandler : sets handler for ZwlrOutputModeV1FinishedEvent +func (i *ZwlrOutputModeV1) SetFinishedHandler(f ZwlrOutputModeV1FinishedHandlerFunc) { + i.finishedHandler = f +} + +func (i *ZwlrOutputModeV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.sizeHandler == nil { + return + } + var e ZwlrOutputModeV1SizeEvent + l := 0 + e.Width = int32(client.Uint32(data[l : l+4])) + l += 4 + e.Height = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.sizeHandler(e) + case 1: + if i.refreshHandler == nil { + return + } + var e ZwlrOutputModeV1RefreshEvent + l := 0 + e.Refresh = int32(client.Uint32(data[l : l+4])) + l += 4 + + i.refreshHandler(e) + case 2: + if i.preferredHandler == nil { + return + } + var e ZwlrOutputModeV1PreferredEvent + + i.preferredHandler(e) + case 3: + if i.finishedHandler == nil { + return + } + var e ZwlrOutputModeV1FinishedEvent + + i.finishedHandler(e) + } +} + +// ZwlrOutputConfigurationV1InterfaceName 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 ZwlrOutputConfigurationV1InterfaceName = "zwlr_output_configuration_v1" + +// ZwlrOutputConfigurationV1 : output configuration +// +// This object is used by the client to describe a full output configuration. +// +// First, the client needs to setup the output configuration. Each head can +// be either enabled (and configured) or disabled. It is a protocol error to +// send two enable_head or disable_head requests with the same head. It is a +// protocol error to omit a head in a configuration. +// +// Then, the client can apply or test the configuration. The compositor will +// then reply with a succeeded, failed or cancelled event. Finally the client +// should destroy the configuration object. +type ZwlrOutputConfigurationV1 struct { + client.BaseProxy + succeededHandler ZwlrOutputConfigurationV1SucceededHandlerFunc + failedHandler ZwlrOutputConfigurationV1FailedHandlerFunc + cancelledHandler ZwlrOutputConfigurationV1CancelledHandlerFunc +} + +// NewZwlrOutputConfigurationV1 : output configuration +// +// This object is used by the client to describe a full output configuration. +// +// First, the client needs to setup the output configuration. Each head can +// be either enabled (and configured) or disabled. It is a protocol error to +// send two enable_head or disable_head requests with the same head. It is a +// protocol error to omit a head in a configuration. +// +// Then, the client can apply or test the configuration. The compositor will +// then reply with a succeeded, failed or cancelled event. Finally the client +// should destroy the configuration object. +func NewZwlrOutputConfigurationV1(ctx *client.Context) *ZwlrOutputConfigurationV1 { + zwlrOutputConfigurationV1 := &ZwlrOutputConfigurationV1{} + ctx.Register(zwlrOutputConfigurationV1) + return zwlrOutputConfigurationV1 +} + +// EnableHead : enable and configure a head +// +// Enable a head. This request creates a head configuration object that can +// be used to change the head's properties. +// +// head: the head to be enabled +func (i *ZwlrOutputConfigurationV1) EnableHead(head *ZwlrOutputHeadV1) (*ZwlrOutputConfigurationHeadV1, error) { + id := NewZwlrOutputConfigurationHeadV1(i.Context()) + const opcode = 0 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], head.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// DisableHead : disable a head +// +// Disable a head. +// +// head: the head to be disabled +func (i *ZwlrOutputConfigurationV1) DisableHead(head *ZwlrOutputHeadV1) error { + const opcode = 1 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], head.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Apply : apply the configuration +// +// Apply the new output configuration. +// +// In case the configuration is successfully applied, there is no guarantee +// that the new output state matches completely the requested +// configuration. For instance, a compositor might round the scale if it +// doesn't support fractional scaling. +// +// After this request has been sent, the compositor must respond with an +// succeeded, failed or cancelled event. Sending a request that isn't the +// destructor is a protocol error. +func (i *ZwlrOutputConfigurationV1) Apply() error { + const opcode = 2 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Test : test the configuration +// +// Test the new output configuration. The configuration won't be applied, +// but will only be validated. +// +// Even if the compositor succeeds to test a configuration, applying it may +// fail. +// +// After this request has been sent, the compositor must respond with an +// succeeded, failed or cancelled event. Sending a request that isn't the +// destructor is a protocol error. +func (i *ZwlrOutputConfigurationV1) Test() error { + const opcode = 3 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Destroy : destroy the output configuration +// +// Using this request a client can tell the compositor that it is not going +// to use the configuration object anymore. Any changes to the outputs +// that have not been applied will be discarded. +// +// This request also destroys wlr_output_configuration_head objects created +// via this object. +func (i *ZwlrOutputConfigurationV1) Destroy() error { + defer i.MarkZombie() + const opcode = 4 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrOutputConfigurationV1Error uint32 + +// ZwlrOutputConfigurationV1Error : +const ( + // ZwlrOutputConfigurationV1ErrorAlreadyConfiguredHead : head has been configured twice + ZwlrOutputConfigurationV1ErrorAlreadyConfiguredHead ZwlrOutputConfigurationV1Error = 1 + // ZwlrOutputConfigurationV1ErrorUnconfiguredHead : head has not been configured + ZwlrOutputConfigurationV1ErrorUnconfiguredHead ZwlrOutputConfigurationV1Error = 2 + // ZwlrOutputConfigurationV1ErrorAlreadyUsed : request sent after configuration has been applied or tested + ZwlrOutputConfigurationV1ErrorAlreadyUsed ZwlrOutputConfigurationV1Error = 3 +) + +func (e ZwlrOutputConfigurationV1Error) Name() string { + switch e { + case ZwlrOutputConfigurationV1ErrorAlreadyConfiguredHead: + return "already_configured_head" + case ZwlrOutputConfigurationV1ErrorUnconfiguredHead: + return "unconfigured_head" + case ZwlrOutputConfigurationV1ErrorAlreadyUsed: + return "already_used" + default: + return "" + } +} + +func (e ZwlrOutputConfigurationV1Error) Value() string { + switch e { + case ZwlrOutputConfigurationV1ErrorAlreadyConfiguredHead: + return "1" + case ZwlrOutputConfigurationV1ErrorUnconfiguredHead: + return "2" + case ZwlrOutputConfigurationV1ErrorAlreadyUsed: + return "3" + default: + return "" + } +} + +func (e ZwlrOutputConfigurationV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrOutputConfigurationV1SucceededEvent : configuration changes succeeded +// +// Sent after the compositor has successfully applied the changes or +// tested them. +// +// Upon receiving this event, the client should destroy this object. +// +// If the current configuration has changed, events to describe the changes +// will be sent followed by a wlr_output_manager.done event. +type ZwlrOutputConfigurationV1SucceededEvent struct{} +type ZwlrOutputConfigurationV1SucceededHandlerFunc func(ZwlrOutputConfigurationV1SucceededEvent) + +// SetSucceededHandler : sets handler for ZwlrOutputConfigurationV1SucceededEvent +func (i *ZwlrOutputConfigurationV1) SetSucceededHandler(f ZwlrOutputConfigurationV1SucceededHandlerFunc) { + i.succeededHandler = f +} + +// ZwlrOutputConfigurationV1FailedEvent : configuration changes failed +// +// Sent if the compositor rejects the changes or failed to apply them. The +// compositor should revert any changes made by the apply request that +// triggered this event. +// +// Upon receiving this event, the client should destroy this object. +type ZwlrOutputConfigurationV1FailedEvent struct{} +type ZwlrOutputConfigurationV1FailedHandlerFunc func(ZwlrOutputConfigurationV1FailedEvent) + +// SetFailedHandler : sets handler for ZwlrOutputConfigurationV1FailedEvent +func (i *ZwlrOutputConfigurationV1) SetFailedHandler(f ZwlrOutputConfigurationV1FailedHandlerFunc) { + i.failedHandler = f +} + +// ZwlrOutputConfigurationV1CancelledEvent : configuration has been cancelled +// +// Sent if the compositor cancels the configuration because the state of an +// output changed and the client has outdated information (e.g. after an +// output has been hotplugged). +// +// The client can create a new configuration with a newer serial and try +// again. +// +// Upon receiving this event, the client should destroy this object. +type ZwlrOutputConfigurationV1CancelledEvent struct{} +type ZwlrOutputConfigurationV1CancelledHandlerFunc func(ZwlrOutputConfigurationV1CancelledEvent) + +// SetCancelledHandler : sets handler for ZwlrOutputConfigurationV1CancelledEvent +func (i *ZwlrOutputConfigurationV1) SetCancelledHandler(f ZwlrOutputConfigurationV1CancelledHandlerFunc) { + i.cancelledHandler = f +} + +func (i *ZwlrOutputConfigurationV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.succeededHandler == nil { + return + } + var e ZwlrOutputConfigurationV1SucceededEvent + + i.succeededHandler(e) + case 1: + if i.failedHandler == nil { + return + } + var e ZwlrOutputConfigurationV1FailedEvent + + i.failedHandler(e) + case 2: + if i.cancelledHandler == nil { + return + } + var e ZwlrOutputConfigurationV1CancelledEvent + + i.cancelledHandler(e) + } +} + +// ZwlrOutputConfigurationHeadV1InterfaceName 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 ZwlrOutputConfigurationHeadV1InterfaceName = "zwlr_output_configuration_head_v1" + +// ZwlrOutputConfigurationHeadV1 : head configuration +// +// This object is used by the client to update a single head's configuration. +// +// It is a protocol error to set the same property twice. +type ZwlrOutputConfigurationHeadV1 struct { + client.BaseProxy +} + +// NewZwlrOutputConfigurationHeadV1 : head configuration +// +// This object is used by the client to update a single head's configuration. +// +// It is a protocol error to set the same property twice. +func NewZwlrOutputConfigurationHeadV1(ctx *client.Context) *ZwlrOutputConfigurationHeadV1 { + zwlrOutputConfigurationHeadV1 := &ZwlrOutputConfigurationHeadV1{} + ctx.Register(zwlrOutputConfigurationHeadV1) + return zwlrOutputConfigurationHeadV1 +} + +// SetMode : set the mode +// +// This request sets the head's mode. +func (i *ZwlrOutputConfigurationHeadV1) SetMode(mode *ZwlrOutputModeV1) error { + const opcode = 0 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], mode.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetCustomMode : set a custom mode +// +// This request assigns a custom mode to the head. The size is given in +// physical hardware units of the output device. If set to zero, the +// refresh rate is unspecified. +// +// It is a protocol error to set both a mode and a custom mode. +// +// width: width of the mode in hardware units +// height: height of the mode in hardware units +// refresh: vertical refresh rate in mHz or zero +func (i *ZwlrOutputConfigurationHeadV1) SetCustomMode(width, height, refresh int32) error { + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(width)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(height)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(refresh)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetPosition : set the position +// +// This request sets the head's position in the global compositor space. +// +// x: x position in the global compositor space +// y: y position in the global compositor space +func (i *ZwlrOutputConfigurationHeadV1) SetPosition(x, y int32) error { + const opcode = 2 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(x)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(y)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetTransform : set the transform +// +// This request sets the head's transform. +func (i *ZwlrOutputConfigurationHeadV1) SetTransform(transform int32) error { + const opcode = 3 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(transform)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetScale : set the scale +// +// This request sets the head's scale. +func (i *ZwlrOutputConfigurationHeadV1) SetScale(scale float64) error { + const opcode = 4 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutFixed(_reqBuf[l:l+4], scale) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetAdaptiveSync : enable/disable adaptive sync +// +// This request enables/disables adaptive sync. Adaptive sync is also +// known as Variable Refresh Rate or VRR. +func (i *ZwlrOutputConfigurationHeadV1) SetAdaptiveSync(state uint32) error { + const opcode = 5 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(state)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +func (i *ZwlrOutputConfigurationHeadV1) Destroy() error { + i.MarkZombie() + return nil +} + +type ZwlrOutputConfigurationHeadV1Error uint32 + +// ZwlrOutputConfigurationHeadV1Error : +const ( + // ZwlrOutputConfigurationHeadV1ErrorAlreadySet : property has already been set + ZwlrOutputConfigurationHeadV1ErrorAlreadySet ZwlrOutputConfigurationHeadV1Error = 1 + // ZwlrOutputConfigurationHeadV1ErrorInvalidMode : mode doesn't belong to head + ZwlrOutputConfigurationHeadV1ErrorInvalidMode ZwlrOutputConfigurationHeadV1Error = 2 + // ZwlrOutputConfigurationHeadV1ErrorInvalidCustomMode : mode is invalid + ZwlrOutputConfigurationHeadV1ErrorInvalidCustomMode ZwlrOutputConfigurationHeadV1Error = 3 + // ZwlrOutputConfigurationHeadV1ErrorInvalidTransform : transform value outside enum + ZwlrOutputConfigurationHeadV1ErrorInvalidTransform ZwlrOutputConfigurationHeadV1Error = 4 + // ZwlrOutputConfigurationHeadV1ErrorInvalidScale : scale negative or zero + ZwlrOutputConfigurationHeadV1ErrorInvalidScale ZwlrOutputConfigurationHeadV1Error = 5 + // ZwlrOutputConfigurationHeadV1ErrorInvalidAdaptiveSyncState : invalid enum value used in the set_adaptive_sync request + ZwlrOutputConfigurationHeadV1ErrorInvalidAdaptiveSyncState ZwlrOutputConfigurationHeadV1Error = 6 +) + +func (e ZwlrOutputConfigurationHeadV1Error) Name() string { + switch e { + case ZwlrOutputConfigurationHeadV1ErrorAlreadySet: + return "already_set" + case ZwlrOutputConfigurationHeadV1ErrorInvalidMode: + return "invalid_mode" + case ZwlrOutputConfigurationHeadV1ErrorInvalidCustomMode: + return "invalid_custom_mode" + case ZwlrOutputConfigurationHeadV1ErrorInvalidTransform: + return "invalid_transform" + case ZwlrOutputConfigurationHeadV1ErrorInvalidScale: + return "invalid_scale" + case ZwlrOutputConfigurationHeadV1ErrorInvalidAdaptiveSyncState: + return "invalid_adaptive_sync_state" + default: + return "" + } +} + +func (e ZwlrOutputConfigurationHeadV1Error) Value() string { + switch e { + case ZwlrOutputConfigurationHeadV1ErrorAlreadySet: + return "1" + case ZwlrOutputConfigurationHeadV1ErrorInvalidMode: + return "2" + case ZwlrOutputConfigurationHeadV1ErrorInvalidCustomMode: + return "3" + case ZwlrOutputConfigurationHeadV1ErrorInvalidTransform: + return "4" + case ZwlrOutputConfigurationHeadV1ErrorInvalidScale: + return "5" + case ZwlrOutputConfigurationHeadV1ErrorInvalidAdaptiveSyncState: + return "6" + default: + return "" + } +} + +func (e ZwlrOutputConfigurationHeadV1Error) String() string { + return e.Name() + "=" + e.Value() +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_output_power/output_power.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_output_power/output_power.go new file mode 100644 index 0000000..8a10088 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_output_power/output_power.go @@ -0,0 +1,283 @@ +// Generated by go-wayland-scanner +// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner +// XML file : internal/proto/xml/wlr-output-power-management-unstable-v1.xml +// +// wlr_output_power_management_unstable_v1 Protocol Copyright: +// +// Copyright © 2019 Purism SPC +// +// 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 wlr_output_power + +import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + +// ZwlrOutputPowerManagerV1InterfaceName 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 ZwlrOutputPowerManagerV1InterfaceName = "zwlr_output_power_manager_v1" + +// ZwlrOutputPowerManagerV1 : manager to create per-output power management +// +// This interface is a manager that allows creating per-output power +// management mode controls. +type ZwlrOutputPowerManagerV1 struct { + client.BaseProxy +} + +// NewZwlrOutputPowerManagerV1 : manager to create per-output power management +// +// This interface is a manager that allows creating per-output power +// management mode controls. +func NewZwlrOutputPowerManagerV1(ctx *client.Context) *ZwlrOutputPowerManagerV1 { + zwlrOutputPowerManagerV1 := &ZwlrOutputPowerManagerV1{} + ctx.Register(zwlrOutputPowerManagerV1) + return zwlrOutputPowerManagerV1 +} + +// GetOutputPower : get a power management for an output +// +// Create an output power management mode control that can be used to +// adjust the power management mode for a given output. +func (i *ZwlrOutputPowerManagerV1) GetOutputPower(output *client.Output) (*ZwlrOutputPowerV1, error) { + id := NewZwlrOutputPowerV1(i.Context()) + const opcode = 0 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], output.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +// Destroy : destroy the manager +// +// All objects created by the manager will still remain valid, until their +// appropriate destroy request has been called. +func (i *ZwlrOutputPowerManagerV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ZwlrOutputPowerV1InterfaceName 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 ZwlrOutputPowerV1InterfaceName = "zwlr_output_power_v1" + +// ZwlrOutputPowerV1 : adjust power management mode for an output +// +// This object offers requests to set the power management mode of +// an output. +type ZwlrOutputPowerV1 struct { + client.BaseProxy + modeHandler ZwlrOutputPowerV1ModeHandlerFunc + failedHandler ZwlrOutputPowerV1FailedHandlerFunc +} + +// NewZwlrOutputPowerV1 : adjust power management mode for an output +// +// This object offers requests to set the power management mode of +// an output. +func NewZwlrOutputPowerV1(ctx *client.Context) *ZwlrOutputPowerV1 { + zwlrOutputPowerV1 := &ZwlrOutputPowerV1{} + ctx.Register(zwlrOutputPowerV1) + return zwlrOutputPowerV1 +} + +// SetMode : Set an outputs power save mode +// +// Set an output's power save mode to the given mode. The mode change +// is effective immediately. If the output does not support the given +// mode a failed event is sent. +// +// mode: the power save mode to set +func (i *ZwlrOutputPowerV1) SetMode(mode uint32) error { + const opcode = 0 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(mode)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Destroy : destroy this power management +// +// Destroys the output power management mode control object. +func (i *ZwlrOutputPowerV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrOutputPowerV1Mode uint32 + +// ZwlrOutputPowerV1Mode : +const ( + // ZwlrOutputPowerV1ModeOff : Output is turned off. + ZwlrOutputPowerV1ModeOff ZwlrOutputPowerV1Mode = 0 + // ZwlrOutputPowerV1ModeOn : Output is turned on, no power saving + ZwlrOutputPowerV1ModeOn ZwlrOutputPowerV1Mode = 1 +) + +func (e ZwlrOutputPowerV1Mode) Name() string { + switch e { + case ZwlrOutputPowerV1ModeOff: + return "off" + case ZwlrOutputPowerV1ModeOn: + return "on" + default: + return "" + } +} + +func (e ZwlrOutputPowerV1Mode) Value() string { + switch e { + case ZwlrOutputPowerV1ModeOff: + return "0" + case ZwlrOutputPowerV1ModeOn: + return "1" + default: + return "" + } +} + +func (e ZwlrOutputPowerV1Mode) String() string { + return e.Name() + "=" + e.Value() +} + +type ZwlrOutputPowerV1Error uint32 + +// ZwlrOutputPowerV1Error : +const ( + // ZwlrOutputPowerV1ErrorInvalidMode : nonexistent power save mode + ZwlrOutputPowerV1ErrorInvalidMode ZwlrOutputPowerV1Error = 1 +) + +func (e ZwlrOutputPowerV1Error) Name() string { + switch e { + case ZwlrOutputPowerV1ErrorInvalidMode: + return "invalid_mode" + default: + return "" + } +} + +func (e ZwlrOutputPowerV1Error) Value() string { + switch e { + case ZwlrOutputPowerV1ErrorInvalidMode: + return "1" + default: + return "" + } +} + +func (e ZwlrOutputPowerV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrOutputPowerV1ModeEvent : Report a power management mode change +// +// Report the power management mode change of an output. +// +// The mode event is sent after an output changed its power +// management mode. The reason can be a client using set_mode or the +// compositor deciding to change an output's mode. +// This event is also sent immediately when the object is created +// so the client is informed about the current power management mode. +type ZwlrOutputPowerV1ModeEvent struct { + Mode uint32 +} +type ZwlrOutputPowerV1ModeHandlerFunc func(ZwlrOutputPowerV1ModeEvent) + +// SetModeHandler : sets handler for ZwlrOutputPowerV1ModeEvent +func (i *ZwlrOutputPowerV1) SetModeHandler(f ZwlrOutputPowerV1ModeHandlerFunc) { + i.modeHandler = f +} + +// ZwlrOutputPowerV1FailedEvent : object no longer valid +// +// This event indicates that the output power management mode control +// is no longer valid. This can happen for a number of reasons, +// including: +// - The output doesn't support power management +// - Another client already has exclusive power management mode control +// for this output +// - The output disappeared +// +// Upon receiving this event, the client should destroy this object. +type ZwlrOutputPowerV1FailedEvent struct{} +type ZwlrOutputPowerV1FailedHandlerFunc func(ZwlrOutputPowerV1FailedEvent) + +// SetFailedHandler : sets handler for ZwlrOutputPowerV1FailedEvent +func (i *ZwlrOutputPowerV1) SetFailedHandler(f ZwlrOutputPowerV1FailedHandlerFunc) { + i.failedHandler = f +} + +func (i *ZwlrOutputPowerV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.modeHandler == nil { + return + } + var e ZwlrOutputPowerV1ModeEvent + l := 0 + e.Mode = client.Uint32(data[l : l+4]) + l += 4 + + i.modeHandler(e) + case 1: + if i.failedHandler == nil { + return + } + var e ZwlrOutputPowerV1FailedEvent + + i.failedHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_screencopy/screencopy.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_screencopy/screencopy.go new file mode 100644 index 0000000..edb9c5b --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wlr_screencopy/screencopy.go @@ -0,0 +1,532 @@ +// Generated by go-wayland-scanner +// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner +// XML file : internal/proto/xml/wlr-screencopy-unstable-v1.xml +// +// wlr_screencopy_unstable_v1 Protocol Copyright: +// +// Copyright © 2018 Simon Ser +// Copyright © 2019 Andri Yngvason +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice (including the next +// paragraph) shall be included in all copies or substantial portions of the +// Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +package wlr_screencopy + +import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + +// ZwlrScreencopyManagerV1InterfaceName 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 ZwlrScreencopyManagerV1InterfaceName = "zwlr_screencopy_manager_v1" + +// ZwlrScreencopyManagerV1 : manager to inform clients and begin capturing +// +// This object is a manager which offers requests to start capturing from a +// source. +type ZwlrScreencopyManagerV1 struct { + client.BaseProxy +} + +// NewZwlrScreencopyManagerV1 : manager to inform clients and begin capturing +// +// This object is a manager which offers requests to start capturing from a +// source. +func NewZwlrScreencopyManagerV1(ctx *client.Context) *ZwlrScreencopyManagerV1 { + zwlrScreencopyManagerV1 := &ZwlrScreencopyManagerV1{} + ctx.Register(zwlrScreencopyManagerV1) + return zwlrScreencopyManagerV1 +} + +// CaptureOutput : capture an output +// +// Capture the next frame of an entire output. +// +// overlayCursor: composite cursor onto the frame +func (i *ZwlrScreencopyManagerV1) CaptureOutput(overlayCursor int32, output *client.Output) (*ZwlrScreencopyFrameV1, error) { + frame := NewZwlrScreencopyFrameV1(i.Context()) + const opcode = 0 + const _reqBufLen = 8 + 4 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], frame.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(overlayCursor)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], output.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return frame, err +} + +// CaptureOutputRegion : capture an output's region +// +// Capture the next frame of an output's region. +// +// The region is given in output logical coordinates, see +// xdg_output.logical_size. The region will be clipped to the output's +// extents. +// +// overlayCursor: composite cursor onto the frame +func (i *ZwlrScreencopyManagerV1) CaptureOutputRegion(overlayCursor int32, output *client.Output, x, y, width, height int32) (*ZwlrScreencopyFrameV1, error) { + frame := NewZwlrScreencopyFrameV1(i.Context()) + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], frame.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(overlayCursor)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], output.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(x)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(y)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(width)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(height)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return frame, err +} + +// Destroy : destroy the manager +// +// All objects created by the manager will still remain valid, until their +// appropriate destroy request has been called. +func (i *ZwlrScreencopyManagerV1) Destroy() error { + defer i.MarkZombie() + const opcode = 2 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// ZwlrScreencopyFrameV1InterfaceName 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 ZwlrScreencopyFrameV1InterfaceName = "zwlr_screencopy_frame_v1" + +// ZwlrScreencopyFrameV1 : a frame ready for copy +// +// This object represents a single frame. +// +// When created, a series of buffer events will be sent, each representing a +// supported buffer type. The "buffer_done" event is sent afterwards to +// indicate that all supported buffer types have been enumerated. The client +// will then be able to send a "copy" request. If the capture is successful, +// the compositor will send a "flags" event followed by a "ready" event. +// +// For objects version 2 or lower, wl_shm buffers are always supported, ie. +// the "buffer" event is guaranteed to be sent. +// +// If the capture failed, the "failed" event is sent. This can happen anytime +// before the "ready" event. +// +// Once either a "ready" or a "failed" event is received, the client should +// destroy the frame. +type ZwlrScreencopyFrameV1 struct { + client.BaseProxy + bufferHandler ZwlrScreencopyFrameV1BufferHandlerFunc + flagsHandler ZwlrScreencopyFrameV1FlagsHandlerFunc + readyHandler ZwlrScreencopyFrameV1ReadyHandlerFunc + failedHandler ZwlrScreencopyFrameV1FailedHandlerFunc + damageHandler ZwlrScreencopyFrameV1DamageHandlerFunc + linuxDmabufHandler ZwlrScreencopyFrameV1LinuxDmabufHandlerFunc + bufferDoneHandler ZwlrScreencopyFrameV1BufferDoneHandlerFunc +} + +// NewZwlrScreencopyFrameV1 : a frame ready for copy +// +// This object represents a single frame. +// +// When created, a series of buffer events will be sent, each representing a +// supported buffer type. The "buffer_done" event is sent afterwards to +// indicate that all supported buffer types have been enumerated. The client +// will then be able to send a "copy" request. If the capture is successful, +// the compositor will send a "flags" event followed by a "ready" event. +// +// For objects version 2 or lower, wl_shm buffers are always supported, ie. +// the "buffer" event is guaranteed to be sent. +// +// If the capture failed, the "failed" event is sent. This can happen anytime +// before the "ready" event. +// +// Once either a "ready" or a "failed" event is received, the client should +// destroy the frame. +func NewZwlrScreencopyFrameV1(ctx *client.Context) *ZwlrScreencopyFrameV1 { + zwlrScreencopyFrameV1 := &ZwlrScreencopyFrameV1{} + ctx.Register(zwlrScreencopyFrameV1) + return zwlrScreencopyFrameV1 +} + +// Copy : copy the frame +// +// Copy the frame to the supplied buffer. The buffer must have the +// correct size, see zwlr_screencopy_frame_v1.buffer and +// zwlr_screencopy_frame_v1.linux_dmabuf. The buffer needs to have a +// supported format. +// +// If the frame is successfully copied, "flags" and "ready" events are +// sent. Otherwise, a "failed" event is sent. +func (i *ZwlrScreencopyFrameV1) Copy(buffer *client.Buffer) error { + const opcode = 0 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], buffer.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// Destroy : delete this object, used or not +// +// Destroys the frame. This request can be sent at any time by the client. +func (i *ZwlrScreencopyFrameV1) Destroy() error { + defer i.MarkZombie() + const opcode = 1 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// CopyWithDamage : copy the frame when it's damaged +// +// Same as copy, except it waits until there is damage to copy. +func (i *ZwlrScreencopyFrameV1) CopyWithDamage(buffer *client.Buffer) error { + const opcode = 2 + const _reqBufLen = 8 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], buffer.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type ZwlrScreencopyFrameV1Error uint32 + +// ZwlrScreencopyFrameV1Error : +const ( + // ZwlrScreencopyFrameV1ErrorAlreadyUsed : the object has already been used to copy a wl_buffer + ZwlrScreencopyFrameV1ErrorAlreadyUsed ZwlrScreencopyFrameV1Error = 0 + // ZwlrScreencopyFrameV1ErrorInvalidBuffer : buffer attributes are invalid + ZwlrScreencopyFrameV1ErrorInvalidBuffer ZwlrScreencopyFrameV1Error = 1 +) + +func (e ZwlrScreencopyFrameV1Error) Name() string { + switch e { + case ZwlrScreencopyFrameV1ErrorAlreadyUsed: + return "already_used" + case ZwlrScreencopyFrameV1ErrorInvalidBuffer: + return "invalid_buffer" + default: + return "" + } +} + +func (e ZwlrScreencopyFrameV1Error) Value() string { + switch e { + case ZwlrScreencopyFrameV1ErrorAlreadyUsed: + return "0" + case ZwlrScreencopyFrameV1ErrorInvalidBuffer: + return "1" + default: + return "" + } +} + +func (e ZwlrScreencopyFrameV1Error) String() string { + return e.Name() + "=" + e.Value() +} + +type ZwlrScreencopyFrameV1Flags uint32 + +// ZwlrScreencopyFrameV1Flags : +const ( + // ZwlrScreencopyFrameV1FlagsYInvert : contents are y-inverted + ZwlrScreencopyFrameV1FlagsYInvert ZwlrScreencopyFrameV1Flags = 1 +) + +func (e ZwlrScreencopyFrameV1Flags) Name() string { + switch e { + case ZwlrScreencopyFrameV1FlagsYInvert: + return "y_invert" + default: + return "" + } +} + +func (e ZwlrScreencopyFrameV1Flags) Value() string { + switch e { + case ZwlrScreencopyFrameV1FlagsYInvert: + return "1" + default: + return "" + } +} + +func (e ZwlrScreencopyFrameV1Flags) String() string { + return e.Name() + "=" + e.Value() +} + +// ZwlrScreencopyFrameV1BufferEvent : wl_shm buffer information +// +// Provides information about wl_shm buffer parameters that need to be +// used for this frame. This event is sent once after the frame is created +// if wl_shm buffers are supported. +type ZwlrScreencopyFrameV1BufferEvent struct { + Format uint32 + Width uint32 + Height uint32 + Stride uint32 +} +type ZwlrScreencopyFrameV1BufferHandlerFunc func(ZwlrScreencopyFrameV1BufferEvent) + +// SetBufferHandler : sets handler for ZwlrScreencopyFrameV1BufferEvent +func (i *ZwlrScreencopyFrameV1) SetBufferHandler(f ZwlrScreencopyFrameV1BufferHandlerFunc) { + i.bufferHandler = f +} + +// ZwlrScreencopyFrameV1FlagsEvent : frame flags +// +// Provides flags about the frame. This event is sent once before the +// "ready" event. +type ZwlrScreencopyFrameV1FlagsEvent struct { + Flags uint32 +} +type ZwlrScreencopyFrameV1FlagsHandlerFunc func(ZwlrScreencopyFrameV1FlagsEvent) + +// SetFlagsHandler : sets handler for ZwlrScreencopyFrameV1FlagsEvent +func (i *ZwlrScreencopyFrameV1) SetFlagsHandler(f ZwlrScreencopyFrameV1FlagsHandlerFunc) { + i.flagsHandler = f +} + +// ZwlrScreencopyFrameV1ReadyEvent : indicates frame is available for reading +// +// Called as soon as the frame is copied, indicating it is available +// for reading. This event includes the time at which the presentation took place. +// +// The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples, +// each component being an unsigned 32-bit value. Whole seconds are in +// tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo, +// and the additional fractional part in tv_nsec as nanoseconds. Hence, +// for valid timestamps tv_nsec must be in [0, 999999999]. The seconds part +// may have an arbitrary offset at start. +// +// After receiving this event, the client should destroy the object. +type ZwlrScreencopyFrameV1ReadyEvent struct { + TvSecHi uint32 + TvSecLo uint32 + TvNsec uint32 +} +type ZwlrScreencopyFrameV1ReadyHandlerFunc func(ZwlrScreencopyFrameV1ReadyEvent) + +// SetReadyHandler : sets handler for ZwlrScreencopyFrameV1ReadyEvent +func (i *ZwlrScreencopyFrameV1) SetReadyHandler(f ZwlrScreencopyFrameV1ReadyHandlerFunc) { + i.readyHandler = f +} + +// ZwlrScreencopyFrameV1FailedEvent : frame copy failed +// +// This event indicates that the attempted frame copy has failed. +// +// After receiving this event, the client should destroy the object. +type ZwlrScreencopyFrameV1FailedEvent struct{} +type ZwlrScreencopyFrameV1FailedHandlerFunc func(ZwlrScreencopyFrameV1FailedEvent) + +// SetFailedHandler : sets handler for ZwlrScreencopyFrameV1FailedEvent +func (i *ZwlrScreencopyFrameV1) SetFailedHandler(f ZwlrScreencopyFrameV1FailedHandlerFunc) { + i.failedHandler = f +} + +// ZwlrScreencopyFrameV1DamageEvent : carries the coordinates of the damaged region +// +// This event is sent right before the ready event when copy_with_damage is +// requested. It may be generated multiple times for each copy_with_damage +// request. +// +// The arguments describe a box around an area that has changed since the +// last copy request that was derived from the current screencopy manager +// instance. +// +// The union of all regions received between the call to copy_with_damage +// and a ready event is the total damage since the prior ready event. +type ZwlrScreencopyFrameV1DamageEvent struct { + X uint32 + Y uint32 + Width uint32 + Height uint32 +} +type ZwlrScreencopyFrameV1DamageHandlerFunc func(ZwlrScreencopyFrameV1DamageEvent) + +// SetDamageHandler : sets handler for ZwlrScreencopyFrameV1DamageEvent +func (i *ZwlrScreencopyFrameV1) SetDamageHandler(f ZwlrScreencopyFrameV1DamageHandlerFunc) { + i.damageHandler = f +} + +// ZwlrScreencopyFrameV1LinuxDmabufEvent : linux-dmabuf buffer information +// +// Provides information about linux-dmabuf buffer parameters that need to +// be used for this frame. This event is sent once after the frame is +// created if linux-dmabuf buffers are supported. +type ZwlrScreencopyFrameV1LinuxDmabufEvent struct { + Format uint32 + Width uint32 + Height uint32 +} +type ZwlrScreencopyFrameV1LinuxDmabufHandlerFunc func(ZwlrScreencopyFrameV1LinuxDmabufEvent) + +// SetLinuxDmabufHandler : sets handler for ZwlrScreencopyFrameV1LinuxDmabufEvent +func (i *ZwlrScreencopyFrameV1) SetLinuxDmabufHandler(f ZwlrScreencopyFrameV1LinuxDmabufHandlerFunc) { + i.linuxDmabufHandler = f +} + +// ZwlrScreencopyFrameV1BufferDoneEvent : all buffer types reported +// +// This event is sent once after all buffer events have been sent. +// +// The client should proceed to create a buffer of one of the supported +// types, and send a "copy" request. +type ZwlrScreencopyFrameV1BufferDoneEvent struct{} +type ZwlrScreencopyFrameV1BufferDoneHandlerFunc func(ZwlrScreencopyFrameV1BufferDoneEvent) + +// SetBufferDoneHandler : sets handler for ZwlrScreencopyFrameV1BufferDoneEvent +func (i *ZwlrScreencopyFrameV1) SetBufferDoneHandler(f ZwlrScreencopyFrameV1BufferDoneHandlerFunc) { + i.bufferDoneHandler = f +} + +func (i *ZwlrScreencopyFrameV1) Dispatch(opcode uint32, fd int, data []byte) { + switch opcode { + case 0: + if i.bufferHandler == nil { + return + } + var e ZwlrScreencopyFrameV1BufferEvent + l := 0 + e.Format = client.Uint32(data[l : l+4]) + l += 4 + e.Width = client.Uint32(data[l : l+4]) + l += 4 + e.Height = client.Uint32(data[l : l+4]) + l += 4 + e.Stride = client.Uint32(data[l : l+4]) + l += 4 + + i.bufferHandler(e) + case 1: + if i.flagsHandler == nil { + return + } + var e ZwlrScreencopyFrameV1FlagsEvent + l := 0 + e.Flags = client.Uint32(data[l : l+4]) + l += 4 + + i.flagsHandler(e) + case 2: + if i.readyHandler == nil { + return + } + var e ZwlrScreencopyFrameV1ReadyEvent + l := 0 + e.TvSecHi = client.Uint32(data[l : l+4]) + l += 4 + e.TvSecLo = client.Uint32(data[l : l+4]) + l += 4 + e.TvNsec = client.Uint32(data[l : l+4]) + l += 4 + + i.readyHandler(e) + case 3: + if i.failedHandler == nil { + return + } + var e ZwlrScreencopyFrameV1FailedEvent + + i.failedHandler(e) + case 4: + if i.damageHandler == nil { + return + } + var e ZwlrScreencopyFrameV1DamageEvent + l := 0 + e.X = client.Uint32(data[l : l+4]) + l += 4 + e.Y = client.Uint32(data[l : l+4]) + l += 4 + e.Width = client.Uint32(data[l : l+4]) + l += 4 + e.Height = client.Uint32(data[l : l+4]) + l += 4 + + i.damageHandler(e) + case 5: + if i.linuxDmabufHandler == nil { + return + } + var e ZwlrScreencopyFrameV1LinuxDmabufEvent + l := 0 + e.Format = client.Uint32(data[l : l+4]) + l += 4 + e.Width = client.Uint32(data[l : l+4]) + l += 4 + e.Height = client.Uint32(data[l : l+4]) + l += 4 + + i.linuxDmabufHandler(e) + case 6: + if i.bufferDoneHandler == nil { + return + } + var e ZwlrScreencopyFrameV1BufferDoneEvent + + i.bufferDoneHandler(e) + } +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wp_viewporter/viewporter.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wp_viewporter/viewporter.go new file mode 100644 index 0000000..4b390bf --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/wp_viewporter/viewporter.go @@ -0,0 +1,399 @@ +// Generated by go-wayland-scanner +// https://github.com/yaslama/go-wayland/cmd/go-wayland-scanner +// XML file : /tmp/viewporter.xml +// +// viewporter Protocol Copyright: +// +// Copyright © 2013-2016 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 wp_viewporter + +import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client" + +// WpViewporterInterfaceName 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 WpViewporterInterfaceName = "wp_viewporter" + +// WpViewporter : surface cropping and scaling +// +// The global interface exposing surface cropping and scaling +// capabilities is used to instantiate an interface extension for a +// wl_surface object. This extended interface will then allow +// cropping and scaling the surface contents, effectively +// disconnecting the direct relationship between the buffer and the +// surface size. +type WpViewporter struct { + client.BaseProxy +} + +// NewWpViewporter : surface cropping and scaling +// +// The global interface exposing surface cropping and scaling +// capabilities is used to instantiate an interface extension for a +// wl_surface object. This extended interface will then allow +// cropping and scaling the surface contents, effectively +// disconnecting the direct relationship between the buffer and the +// surface size. +func NewWpViewporter(ctx *client.Context) *WpViewporter { + wpViewporter := &WpViewporter{} + ctx.Register(wpViewporter) + return wpViewporter +} + +// Destroy : unbind from the cropping and scaling interface +// +// Informs the server that the client will not be using this +// protocol object anymore. This does not affect any other objects, +// wp_viewport objects included. +func (i *WpViewporter) Destroy() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// GetViewport : extend surface interface for crop and scale +// +// Instantiate an interface extension for the given wl_surface to +// crop and scale its content. If the given wl_surface already has +// a wp_viewport object associated, the viewport_exists +// protocol error is raised. +// +// surface: the surface +func (i *WpViewporter) GetViewport(surface *client.Surface) (*WpViewport, error) { + id := NewWpViewport(i.Context()) + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], id.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], surface.ID()) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return id, err +} + +type WpViewporterError uint32 + +// WpViewporterError : +const ( + // WpViewporterErrorViewportExists : the surface already has a viewport object associated + WpViewporterErrorViewportExists WpViewporterError = 0 +) + +func (e WpViewporterError) Name() string { + switch e { + case WpViewporterErrorViewportExists: + return "viewport_exists" + default: + return "" + } +} + +func (e WpViewporterError) Value() string { + switch e { + case WpViewporterErrorViewportExists: + return "0" + default: + return "" + } +} + +func (e WpViewporterError) String() string { + return e.Name() + "=" + e.Value() +} + +// WpViewportInterfaceName 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 WpViewportInterfaceName = "wp_viewport" + +// WpViewport : crop and scale interface to a wl_surface +// +// An additional interface to a wl_surface object, which allows the +// client to specify the cropping and scaling of the surface +// contents. +// +// This interface works with two concepts: the source rectangle (src_x, +// src_y, src_width, src_height), and the destination size (dst_width, +// dst_height). The contents of the source rectangle are scaled to the +// destination size, and content outside the source rectangle is ignored. +// This state is double-buffered, see wl_surface.commit. +// +// The two parts of crop and scale state are independent: the source +// rectangle, and the destination size. Initially both are unset, that +// is, no scaling is applied. The whole of the current wl_buffer is +// used as the source, and the surface size is as defined in +// wl_surface.attach. +// +// If the destination size is set, it causes the surface size to become +// dst_width, dst_height. The source (rectangle) is scaled to exactly +// this size. This overrides whatever the attached wl_buffer size is, +// unless the wl_buffer is NULL. If the wl_buffer is NULL, the surface +// has no content and therefore no size. Otherwise, the size is always +// at least 1x1 in surface local coordinates. +// +// If the source rectangle is set, it defines what area of the wl_buffer is +// taken as the source. If the source rectangle is set and the destination +// size is not set, then src_width and src_height must be integers, and the +// surface size becomes the source rectangle size. This results in cropping +// without scaling. If src_width or src_height are not integers and +// destination size is not set, the bad_size protocol error is raised when +// the surface state is applied. +// +// The coordinate transformations from buffer pixel coordinates up to +// the surface-local coordinates happen in the following order: +// 1. buffer_transform (wl_surface.set_buffer_transform) +// 2. buffer_scale (wl_surface.set_buffer_scale) +// 3. crop and scale (wp_viewport.set*) +// This means, that the source rectangle coordinates of crop and scale +// are given in the coordinates after the buffer transform and scale, +// i.e. in the coordinates that would be the surface-local coordinates +// if the crop and scale was not applied. +// +// If src_x or src_y are negative, the bad_value protocol error is raised. +// Otherwise, if the source rectangle is partially or completely outside of +// the non-NULL wl_buffer, then the out_of_buffer protocol error is raised +// when the surface state is applied. A NULL wl_buffer does not raise the +// out_of_buffer error. +// +// If the wl_surface associated with the wp_viewport is destroyed, +// all wp_viewport requests except 'destroy' raise the protocol error +// no_surface. +// +// If the wp_viewport object is destroyed, the crop and scale +// state is removed from the wl_surface. The change will be applied +// on the next wl_surface.commit. +type WpViewport struct { + client.BaseProxy +} + +// NewWpViewport : crop and scale interface to a wl_surface +// +// An additional interface to a wl_surface object, which allows the +// client to specify the cropping and scaling of the surface +// contents. +// +// This interface works with two concepts: the source rectangle (src_x, +// src_y, src_width, src_height), and the destination size (dst_width, +// dst_height). The contents of the source rectangle are scaled to the +// destination size, and content outside the source rectangle is ignored. +// This state is double-buffered, see wl_surface.commit. +// +// The two parts of crop and scale state are independent: the source +// rectangle, and the destination size. Initially both are unset, that +// is, no scaling is applied. The whole of the current wl_buffer is +// used as the source, and the surface size is as defined in +// wl_surface.attach. +// +// If the destination size is set, it causes the surface size to become +// dst_width, dst_height. The source (rectangle) is scaled to exactly +// this size. This overrides whatever the attached wl_buffer size is, +// unless the wl_buffer is NULL. If the wl_buffer is NULL, the surface +// has no content and therefore no size. Otherwise, the size is always +// at least 1x1 in surface local coordinates. +// +// If the source rectangle is set, it defines what area of the wl_buffer is +// taken as the source. If the source rectangle is set and the destination +// size is not set, then src_width and src_height must be integers, and the +// surface size becomes the source rectangle size. This results in cropping +// without scaling. If src_width or src_height are not integers and +// destination size is not set, the bad_size protocol error is raised when +// the surface state is applied. +// +// The coordinate transformations from buffer pixel coordinates up to +// the surface-local coordinates happen in the following order: +// 1. buffer_transform (wl_surface.set_buffer_transform) +// 2. buffer_scale (wl_surface.set_buffer_scale) +// 3. crop and scale (wp_viewport.set*) +// This means, that the source rectangle coordinates of crop and scale +// are given in the coordinates after the buffer transform and scale, +// i.e. in the coordinates that would be the surface-local coordinates +// if the crop and scale was not applied. +// +// If src_x or src_y are negative, the bad_value protocol error is raised. +// Otherwise, if the source rectangle is partially or completely outside of +// the non-NULL wl_buffer, then the out_of_buffer protocol error is raised +// when the surface state is applied. A NULL wl_buffer does not raise the +// out_of_buffer error. +// +// If the wl_surface associated with the wp_viewport is destroyed, +// all wp_viewport requests except 'destroy' raise the protocol error +// no_surface. +// +// If the wp_viewport object is destroyed, the crop and scale +// state is removed from the wl_surface. The change will be applied +// on the next wl_surface.commit. +func NewWpViewport(ctx *client.Context) *WpViewport { + wpViewport := &WpViewport{} + ctx.Register(wpViewport) + return wpViewport +} + +// Destroy : remove scaling and cropping from the surface +// +// The associated wl_surface's crop and scale state is removed. +// The change is applied on the next wl_surface.commit. +func (i *WpViewport) Destroy() error { + defer i.MarkZombie() + const opcode = 0 + const _reqBufLen = 8 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetSource : set the source rectangle for cropping +// +// Set the source rectangle of the associated wl_surface. See +// wp_viewport for the description, and relation to the wl_buffer +// size. +// +// If all of x, y, width and height are -1.0, the source rectangle is +// unset instead. Any other set of values where width or height are zero +// or negative, or x or y are negative, raise the bad_value protocol +// error. +// +// The crop and scale state is double-buffered, see wl_surface.commit. +// +// x: source rectangle x +// y: source rectangle y +// width: source rectangle width +// height: source rectangle height +func (i *WpViewport) SetSource(x, y, width, height float64) error { + const opcode = 1 + const _reqBufLen = 8 + 4 + 4 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutFixed(_reqBuf[l:l+4], x) + l += 4 + client.PutFixed(_reqBuf[l:l+4], y) + l += 4 + client.PutFixed(_reqBuf[l:l+4], width) + l += 4 + client.PutFixed(_reqBuf[l:l+4], height) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +// SetDestination : set the surface size for scaling +// +// Set the destination size of the associated wl_surface. See +// wp_viewport for the description, and relation to the wl_buffer +// size. +// +// If width is -1 and height is -1, the destination size is unset +// instead. Any other pair of values for width and height that +// contains zero or negative values raises the bad_value protocol +// error. +// +// The crop and scale state is double-buffered, see wl_surface.commit. +// +// width: surface width +// height: surface height +func (i *WpViewport) SetDestination(width, height int32) error { + const opcode = 2 + const _reqBufLen = 8 + 4 + 4 + var _reqBuf [_reqBufLen]byte + l := 0 + client.PutUint32(_reqBuf[l:4], i.ID()) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(width)) + l += 4 + client.PutUint32(_reqBuf[l:l+4], uint32(height)) + l += 4 + err := i.Context().WriteMsg(_reqBuf[:], nil) + return err +} + +type WpViewportError uint32 + +// WpViewportError : +const ( + // WpViewportErrorBadValue : negative or zero values in width or height + WpViewportErrorBadValue WpViewportError = 0 + // WpViewportErrorBadSize : destination size is not integer + WpViewportErrorBadSize WpViewportError = 1 + // WpViewportErrorOutOfBuffer : source rectangle extends outside of the content area + WpViewportErrorOutOfBuffer WpViewportError = 2 + // WpViewportErrorNoSurface : the wl_surface was destroyed + WpViewportErrorNoSurface WpViewportError = 3 +) + +func (e WpViewportError) Name() string { + switch e { + case WpViewportErrorBadValue: + return "bad_value" + case WpViewportErrorBadSize: + return "bad_size" + case WpViewportErrorOutOfBuffer: + return "out_of_buffer" + case WpViewportErrorNoSurface: + return "no_surface" + default: + return "" + } +} + +func (e WpViewportError) Value() string { + switch e { + case WpViewportErrorBadValue: + return "0" + case WpViewportErrorBadSize: + return "1" + case WpViewportErrorOutOfBuffer: + return "2" + case WpViewportErrorNoSurface: + return "3" + default: + return "" + } +} + +func (e WpViewportError) String() string { + return e.Name() + "=" + e.Value() +} diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/dwl-ipc-unstable-v2.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/dwl-ipc-unstable-v2.xml new file mode 100644 index 0000000..a4e0b49 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/dwl-ipc-unstable-v2.xml @@ -0,0 +1,252 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- +This is largely ripped from somebar's ipc patchset; just with some personal modifications. +I would probably just submit raphi's patchset but I don't think that would be polite. +--> +<protocol name="dwl_ipc_unstable_v2"> + <description summary="inter-proccess-communication about dwl's state"> + This protocol allows clients to update and get updates from dwl. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible + changes may be added together with the corresponding interface + version bump. + Backward incompatible changes are done by bumping the version + number in the protocol and interface names and resetting the + interface version. Once the protocol is to be declared stable, + the 'z' prefix and the version number in the protocol and + interface names are removed and the interface version number is + reset. + </description> + + <interface name="zdwl_ipc_manager_v2" version="2"> + <description summary="manage dwl state"> + This interface is exposed as a global in wl_registry. + + Clients can use this interface to get a dwl_ipc_output. + After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events. + The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client. + </description> + + <request name="release" type="destructor"> + <description summary="release dwl_ipc_manager"> + Indicates that the client will not the dwl_ipc_manager object anymore. + Objects created through this instance are not affected. + </description> + </request> + + <request name="get_output"> + <description summary="get a dwl_ipc_outout for a wl_output"> + Get a dwl_ipc_outout for the specified wl_output. + </description> + <arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/> + <arg name="output" type="object" interface="wl_output"/> + </request> + + <event name="tags"> + <description summary="Announces tag amount"> + This event is sent after binding. + A roundtrip after binding guarantees the client recieved all tags. + </description> + <arg name="amount" type="uint"/> + </event> + + <event name="layout"> + <description summary="Announces a layout"> + This event is sent after binding. + A roundtrip after binding guarantees the client recieved all layouts. + </description> + <arg name="name" type="string"/> + </event> + </interface> + + <interface name="zdwl_ipc_output_v2" version="2"> + <description summary="control dwl output"> + Observe and control a dwl output. + + Events are double-buffered: + Clients should cache events and redraw when a dwl_ipc_output.frame event is sent. + + Request are not double-buffered: + The compositor will update immediately upon request. + </description> + + <enum name="tag_state"> + <entry name="none" value="0" summary="no state"/> + <entry name="active" value="1" summary="tag is active"/> + <entry name="urgent" value="2" summary="tag has at least one urgent client"/> + </enum> + + <request name="release" type="destructor"> + <description summary="release dwl_ipc_outout"> + Indicates to that the client no longer needs this dwl_ipc_output. + </description> + </request> + + <event name="toggle_visibility"> + <description summary="Toggle client visibilty"> + Indicates the client should hide or show themselves. + If the client is visible then hide, if hidden then show. + </description> + </event> + + <event name="active"> + <description summary="Update the selected output."> + Indicates if the output is active. Zero is invalid, nonzero is valid. + </description> + <arg name="active" type="uint"/> + </event> + + <event name="tag"> + <description summary="Update the state of a tag."> + Indicates that a tag has been updated. + </description> + <arg name="tag" type="uint" summary="Index of the tag"/> + <arg name="state" type="uint" enum="tag_state" summary="The state of the tag."/> + <arg name="clients" type="uint" summary="The number of clients in the tag."/> + <arg name="focused" type="uint" summary="If there is a focused client. Nonzero being valid, zero being invalid."/> + </event> + + <event name="layout"> + <description summary="Update the layout."> + Indicates a new layout is selected. + </description> + <arg name="layout" type="uint" summary="Index of the layout."/> + </event> + + <event name="title"> + <description summary="Update the title."> + Indicates the title has changed. + </description> + <arg name="title" type="string" summary="The new title name."/> + </event> + + <event name="appid" since="1"> + <description summary="Update the appid."> + Indicates the appid has changed. + </description> + <arg name="appid" type="string" summary="The new appid."/> + </event> + + <event name="layout_symbol" since="1"> + <description summary="Update the current layout symbol"> + Indicates the layout has changed. Since layout symbols are dynamic. + As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying. + You can ignore the zdwl_ipc_output.layout event. + </description> + <arg name="layout" type="string" summary="The new layout"/> + </event> + + <event name="frame"> + <description summary="The update sequence is done."> + Indicates that a sequence of status updates have finished and the client should redraw. + </description> + </event> + + <request name="set_tags"> + <description summary="Set the active tags of this output"/> + <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/> + <arg name="toggle_tagset" type="uint" summary="toggle the selected tagset, zero for invalid, nonzero for valid."/> + </request> + + <request name="set_client_tags"> + <description summary="Set the tags of the focused client."> + The tags are updated as follows: + new_tags = (current_tags AND and_tags) XOR xor_tags + </description> + <arg name="and_tags" type="uint"/> + <arg name="xor_tags" type="uint"/> + </request> + + <request name="set_layout"> + <description summary="Set the layout of this output"/> + <arg name="index" type="uint" summary="index of a layout recieved by dwl_ipc_manager.layout"/> + </request> + + <request name="quit" since="2"> + <description summary="Quit mango">This request allows clients to instruct the compositor to quit mango.</description> + </request> + + <request name="dispatch" since="2"> + <description summary="Set the active tags of this output"/> + <arg name="dispatch" type="string" summary="dispatch name."/> + <arg name="arg1" type="string" summary="arg1."/> + <arg name="arg2" type="string" summary="arg2."/> + <arg name="arg3" type="string" summary="arg3."/> + <arg name="arg4" type="string" summary="arg4."/> + <arg name="arg5" type="string" summary="arg5."/> + </request> + + <!-- Version 2 --> + <event name="fullscreen" since="2"> + <description summary="Update fullscreen status"> + Indicates if the selected client on this output is fullscreen. + </description> + <arg name="is_fullscreen" type="uint" summary="If the selected client is fullscreen. Nonzero is valid, zero invalid"/> + </event> + + <event name="floating" since="2"> + <description summary="Update the floating status"> + Indicates if the selected client on this output is floating. + </description> + <arg name="is_floating" type="uint" summary="If the selected client is floating. Nonzero is valid, zero invalid"/> + </event> + + <event name="x" since="2"> + <description summary="Update the x coordinates"> + Indicates if x coordinates of the selected client. + </description> + <arg name="x" type="int" summary="x coordinate of the selected client"/> + </event> + + <event name="y" since="2"> + <description summary="Update the y coordinates"> + Indicates if y coordinates of the selected client. + </description> + <arg name="y" type="int" summary="y coordinate of the selected client"/> + </event> + + <event name="width" since="2"> + <description summary="Update the width"> + Indicates if width of the selected client. + </description> + <arg name="width" type="int" summary="width of the selected client"/> + </event> + + <event name="height" since="2"> + <description summary="Update the height"> + Indicates if height of the selected client. + </description> + <arg name="height" type="int" summary="height of the selected client"/> + </event> + + <event name="last_layer" since="2"> + <description summary="last map layer."> + last map layer. + </description> + <arg name="last_layer" type="string" summary="last map layer."/> + </event> + + <event name="kb_layout" since="2"> + <description summary="current keyboard layout."> + current keyboard layout. + </description> + <arg name="kb_layout" type="string" summary="current keyboard layout."/> + </event> + + <event name="keymode" since="2"> + <description summary="current keybind mode."> + current keybind mode. + </description> + <arg name="keymode" type="string" summary="current keybind mode."/> + </event> + + <event name="scalefactor" since="2"> + <description summary="scale factor of monitor."> + scale factor of monitor. + </description> + <arg name="scalefactor" type="uint" summary="scale factor of monitor."/> + </event> + + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/ext-data-control-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/ext-data-control-v1.xml new file mode 100644 index 0000000..37ee577 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/ext-data-control-v1.xml @@ -0,0 +1,276 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="ext_data_control_v1"> + <copyright> + Copyright © 2018 Simon Ser + Copyright © 2019 Ivan Molodetskikh + Copyright © 2024 Neal Gompa + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + </copyright> + + <description summary="control data devices"> + This protocol allows a privileged client to control data devices. In + particular, the client will be able to manage the current selection and take + the role of a clipboard manager. + + Warning! The protocol described in this file is currently in the testing + phase. Backward compatible changes may be added together with the + corresponding interface version bump. Backward incompatible changes can + only be done by creating a new major version of the extension. + </description> + + <interface name="ext_data_control_manager_v1" version="1"> + <description summary="manager to control data devices"> + This interface is a manager that allows creating per-seat data device + controls. + </description> + + <request name="create_data_source"> + <description summary="create a new data source"> + Create a new data source. + </description> + <arg name="id" type="new_id" interface="ext_data_control_source_v1" + summary="data source to create"/> + </request> + + <request name="get_data_device"> + <description summary="get a data device for a seat"> + Create a data device that can be used to manage a seat's selection. + </description> + <arg name="id" type="new_id" interface="ext_data_control_device_v1"/> + <arg name="seat" type="object" interface="wl_seat"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy the manager"> + All objects created by the manager will still remain valid, until their + appropriate destroy request has been called. + </description> + </request> + </interface> + + <interface name="ext_data_control_device_v1" version="1"> + <description summary="manage a data device for a seat"> + This interface allows a client to manage a seat's selection. + + When the seat is destroyed, this object becomes inert. + </description> + + <request name="set_selection"> + <description summary="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. + + The given source may not be used in any further set_selection or + set_primary_selection requests. Attempting to use a previously used + source triggers the used_source protocol error. + + To unset the selection, set the source to NULL. + </description> + <arg name="source" type="object" interface="ext_data_control_source_v1" + allow-null="true"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy this data device"> + Destroys the data device object. + </description> + </request> + + <event name="data_offer"> + <description summary="introduce a new ext_data_control_offer"> + The data_offer event introduces a new ext_data_control_offer object, + which will subsequently be used in either the + ext_data_control_device.selection event (for the regular clipboard + selections) or the ext_data_control_device.primary_selection event (for + the primary clipboard selections). Immediately following the + ext_data_control_device.data_offer event, the new data_offer object + will send out ext_data_control_offer.offer events to describe the MIME + types it offers. + </description> + <arg name="id" type="new_id" interface="ext_data_control_offer_v1"/> + </event> + + <event name="selection"> + <description summary="advertise new selection"> + The selection event is sent out to notify the client of a new + ext_data_control_offer for the selection for this device. The + ext_data_control_device.data_offer and the ext_data_control_offer.offer + events are sent out immediately before this event to introduce the data + offer object. The selection event is sent to a client when a new + selection is set. The ext_data_control_offer is valid until a new + ext_data_control_offer or NULL is received. The client must destroy the + previous selection ext_data_control_offer, if any, upon receiving this + event. Regardless, the previous selection will be ignored once a new + selection ext_data_control_offer is received. + + The first selection event is sent upon binding the + ext_data_control_device object. + </description> + <arg name="id" type="object" interface="ext_data_control_offer_v1" + allow-null="true"/> + </event> + + <event name="finished"> + <description summary="this data control is no longer valid"> + This data control object is no longer valid and should be destroyed by + the client. + </description> + </event> + + <event name="primary_selection"> + <description summary="advertise new primary selection"> + The primary_selection event is sent out to notify the client of a new + ext_data_control_offer for the primary selection for this device. The + ext_data_control_device.data_offer and the ext_data_control_offer.offer + events are sent out immediately before this event to introduce the data + offer object. The primary_selection event is sent to a client when a + new primary selection is set. The ext_data_control_offer is valid until + a new ext_data_control_offer or NULL is received. The client must + destroy the previous primary selection ext_data_control_offer, if any, + upon receiving this event. Regardless, the previous primary selection + will be ignored once a new primary selection ext_data_control_offer is + received. + + If the compositor supports primary selection, the first + primary_selection event is sent upon binding the + ext_data_control_device object. + </description> + <arg name="id" type="object" interface="ext_data_control_offer_v1" + allow-null="true"/> + </event> + + <request name="set_primary_selection"> + <description summary="copy data to the primary selection"> + This request asks the compositor to set the primary selection to the + data from the source on behalf of the client. + + The given source may not be used in any further set_selection or + set_primary_selection requests. Attempting to use a previously used + source triggers the used_source protocol error. + + To unset the primary selection, set the source to NULL. + + The compositor will ignore this request if it does not support primary + selection. + </description> + <arg name="source" type="object" interface="ext_data_control_source_v1" + allow-null="true"/> + </request> + + <enum name="error"> + <entry name="used_source" value="1" + summary="source given to set_selection or set_primary_selection was already used before"/> + </enum> + </interface> + + <interface name="ext_data_control_source_v1" version="1"> + <description summary="offer to transfer data"> + The ext_data_control_source object is the source side of a + ext_data_control_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. + </description> + + <enum name="error"> + <entry name="invalid_offer" value="1" + summary="offer sent after ext_data_control_device.set_selection"/> + </enum> + + <request name="offer"> + <description summary="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. + + Calling this after ext_data_control_device.set_selection is a protocol + error. + </description> + <arg name="mime_type" type="string" + summary="MIME type offered by the data source"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy this source"> + Destroys the data source object. + </description> + </request> + + <event name="send"> + <description summary="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. + </description> + <arg name="mime_type" type="string" summary="MIME type for the data"/> + <arg name="fd" type="fd" summary="file descriptor for the data"/> + </event> + + <event name="cancelled"> + <description summary="selection was cancelled"> + This data source is no longer valid. The data source has been replaced + by another data source. + + The client should clean up and destroy this data source. + </description> + </event> + </interface> + + <interface name="ext_data_control_offer_v1" version="1"> + <description summary="offer to transfer data"> + A ext_data_control_offer represents a piece of data offered for transfer + by another client (the source client). 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. + </description> + + <request name="receive"> + <description summary="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. + </description> + <arg name="mime_type" type="string" + summary="MIME type desired by receiver"/> + <arg name="fd" type="fd" summary="file descriptor for data transfer"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy this offer"> + Destroys the data offer object. + </description> + </request> + + <event name="offer"> + <description summary="advertise offered MIME type"> + Sent immediately after creating the ext_data_control_offer object. + One event per offered MIME type. + </description> + <arg name="mime_type" type="string" summary="offered MIME type"/> + </event> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/ext-workspace-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/ext-workspace-v1.xml new file mode 100644 index 0000000..134b729 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/ext-workspace-v1.xml @@ -0,0 +1,422 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="ext_workspace_v1"> + <copyright> + Copyright © 2019 Christopher Billington + Copyright © 2020 Ilia Bozhinov + Copyright © 2022 Victoria Brekenfeld + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + </copyright> + + <interface name="ext_workspace_manager_v1" version="1"> + <description summary="list and control workspaces"> + Workspaces, also called virtual desktops, are groups of surfaces. A + compositor with a concept of workspaces may only show some such groups of + surfaces (those of 'active' workspaces) at a time. 'Activating' a + workspace is a request for the compositor to display that workspace's + surfaces as normal, whereas the compositor may hide or otherwise + de-emphasise surfaces that are associated only with 'inactive' workspaces. + Workspaces are grouped by which sets of outputs they correspond to, and + may contain surfaces only from those outputs. In this way, it is possible + for each output to have its own set of workspaces, or for all outputs (or + any other arbitrary grouping) to share workspaces. Compositors may + optionally conceptually arrange each group of workspaces in an + N-dimensional grid. + + The purpose of this protocol is to enable the creation of taskbars and + docks by providing them with a list of workspaces and their properties, + and allowing them to activate and deactivate workspaces. + + After a client binds the ext_workspace_manager_v1, each workspace will be + sent via the workspace event. + </description> + + <event name="workspace_group"> + <description summary="a workspace group has been created"> + This event is emitted whenever a new workspace group has been created. + + All initial details of the workspace group (outputs) will be + sent immediately after this event via the corresponding events in + ext_workspace_group_handle_v1 and ext_workspace_handle_v1. + </description> + <arg name="workspace_group" type="new_id" interface="ext_workspace_group_handle_v1"/> + </event> + + <event name="workspace"> + <description summary="workspace has been created"> + This event is emitted whenever a new workspace has been created. + + All initial details of the workspace (name, coordinates, state) will + be sent immediately after this event via the corresponding events in + ext_workspace_handle_v1. + + Workspaces start off unassigned to any workspace group. + </description> + <arg name="workspace" type="new_id" interface="ext_workspace_handle_v1"/> + </event> + + <request name="commit"> + <description summary="all requests about the workspaces have been sent"> + The client must send this request after it has finished sending other + requests. The compositor must process a series of requests preceding a + commit request atomically. + + This allows changes to the workspace properties to be seen as atomic, + even if they happen via multiple events, and even if they involve + multiple ext_workspace_handle_v1 objects, for example, deactivating one + workspace and activating another. + </description> + </request> + + <event name="done"> + <description summary="all information about the workspaces and workspace groups has been sent"> + This event is sent after all changes in all workspaces and workspace groups have been + sent. + + This allows changes to one or more ext_workspace_group_handle_v1 + properties and ext_workspace_handle_v1 properties + to be seen as atomic, even if they happen via multiple events. + In particular, an output moving from one workspace group to + another sends an output_enter event and an output_leave event to the two + ext_workspace_group_handle_v1 objects in question. The compositor sends + the done event only after updating the output information in both + workspace groups. + </description> + </event> + + <event name="finished" type="destructor"> + <description summary="the compositor has finished with the workspace_manager"> + This event indicates that the compositor is done sending events to the + ext_workspace_manager_v1. The server will destroy the object + immediately after sending this request. + </description> + </event> + + <request name="stop"> + <description summary="stop sending events"> + Indicates the client no longer wishes to receive events for new + workspace groups. However the compositor may emit further workspace + events, until the finished event is emitted. The compositor is expected + to send the finished event eventually once the stop request has been processed. + + The client must not send any requests after this one, doing so will raise a wl_display + invalid_object error. + </description> + </request> + + </interface> + + <interface name="ext_workspace_group_handle_v1" version="1"> + <description summary="a workspace group assigned to a set of outputs"> + A ext_workspace_group_handle_v1 object represents a workspace group + that is assigned a set of outputs and contains a number of workspaces. + + The set of outputs assigned to the workspace group is conveyed to the client via + output_enter and output_leave events, and its workspaces are conveyed with + workspace events. + + For example, a compositor which has a set of workspaces for each output may + advertise a workspace group (and its workspaces) per output, whereas a compositor + where a workspace spans all outputs may advertise a single workspace group for all + outputs. + </description> + + <enum name="group_capabilities" bitfield="true"> + <entry name="create_workspace" value="1" summary="create_workspace request is available"/> + </enum> + + <event name="capabilities"> + <description summary="compositor capabilities"> + This event advertises the capabilities supported by the compositor. If + a capability isn't supported, clients should hide or disable the UI + elements that expose this functionality. For instance, if the + compositor doesn't advertise support for creating workspaces, a button + triggering the create_workspace request should not be displayed. + + The compositor will ignore requests it doesn't support. For instance, + a compositor which doesn't advertise support for creating workspaces will ignore + create_workspace requests. + + Compositors must send this event once after creation of an + ext_workspace_group_handle_v1. When the capabilities change, compositors + must send this event again. + </description> + <arg name="capabilities" type="uint" summary="capabilities" enum="group_capabilities"/> + </event> + + <event name="output_enter"> + <description summary="output assigned to workspace group"> + This event is emitted whenever an output is assigned to the workspace + group or a new `wl_output` object is bound by the client, which was already + assigned to this workspace_group. + </description> + <arg name="output" type="object" interface="wl_output"/> + </event> + + <event name="output_leave"> + <description summary="output removed from workspace group"> + This event is emitted whenever an output is removed from the workspace + group. + </description> + <arg name="output" type="object" interface="wl_output"/> + </event> + + <event name="workspace_enter"> + <description summary="workspace added to workspace group"> + This event is emitted whenever a workspace is assigned to this group. + A workspace may only ever be assigned to a single group at a single point + in time, but can be re-assigned during it's lifetime. + </description> + <arg name="workspace" type="object" interface="ext_workspace_handle_v1"/> + </event> + + <event name="workspace_leave"> + <description summary="workspace removed from workspace group"> + This event is emitted whenever a workspace is removed from this group. + </description> + <arg name="workspace" type="object" interface="ext_workspace_handle_v1"/> + </event> + + <event name="removed"> + <description summary="this workspace group has been removed"> + This event is send when the group associated with the ext_workspace_group_handle_v1 + has been removed. After sending this request the compositor will immediately consider + the object inert. Any requests will be ignored except the destroy request. + It is guaranteed there won't be any more events referencing this + ext_workspace_group_handle_v1. + + The compositor must remove all workspaces belonging to a workspace group + via a workspace_leave event before removing the workspace group. + </description> + </event> + + <request name="create_workspace"> + <description summary="create a new workspace"> + Request that the compositor create a new workspace with the given name + and assign it to this group. + + There is no guarantee that the compositor will create a new workspace, + or that the created workspace will have the provided name. + </description> + <arg name="workspace" type="string"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy the ext_workspace_group_handle_v1 object"> + Destroys the ext_workspace_group_handle_v1 object. + + This request should be send either when the client does not want to + use the workspace group object any more or after the removed event to finalize + the destruction of the object. + </description> + </request> + </interface> + + <interface name="ext_workspace_handle_v1" version="1"> + <description summary="a workspace handing a group of surfaces"> + A ext_workspace_handle_v1 object represents a workspace that handles a + group of surfaces. + + Each workspace has: + - a name, conveyed to the client with the name event + - potentially an id conveyed with the id event + - a list of states, conveyed to the client with the state event + - and optionally a set of coordinates, conveyed to the client with the + coordinates event + + The client may request that the compositor activate or deactivate the workspace. + + Each workspace can belong to only a single workspace group. + Depending on the compositor policy, there might be workspaces with + the same name in different workspace groups, but these workspaces are still + separate (e.g. one of them might be active while the other is not). + </description> + + <event name="id"> + <description summary="workspace id"> + If this event is emitted, it will be send immediately after the + ext_workspace_handle_v1 is created or when an id is assigned to + a workspace (at most once during it's lifetime). + + An id will never change during the lifetime of the `ext_workspace_handle_v1` + and is guaranteed to be unique during it's lifetime. + + Ids are not human-readable and shouldn't be displayed, use `name` for that purpose. + + Compositors are expected to only send ids for workspaces likely stable across multiple + sessions and can be used by clients to store preferences for workspaces. Workspaces without + ids should be considered temporary and any data associated with them should be deleted once + the respective object is lost. + </description> + <arg name="id" type="string"/> + </event> + + <event name="name"> + <description summary="workspace name changed"> + This event is emitted immediately after the ext_workspace_handle_v1 is + created and whenever the name of the workspace changes. + + A name is meant to be human-readable and can be displayed to a user. + Unlike the id it is neither stable nor unique. + </description> + <arg name="name" type="string"/> + </event> + + <event name="coordinates"> + <description summary="workspace coordinates changed"> + This event is used to organize workspaces into an N-dimensional grid + within a workspace group, and if supported, is emitted immediately after + the ext_workspace_handle_v1 is created and whenever the coordinates of + the workspace change. Compositors may not send this event if they do not + conceptually arrange workspaces in this way. If compositors simply + number workspaces, without any geometric interpretation, they may send + 1D coordinates, which clients should not interpret as implying any + geometry. Sending an empty array means that the compositor no longer + orders the workspace geometrically. + + Coordinates have an arbitrary number of dimensions N with an uint32 + position along each dimension. By convention if N > 1, the first + dimension is X, the second Y, the third Z, and so on. The compositor may + chose to utilize these events for a more novel workspace layout + convention, however. No guarantee is made about the grid being filled or + bounded; there may be a workspace at coordinate 1 and another at + coordinate 1000 and none in between. Within a workspace group, however, + workspaces must have unique coordinates of equal dimensionality. + </description> + <arg name="coordinates" type="array"/> + </event> + + <enum name="state" bitfield="true"> + <description summary="types of states on the workspace"> + The different states that a workspace can have. + </description> + + <entry name="active" value="1" summary="the workspace is active"/> + <entry name="urgent" value="2" summary="the workspace requests attention"/> + <entry name="hidden" value="4"> + <description summary="the workspace is not visible"> + The workspace is not visible in its workspace group, and clients + attempting to visualize the compositor workspace state should not + display such workspaces. + </description> + </entry> + </enum> + + <event name="state"> + <description summary="the state of the workspace changed"> + This event is emitted immediately after the ext_workspace_handle_v1 is + created and each time the workspace state changes, either because of a + compositor action or because of a request in this protocol. + + Missing states convey the opposite meaning, e.g. an unset active bit + means the workspace is currently inactive. + </description> + <arg name="state" type="uint" enum="state"/> + </event> + + <enum name="workspace_capabilities" bitfield="true"> + <entry name="activate" value="1" summary="activate request is available"/> + <entry name="deactivate" value="2" summary="deactivate request is available"/> + <entry name="remove" value="4" summary="remove request is available"/> + <entry name="assign" value="8" summary="assign request is available"/> + </enum> + + <event name="capabilities"> + <description summary="compositor capabilities"> + This event advertises the capabilities supported by the compositor. If + a capability isn't supported, clients should hide or disable the UI + elements that expose this functionality. For instance, if the + compositor doesn't advertise support for removing workspaces, a button + triggering the remove request should not be displayed. + + The compositor will ignore requests it doesn't support. For instance, + a compositor which doesn't advertise support for remove will ignore + remove requests. + + Compositors must send this event once after creation of an + ext_workspace_handle_v1 . When the capabilities change, compositors + must send this event again. + </description> + <arg name="capabilities" type="uint" summary="capabilities" enum="workspace_capabilities"/> + </event> + + <event name="removed"> + <description summary="this workspace has been removed"> + This event is send when the workspace associated with the ext_workspace_handle_v1 + has been removed. After sending this request, the compositor will immediately consider + the object inert. Any requests will be ignored except the destroy request. + + It is guaranteed there won't be any more events referencing this + ext_workspace_handle_v1. + + The compositor must only remove a workspaces not currently belonging to any + workspace_group. + </description> + </event> + + <request name="destroy" type="destructor"> + <description summary="destroy the ext_workspace_handle_v1 object"> + Destroys the ext_workspace_handle_v1 object. + + This request should be made either when the client does not want to + use the workspace object any more or after the remove event to finalize + the destruction of the object. + </description> + </request> + + <request name="activate"> + <description summary="activate the workspace"> + Request that this workspace be activated. + + There is no guarantee the workspace will be actually activated, and + behaviour may be compositor-dependent. For example, activating a + workspace may or may not deactivate all other workspaces in the same + group. + </description> + </request> + + <request name="deactivate"> + <description summary="deactivate the workspace"> + Request that this workspace be deactivated. + + There is no guarantee the workspace will be actually deactivated. + </description> + </request> + + <request name="assign"> + <description summary="assign workspace to group"> + Requests that this workspace is assigned to the given workspace group. + + There is no guarantee the workspace will be assigned. + </description> + <arg name="workspace_group" type="object" interface="ext_workspace_group_handle_v1"/> + </request> + + <request name="remove"> + <description summary="remove the workspace"> + Request that this workspace be removed. + + There is no guarantee the workspace will be actually removed. + </description> + </request> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/keyboard-shortcuts-inhibit-unstable-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/keyboard-shortcuts-inhibit-unstable-v1.xml new file mode 100644 index 0000000..2774876 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/keyboard-shortcuts-inhibit-unstable-v1.xml @@ -0,0 +1,143 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="keyboard_shortcuts_inhibit_unstable_v1"> + + <copyright> + Copyright © 2017 Red Hat Inc. + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + </copyright> + + <description summary="Protocol for inhibiting the compositor keyboard shortcuts"> + This protocol specifies a way for a client to request the compositor + to ignore its own keyboard shortcuts for a given seat, so that all + key events from that seat get forwarded to a surface. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible + changes may be added together with the corresponding interface + version bump. + Backward incompatible changes are done by bumping the version + number in the protocol and interface names and resetting the + interface version. Once the protocol is to be declared stable, + the 'z' prefix and the version number in the protocol and + interface names are removed and the interface version number is + reset. + </description> + + <interface name="zwp_keyboard_shortcuts_inhibit_manager_v1" version="1"> + <description summary="context object for keyboard grab_manager"> + A global interface used for inhibiting the compositor keyboard shortcuts. + </description> + + <request name="destroy" type="destructor"> + <description summary="destroy the keyboard shortcuts inhibitor object"> + Destroy the keyboard shortcuts inhibitor manager. + </description> + </request> + + <request name="inhibit_shortcuts"> + <description summary="create a new keyboard shortcuts inhibitor object"> + Create a new keyboard shortcuts inhibitor object associated with + the given surface for the given seat. + + If shortcuts are already inhibited for the specified seat and surface, + a protocol error "already_inhibited" is raised by the compositor. + </description> + <arg name="id" type="new_id" interface="zwp_keyboard_shortcuts_inhibitor_v1"/> + <arg name="surface" type="object" interface="wl_surface" + summary="the surface that inhibits the keyboard shortcuts behavior"/> + <arg name="seat" type="object" interface="wl_seat" + summary="the wl_seat for which keyboard shortcuts should be disabled"/> + </request> + + <enum name="error"> + <entry name="already_inhibited" + value="0" + summary="the shortcuts are already inhibited for this surface"/> + </enum> + </interface> + + <interface name="zwp_keyboard_shortcuts_inhibitor_v1" version="1"> + <description summary="context object for keyboard shortcuts inhibitor"> + A keyboard shortcuts inhibitor instructs the compositor to ignore + its own keyboard shortcuts when the associated surface has keyboard + focus. As a result, when the surface has keyboard focus on the given + seat, it will receive all key events originating from the specified + seat, even those which would normally be caught by the compositor for + its own shortcuts. + + The Wayland compositor is however under no obligation to disable + all of its shortcuts, and may keep some special key combo for its own + use, including but not limited to one allowing the user to forcibly + restore normal keyboard events routing in the case of an unwilling + client. The compositor may also use the same key combo to reactivate + an existing shortcut inhibitor that was previously deactivated on + user request. + + When the compositor restores its own keyboard shortcuts, an + "inactive" event is emitted to notify the client that the keyboard + shortcuts inhibitor is not effectively active for the surface and + seat any more, and the client should not expect to receive all + keyboard events. + + When the keyboard shortcuts inhibitor is inactive, the client has + no way to forcibly reactivate the keyboard shortcuts inhibitor. + + The user can chose to re-enable a previously deactivated keyboard + shortcuts inhibitor using any mechanism the compositor may offer, + in which case the compositor will send an "active" event to notify + the client. + + If the surface is destroyed, unmapped, or loses the seat's keyboard + focus, the keyboard shortcuts inhibitor becomes irrelevant and the + compositor will restore its own keyboard shortcuts but no "inactive" + event is emitted in this case. + </description> + + <request name="destroy" type="destructor"> + <description summary="destroy the keyboard shortcuts inhibitor object"> + Remove the keyboard shortcuts inhibitor from the associated wl_surface. + </description> + </request> + + <event name="active"> + <description summary="shortcuts are inhibited"> + This event indicates that the shortcut inhibitor is active. + + The compositor sends this event every time compositor shortcuts + are inhibited on behalf of the surface. When active, the client + may receive input events normally reserved by the compositor + (see zwp_keyboard_shortcuts_inhibitor_v1). + + This occurs typically when the initial request "inhibit_shortcuts" + first becomes active or when the user instructs the compositor to + re-enable and existing shortcuts inhibitor using any mechanism + offered by the compositor. + </description> + </event> + + <event name="inactive"> + <description summary="shortcuts are restored"> + This event indicates that the shortcuts inhibitor is inactive, + normal shortcuts processing is restored by the compositor. + </description> + </event> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-gamma-control-unstable-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-gamma-control-unstable-v1.xml new file mode 100644 index 0000000..16e0be8 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-gamma-control-unstable-v1.xml @@ -0,0 +1,126 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="wlr_gamma_control_unstable_v1"> + <copyright> + Copyright © 2015 Giulio camuffo + Copyright © 2018 Simon Ser + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + </copyright> + + <description summary="manage gamma tables of outputs"> + This protocol allows a privileged client to set the gamma tables for + outputs. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible changes + may be added together with the corresponding interface version bump. + Backward incompatible changes are done by bumping the version number in + the protocol and interface names and resetting the interface version. + Once the protocol is to be declared stable, the 'z' prefix and the + version number in the protocol and interface names are removed and the + interface version number is reset. + </description> + + <interface name="zwlr_gamma_control_manager_v1" version="1"> + <description summary="manager to create per-output gamma controls"> + This interface is a manager that allows creating per-output gamma + controls. + </description> + + <request name="get_gamma_control"> + <description summary="get a gamma control for an output"> + Create a gamma control that can be used to adjust gamma tables for the + provided output. + </description> + <arg name="id" type="new_id" interface="zwlr_gamma_control_v1"/> + <arg name="output" type="object" interface="wl_output"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy the manager"> + All objects created by the manager will still remain valid, until their + appropriate destroy request has been called. + </description> + </request> + </interface> + + <interface name="zwlr_gamma_control_v1" version="1"> + <description summary="adjust gamma tables for an output"> + This interface allows a client to adjust gamma tables for a particular + output. + + The client will receive the gamma size, and will then be able to set gamma + tables. At any time the compositor can send a failed event indicating that + this object is no longer valid. + + There can only be at most one gamma control object per output, which + has exclusive access to this particular output. When the gamma control + object is destroyed, the gamma table is restored to its original value. + </description> + + <event name="gamma_size"> + <description summary="size of gamma ramps"> + Advertise the size of each gamma ramp. + + This event is sent immediately when the gamma control object is created. + </description> + <arg name="size" type="uint" summary="number of elements in a ramp"/> + </event> + + <enum name="error"> + <entry name="invalid_gamma" value="1" summary="invalid gamma tables"/> + </enum> + + <request name="set_gamma"> + <description summary="set the gamma table"> + Set the gamma table. The file descriptor can be memory-mapped to provide + the raw gamma table, which contains successive gamma ramps for the red, + green and blue channels. Each gamma ramp is an array of 16-byte unsigned + integers which has the same length as the gamma size. + + The file descriptor data must have the same length as three times the + gamma size. + </description> + <arg name="fd" type="fd" summary="gamma table file descriptor"/> + </request> + + <event name="failed"> + <description summary="object no longer valid"> + This event indicates that the gamma control is no longer valid. This + can happen for a number of reasons, including: + - The output doesn't support gamma tables + - Setting the gamma tables failed + - Another client already has exclusive gamma control for this output + - The compositor has transferred gamma control to another client + + Upon receiving this event, the client should destroy this object. + </description> + </event> + + <request name="destroy" type="destructor"> + <description summary="destroy this control"> + Destroys the gamma control object. If the object is still valid, this + restores the original gamma tables. + </description> + </request> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-layer-shell-unstable-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-layer-shell-unstable-v1.xml new file mode 100644 index 0000000..e9f27e4 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-layer-shell-unstable-v1.xml @@ -0,0 +1,407 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="wlr_layer_shell_unstable_v1"> + <copyright> + Copyright © 2017 Drew DeVault + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + </copyright> + + <interface name="zwlr_layer_shell_v1" version="5"> + <description summary="create surfaces that are layers of the desktop"> + Clients can use this interface to assign the surface_layer role to + wl_surfaces. Such surfaces are assigned to a "layer" of the output and + rendered with a defined z-depth respective to each other. They may also be + anchored to the edges and corners of a screen and specify input handling + semantics. This interface should be suitable for the implementation of + many desktop shell components, and a broad number of other applications + that interact with the desktop. + </description> + + <request name="get_layer_surface"> + <description summary="create a layer_surface from a surface"> + Create a layer surface for an existing surface. This assigns the role of + layer_surface, or raises a protocol error if another role is already + assigned. + + Creating a layer surface from a wl_surface which has a buffer attached + or committed is a client error, and any attempts by a client to attach + or manipulate a buffer prior to the first layer_surface.configure call + must also be treated as errors. + + After creating a layer_surface object and setting it up, the client + must perform an initial commit without any buffer attached. + The compositor will reply with a layer_surface.configure event. + The client must acknowledge it and is then allowed to attach a buffer + to map the surface. + + You may pass NULL for output to allow the compositor to decide which + output to use. Generally this will be the one that the user most + recently interacted with. + + Clients can specify a namespace that defines the purpose of the layer + surface. + </description> + <arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/> + <arg name="surface" type="object" interface="wl_surface"/> + <arg name="output" type="object" interface="wl_output" allow-null="true"/> + <arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/> + <arg name="namespace" type="string" summary="namespace for the layer surface"/> + </request> + + <enum name="error"> + <entry name="role" value="0" summary="wl_surface has another role"/> + <entry name="invalid_layer" value="1" summary="layer value is invalid"/> + <entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/> + </enum> + + <enum name="layer"> + <description summary="available layers for surfaces"> + These values indicate which layers a surface can be rendered in. They + are ordered by z depth, bottom-most first. Traditional shell surfaces + will typically be rendered between the bottom and top layers. + Fullscreen shell surfaces are typically rendered at the top layer. + Multiple surfaces can share a single layer, and ordering within a + single layer is undefined. + </description> + + <entry name="background" value="0"/> + <entry name="bottom" value="1"/> + <entry name="top" value="2"/> + <entry name="overlay" value="3"/> + </enum> + + <!-- Version 3 additions --> + + <request name="destroy" type="destructor" since="3"> + <description summary="destroy the layer_shell object"> + This request indicates that the client will not use the layer_shell + object any more. Objects that have been created through this instance + are not affected. + </description> + </request> + </interface> + + <interface name="zwlr_layer_surface_v1" version="5"> + <description summary="layer metadata interface"> + An interface that may be implemented by a wl_surface, for surfaces that + are designed to be rendered as a layer of a stacked desktop-like + environment. + + Layer surface state (layer, size, anchor, exclusive zone, + margin, interactivity) is double-buffered, and will be applied at the + time wl_surface.commit of the corresponding wl_surface is called. + + Attaching a null buffer to a layer surface unmaps it. + + Unmapping a layer_surface means that the surface cannot be shown by the + compositor until it is explicitly mapped again. The layer_surface + returns to the state it had right after layer_shell.get_layer_surface. + The client can re-map the surface by performing a commit without any + buffer attached, waiting for a configure event and handling it as usual. + </description> + + <request name="set_size"> + <description summary="sets the size of the surface"> + Sets the size of the surface in surface-local coordinates. The + compositor will display the surface centered with respect to its + anchors. + + If you pass 0 for either value, the compositor will assign it and + inform you of the assignment in the configure event. You must set your + anchor to opposite edges in the dimensions you omit; not doing so is a + protocol error. Both values are 0 by default. + + Size is double-buffered, see wl_surface.commit. + </description> + <arg name="width" type="uint"/> + <arg name="height" type="uint"/> + </request> + + <request name="set_anchor"> + <description summary="configures the anchor point of the surface"> + Requests that the compositor anchor the surface to the specified edges + and corners. If two orthogonal edges are specified (e.g. 'top' and + 'left'), then the anchor point will be the intersection of the edges + (e.g. the top left corner of the output); otherwise the anchor point + will be centered on that edge, or in the center if none is specified. + + Anchor is double-buffered, see wl_surface.commit. + </description> + <arg name="anchor" type="uint" enum="anchor"/> + </request> + + <request name="set_exclusive_zone"> + <description summary="configures the exclusive geometry of this surface"> + Requests that the compositor avoids occluding an area with other + surfaces. The compositor's use of this information is + implementation-dependent - do not assume that this region will not + actually be occluded. + + A positive value is only meaningful if the surface is anchored to one + edge or an edge and both perpendicular edges. If the surface is not + anchored, anchored to only two perpendicular edges (a corner), anchored + to only two parallel edges or anchored to all edges, a positive value + will be treated the same as zero. + + A positive zone is the distance from the edge in surface-local + coordinates to consider exclusive. + + Surfaces that do not wish to have an exclusive zone may instead specify + how they should interact with surfaces that do. If set to zero, the + surface indicates that it would like to be moved to avoid occluding + surfaces with a positive exclusive zone. If set to -1, the surface + indicates that it would not like to be moved to accommodate for other + surfaces, and the compositor should extend it all the way to the edges + it is anchored to. + + For example, a panel might set its exclusive zone to 10, so that + maximized shell surfaces are not shown on top of it. A notification + might set its exclusive zone to 0, so that it is moved to avoid + occluding the panel, but shell surfaces are shown underneath it. A + wallpaper or lock screen might set their exclusive zone to -1, so that + they stretch below or over the panel. + + The default value is 0. + + Exclusive zone is double-buffered, see wl_surface.commit. + </description> + <arg name="zone" type="int"/> + </request> + + <request name="set_margin"> + <description summary="sets a margin from the anchor point"> + Requests that the surface be placed some distance away from the anchor + point on the output, in surface-local coordinates. Setting this value + for edges you are not anchored to has no effect. + + The exclusive zone includes the margin. + + Margin is double-buffered, see wl_surface.commit. + </description> + <arg name="top" type="int"/> + <arg name="right" type="int"/> + <arg name="bottom" type="int"/> + <arg name="left" type="int"/> + </request> + + <enum name="keyboard_interactivity"> + <description summary="types of keyboard interaction possible for a layer shell surface"> + Types of keyboard interaction possible for layer shell surfaces. The + rationale for this is twofold: (1) some applications are not interested + in keyboard events and not allowing them to be focused can improve the + desktop experience; (2) some applications will want to take exclusive + keyboard focus. + </description> + + <entry name="none" value="0"> + <description summary="no keyboard focus is possible"> + This value indicates that this surface is not interested in keyboard + events and the compositor should never assign it the keyboard focus. + + This is the default value, set for newly created layer shell surfaces. + + This is useful for e.g. desktop widgets that display information or + only have interaction with non-keyboard input devices. + </description> + </entry> + <entry name="exclusive" value="1"> + <description summary="request exclusive keyboard focus"> + Request exclusive keyboard focus if this surface is above the shell surface layer. + + For the top and overlay layers, the seat will always give + exclusive keyboard focus to the top-most layer which has keyboard + interactivity set to exclusive. If this layer contains multiple + surfaces with keyboard interactivity set to exclusive, the compositor + determines the one receiving keyboard events in an implementation- + defined manner. In this case, no guarantee is made when this surface + will receive keyboard focus (if ever). + + For the bottom and background layers, the compositor is allowed to use + normal focus semantics. + + This setting is mainly intended for applications that need to ensure + they receive all keyboard events, such as a lock screen or a password + prompt. + </description> + </entry> + <entry name="on_demand" value="2" since="4"> + <description summary="request regular keyboard focus semantics"> + This requests the compositor to allow this surface to be focused and + unfocused by the user in an implementation-defined manner. The user + should be able to unfocus this surface even regardless of the layer + it is on. + + Typically, the compositor will want to use its normal mechanism to + manage keyboard focus between layer shell surfaces with this setting + and regular toplevels on the desktop layer (e.g. click to focus). + Nevertheless, it is possible for a compositor to require a special + interaction to focus or unfocus layer shell surfaces (e.g. requiring + a click even if focus follows the mouse normally, or providing a + keybinding to switch focus between layers). + + This setting is mainly intended for desktop shell components (e.g. + panels) that allow keyboard interaction. Using this option can allow + implementing a desktop shell that can be fully usable without the + mouse. + </description> + </entry> + </enum> + + <request name="set_keyboard_interactivity"> + <description summary="requests keyboard events"> + Set how keyboard events are delivered to this surface. By default, + layer shell surfaces do not receive keyboard events; this request can + be used to change this. + + This setting is inherited by child surfaces set by the get_popup + request. + + Layer surfaces receive pointer, touch, and tablet events normally. If + you do not want to receive them, set the input region on your surface + to an empty region. + + Keyboard interactivity is double-buffered, see wl_surface.commit. + </description> + <arg name="keyboard_interactivity" type="uint" enum="keyboard_interactivity"/> + </request> + + <request name="get_popup"> + <description summary="assign this layer_surface as an xdg_popup parent"> + This assigns an xdg_popup's parent to this layer_surface. This popup + should have been created via xdg_surface::get_popup with the parent set + to NULL, and this request must be invoked before committing the popup's + initial state. + + See the documentation of xdg_popup for more details about what an + xdg_popup is and how it is used. + </description> + <arg name="popup" type="object" interface="xdg_popup"/> + </request> + + <request name="ack_configure"> + <description summary="ack a configure event"> + When a configure event is received, if a client commits the + surface in response to the configure event, then the client + must make an ack_configure request sometime before the commit + request, passing along the serial of the configure event. + + If the client receives multiple configure events before it + can respond to one, it only has to ack the last configure event. + + A client is not required to commit immediately after sending + an ack_configure request - it may even ack_configure several times + before its next surface commit. + + A client may send multiple ack_configure requests before committing, but + only the last request sent before a commit indicates which configure + event the client really is responding to. + </description> + <arg name="serial" type="uint" summary="the serial from the configure event"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy the layer_surface"> + This request destroys the layer surface. + </description> + </request> + + <event name="configure"> + <description summary="suggest a surface change"> + The configure event asks the client to resize its surface. + + Clients should arrange their surface for the new states, and then send + an ack_configure request with the serial sent in this configure event at + some point before committing the new surface. + + 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. + + 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). If the client picks a smaller size and + is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the + surface will be centered on this axis. + + If the width or height arguments are zero, it means the client should + decide its own window dimension. + </description> + <arg name="serial" type="uint"/> + <arg name="width" type="uint"/> + <arg name="height" type="uint"/> + </event> + + <event name="closed"> + <description summary="surface should be closed"> + The closed event is sent by the compositor when the surface will no + longer be shown. The output may have been destroyed or the user may + have asked for it to be removed. Further changes to the surface will be + ignored. The client should destroy the resource after receiving this + event, and create a new surface if they so choose. + </description> + </event> + + <enum name="error"> + <entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/> + <entry name="invalid_size" value="1" summary="size is invalid"/> + <entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/> + <entry name="invalid_keyboard_interactivity" value="3" summary="keyboard interactivity is invalid"/> + <entry name="invalid_exclusive_edge" value="4" summary="exclusive edge is invalid given the surface anchors"/> + </enum> + + <enum name="anchor" bitfield="true"> + <entry name="top" value="1" summary="the top edge of the anchor rectangle"/> + <entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/> + <entry name="left" value="4" summary="the left edge of the anchor rectangle"/> + <entry name="right" value="8" summary="the right edge of the anchor rectangle"/> + </enum> + + <!-- Version 2 additions --> + + <request name="set_layer" since="2"> + <description summary="change the layer of the surface"> + Change the layer that the surface is rendered on. + + Layer is double-buffered, see wl_surface.commit. + </description> + <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/> + </request> + + <!-- Version 5 additions --> + + <request name="set_exclusive_edge" since="5"> + <description summary="set the edge the exclusive zone will be applied to"> + Requests an edge for the exclusive zone to apply. The exclusive + edge will be automatically deduced from anchor points when possible, + but when the surface is anchored to a corner, it will be necessary + to set it explicitly to disambiguate, as it is not possible to deduce + which one of the two corner edges should be used. + + The edge must be one the surface is anchored to, otherwise the + invalid_exclusive_edge protocol error will be raised. + </description> + <arg name="edge" type="uint" enum="anchor"/> + </request> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-output-management-unstable-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-output-management-unstable-v1.xml new file mode 100644 index 0000000..541284a --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-output-management-unstable-v1.xml @@ -0,0 +1,611 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="wlr_output_management_unstable_v1"> + <copyright> + Copyright © 2019 Purism SPC + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + </copyright> + + <description summary="protocol to configure output devices"> + This protocol exposes interfaces to obtain and modify output device + configuration. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible changes + may be added together with the corresponding interface version bump. + Backward incompatible changes are done by bumping the version number in + the protocol and interface names and resetting the interface version. + Once the protocol is to be declared stable, the 'z' prefix and the + version number in the protocol and interface names are removed and the + interface version number is reset. + </description> + + <interface name="zwlr_output_manager_v1" version="4"> + <description summary="output device configuration manager"> + This interface is a manager that allows reading and writing the current + output device configuration. + + Output devices that display pixels (e.g. a physical monitor or a virtual + output in a window) are represented as heads. Heads cannot be created nor + destroyed by the client, but they can be enabled or disabled and their + properties can be changed. Each head may have one or more available modes. + + Whenever a head appears (e.g. a monitor is plugged in), it will be + advertised via the head event. Immediately after the output manager is + bound, all current heads are advertised. + + Whenever a head's properties change, the relevant wlr_output_head events + will be sent. Not all head properties will be sent: only properties that + have changed need to. + + Whenever a head disappears (e.g. a monitor is unplugged), a + wlr_output_head.finished event will be sent. + + After one or more heads appear, change or disappear, the done event will + be sent. It carries a serial which can be used in a create_configuration + request to update heads properties. + + The information obtained from this protocol should only be used for output + configuration purposes. This protocol is not designed to be a generic + output property advertisement protocol for regular clients. Instead, + protocols such as xdg-output should be used. + </description> + + <event name="head"> + <description summary="introduce a new head"> + This event introduces a new head. This happens whenever a new head + appears (e.g. a monitor is plugged in) or after the output manager is + bound. + </description> + <arg name="head" type="new_id" interface="zwlr_output_head_v1"/> + </event> + + <event name="done"> + <description summary="sent all information about current configuration"> + This event is sent after all information has been sent after binding to + the output manager object and after any subsequent changes. This applies + to child head and mode objects as well. In other words, this event is + sent whenever a head or mode is created or destroyed and whenever one of + their properties has been changed. Not all state is re-sent each time + the current configuration changes: only the actual changes are sent. + + This allows changes to the output configuration to be seen as atomic, + even if they happen via multiple events. + + A serial is sent to be used in a future create_configuration request. + </description> + <arg name="serial" type="uint" summary="current configuration serial"/> + </event> + + <request name="create_configuration"> + <description summary="create a new output configuration object"> + Create a new output configuration object. This allows to update head + properties. + </description> + <arg name="id" type="new_id" interface="zwlr_output_configuration_v1"/> + <arg name="serial" type="uint"/> + </request> + + <request name="stop"> + <description summary="stop sending events"> + Indicates the client no longer wishes to receive events for output + configuration changes. However the compositor may emit further events, + until the finished event is emitted. + + The client must not send any more requests after this one. + </description> + </request> + + <event name="finished" type="destructor"> + <description summary="the compositor has finished with the manager"> + This event indicates that the compositor is done sending manager events. + The compositor will destroy the object immediately after sending this + event, so it will become invalid and the client should release any + resources associated with it. + </description> + </event> + </interface> + + <interface name="zwlr_output_head_v1" version="4"> + <description summary="output device"> + A head is an output device. The difference between a wl_output object and + a head is that heads are advertised even if they are turned off. A head + object only advertises properties and cannot be used directly to change + them. + + A head has some read-only properties: modes, name, description and + physical_size. These cannot be changed by clients. + + Other properties can be updated via a wlr_output_configuration object. + + Properties sent via this interface are applied atomically via the + wlr_output_manager.done event. No guarantees are made regarding the order + in which properties are sent. + </description> + + <event name="name"> + <description summary="head name"> + This event describes the head name. + + The naming convention is compositor defined, but limited to alphanumeric + characters and dashes (-). Each name is unique among all wlr_output_head + objects, but if a wlr_output_head object is destroyed the same name may + be reused later. The names will also remain consistent across sessions + with the same hardware and software configuration. + + 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. + + If this head matches a wl_output, the wl_output.name event must report + the same name. + + The name event is sent after a wlr_output_head object is created. This + event is only sent once per object, and the name does not change over + the lifetime of the wlr_output_head object. + </description> + <arg name="name" type="string"/> + </event> + + <event name="description"> + <description summary="head description"> + This event describes a human-readable description of the head. + + The description is a UTF-8 string with no convention defined for its + contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 + output via :1'. However, do not assume that the name is a reflection of + the make, model, serial of the underlying DRM connector or the display + name of the underlying X11 connection, etc. + + If this head matches a wl_output, the wl_output.description event must + report the same name. + + The description event is sent after a wlr_output_head object is created. + This event is only sent once per object, and the description does not + change over the lifetime of the wlr_output_head object. + </description> + <arg name="description" type="string"/> + </event> + + <event name="physical_size"> + <description summary="head physical size"> + This event describes the physical size of the head. This event is only + sent if the head has a physical size (e.g. is not a projector or a + virtual device). + + The physical size event is sent after a wlr_output_head object is created. This + event is only sent once per object, and the physical size does not change over + the lifetime of the wlr_output_head object. + </description> + <arg name="width" type="int" summary="width in millimeters of the output"/> + <arg name="height" type="int" summary="height in millimeters of the output"/> + </event> + + <event name="mode"> + <description summary="introduce a mode"> + This event introduces a mode for this head. It is sent once per + supported mode. + </description> + <arg name="mode" type="new_id" interface="zwlr_output_mode_v1"/> + </event> + + <event name="enabled"> + <description summary="head is enabled or disabled"> + This event describes whether the head is enabled. A disabled head is not + mapped to a region of the global compositor space. + + When a head is disabled, some properties (current_mode, position, + transform and scale) are irrelevant. + </description> + <arg name="enabled" type="int" summary="zero if disabled, non-zero if enabled"/> + </event> + + <event name="current_mode"> + <description summary="current mode"> + This event describes the mode currently in use for this head. It is only + sent if the output is enabled. + </description> + <arg name="mode" type="object" interface="zwlr_output_mode_v1"/> + </event> + + <event name="position"> + <description summary="current position"> + This events describes the position of the head in the global compositor + space. It is only sent if the output is enabled. + </description> + <arg name="x" type="int" + summary="x position within the global compositor space"/> + <arg name="y" type="int" + summary="y position within the global compositor space"/> + </event> + + <event name="transform"> + <description summary="current transformation"> + This event describes the transformation currently applied to the head. + It is only sent if the output is enabled. + </description> + <arg name="transform" type="int" enum="wl_output.transform"/> + </event> + + <event name="scale"> + <description summary="current scale"> + This events describes the scale of the head in the global compositor + space. It is only sent if the output is enabled. + </description> + <arg name="scale" type="fixed"/> + </event> + + <event name="finished"> + <description summary="the head has disappeared"> + This event indicates that the head is no longer available. The head + object becomes inert. Clients should send a destroy request and release + any resources associated with it. + </description> + </event> + + <!-- Version 2 additions --> + + <event name="make" since="2"> + <description summary="head manufacturer"> + This event describes the manufacturer of the head. + + Together with the model and serial_number events the purpose is to + allow clients to recognize heads from previous sessions and for example + load head-specific configurations back. + + It is not guaranteed this event will be ever sent. A reason for that + can be that the compositor does not have information about the make of + the head or the definition of a make is not sensible in the current + setup, for example in a virtual session. Clients can still try to + identify the head by available information from other events but should + be aware that there is an increased risk of false positives. + + If sent, the make event is sent after a wlr_output_head object is + created and only sent once per object. The make does not change over + the lifetime of the wlr_output_head object. + + It is not recommended to display the make string in UI to users. For + that the string provided by the description event should be preferred. + </description> + <arg name="make" type="string"/> + </event> + + <event name="model" since="2"> + <description summary="head model"> + This event describes the model of the head. + + Together with the make and serial_number events the purpose is to + allow clients to recognize heads from previous sessions and for example + load head-specific configurations back. + + It is not guaranteed this event will be ever sent. A reason for that + can be that the compositor does not have information about the model of + the head or the definition of a model is not sensible in the current + setup, for example in a virtual session. Clients can still try to + identify the head by available information from other events but should + be aware that there is an increased risk of false positives. + + If sent, the model event is sent after a wlr_output_head object is + created and only sent once per object. The model does not change over + the lifetime of the wlr_output_head object. + + It is not recommended to display the model string in UI to users. For + that the string provided by the description event should be preferred. + </description> + <arg name="model" type="string"/> + </event> + + <event name="serial_number" since="2"> + <description summary="head serial number"> + This event describes the serial number of the head. + + Together with the make and model events the purpose is to allow clients + to recognize heads from previous sessions and for example load head- + specific configurations back. + + It is not guaranteed this event will be ever sent. A reason for that + can be that the compositor does not have information about the serial + number of the head or the definition of a serial number is not sensible + in the current setup. Clients can still try to identify the head by + available information from other events but should be aware that there + is an increased risk of false positives. + + If sent, the serial number event is sent after a wlr_output_head object + is created and only sent once per object. The serial number does not + change over the lifetime of the wlr_output_head object. + + It is not recommended to display the serial_number string in UI to + users. For that the string provided by the description event should be + preferred. + </description> + <arg name="serial_number" type="string"/> + </event> + + <!-- Version 3 additions --> + + <request name="release" type="destructor" since="3"> + <description summary="destroy the head object"> + This request indicates that the client will no longer use this head + object. + </description> + </request> + + <!-- Version 4 additions --> + + <enum name="adaptive_sync_state" since="4"> + <entry name="disabled" value="0" summary="adaptive sync is disabled"/> + <entry name="enabled" value="1" summary="adaptive sync is enabled"/> + </enum> + + <event name="adaptive_sync" since="4"> + <description summary="current adaptive sync state"> + This event describes whether adaptive sync is currently enabled for + the head or not. Adaptive sync is also known as Variable Refresh + Rate or VRR. + </description> + <arg name="state" type="uint" enum="adaptive_sync_state"/> + </event> + </interface> + + <interface name="zwlr_output_mode_v1" version="3"> + <description summary="output mode"> + This object describes an output mode. + + Some heads don't support output modes, in which case modes won't be + advertised. + + Properties sent via this interface are applied atomically via the + wlr_output_manager.done event. No guarantees are made regarding the order + in which properties are sent. + </description> + + <event name="size"> + <description summary="mode size"> + This event describes the mode size. The size 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 or transformed. + </description> + <arg name="width" type="int" summary="width of the mode in hardware units"/> + <arg name="height" type="int" summary="height of the mode in hardware units"/> + </event> + + <event name="refresh"> + <description summary="mode refresh rate"> + This event describes the mode's fixed vertical refresh rate. It is only + sent if the mode has a fixed refresh rate. + </description> + <arg name="refresh" type="int" summary="vertical refresh rate in mHz"/> + </event> + + <event name="preferred"> + <description summary="mode is preferred"> + This event advertises this mode as preferred. + </description> + </event> + + <event name="finished"> + <description summary="the mode has disappeared"> + This event indicates that the mode is no longer available. The mode + object becomes inert. Clients should send a destroy request and release + any resources associated with it. + </description> + </event> + + <!-- Version 3 additions --> + + <request name="release" type="destructor" since="3"> + <description summary="destroy the mode object"> + This request indicates that the client will no longer use this mode + object. + </description> + </request> + </interface> + + <interface name="zwlr_output_configuration_v1" version="4"> + <description summary="output configuration"> + This object is used by the client to describe a full output configuration. + + First, the client needs to setup the output configuration. Each head can + be either enabled (and configured) or disabled. It is a protocol error to + send two enable_head or disable_head requests with the same head. It is a + protocol error to omit a head in a configuration. + + Then, the client can apply or test the configuration. The compositor will + then reply with a succeeded, failed or cancelled event. Finally the client + should destroy the configuration object. + </description> + + <enum name="error"> + <entry name="already_configured_head" value="1" + summary="head has been configured twice"/> + <entry name="unconfigured_head" value="2" + summary="head has not been configured"/> + <entry name="already_used" value="3" + summary="request sent after configuration has been applied or tested"/> + </enum> + + <request name="enable_head"> + <description summary="enable and configure a head"> + Enable a head. This request creates a head configuration object that can + be used to change the head's properties. + </description> + <arg name="id" type="new_id" interface="zwlr_output_configuration_head_v1" + summary="a new object to configure the head"/> + <arg name="head" type="object" interface="zwlr_output_head_v1" + summary="the head to be enabled"/> + </request> + + <request name="disable_head"> + <description summary="disable a head"> + Disable a head. + </description> + <arg name="head" type="object" interface="zwlr_output_head_v1" + summary="the head to be disabled"/> + </request> + + <request name="apply"> + <description summary="apply the configuration"> + Apply the new output configuration. + + In case the configuration is successfully applied, there is no guarantee + that the new output state matches completely the requested + configuration. For instance, a compositor might round the scale if it + doesn't support fractional scaling. + + After this request has been sent, the compositor must respond with an + succeeded, failed or cancelled event. Sending a request that isn't the + destructor is a protocol error. + </description> + </request> + + <request name="test"> + <description summary="test the configuration"> + Test the new output configuration. The configuration won't be applied, + but will only be validated. + + Even if the compositor succeeds to test a configuration, applying it may + fail. + + After this request has been sent, the compositor must respond with an + succeeded, failed or cancelled event. Sending a request that isn't the + destructor is a protocol error. + </description> + </request> + + <event name="succeeded"> + <description summary="configuration changes succeeded"> + Sent after the compositor has successfully applied the changes or + tested them. + + Upon receiving this event, the client should destroy this object. + + If the current configuration has changed, events to describe the changes + will be sent followed by a wlr_output_manager.done event. + </description> + </event> + + <event name="failed"> + <description summary="configuration changes failed"> + Sent if the compositor rejects the changes or failed to apply them. The + compositor should revert any changes made by the apply request that + triggered this event. + + Upon receiving this event, the client should destroy this object. + </description> + </event> + + <event name="cancelled"> + <description summary="configuration has been cancelled"> + Sent if the compositor cancels the configuration because the state of an + output changed and the client has outdated information (e.g. after an + output has been hotplugged). + + The client can create a new configuration with a newer serial and try + again. + + Upon receiving this event, the client should destroy this object. + </description> + </event> + + <request name="destroy" type="destructor"> + <description summary="destroy the output configuration"> + Using this request a client can tell the compositor that it is not going + to use the configuration object anymore. Any changes to the outputs + that have not been applied will be discarded. + + This request also destroys wlr_output_configuration_head objects created + via this object. + </description> + </request> + </interface> + + <interface name="zwlr_output_configuration_head_v1" version="4"> + <description summary="head configuration"> + This object is used by the client to update a single head's configuration. + + It is a protocol error to set the same property twice. + </description> + + <enum name="error"> + <entry name="already_set" value="1" summary="property has already been set"/> + <entry name="invalid_mode" value="2" summary="mode doesn't belong to head"/> + <entry name="invalid_custom_mode" value="3" summary="mode is invalid"/> + <entry name="invalid_transform" value="4" summary="transform value outside enum"/> + <entry name="invalid_scale" value="5" summary="scale negative or zero"/> + <entry name="invalid_adaptive_sync_state" value="6" since="4" + summary="invalid enum value used in the set_adaptive_sync request"/> + </enum> + + <request name="set_mode"> + <description summary="set the mode"> + This request sets the head's mode. + </description> + <arg name="mode" type="object" interface="zwlr_output_mode_v1"/> + </request> + + <request name="set_custom_mode"> + <description summary="set a custom mode"> + This request assigns a custom mode to the head. The size is given in + physical hardware units of the output device. If set to zero, the + refresh rate is unspecified. + + It is a protocol error to set both a mode and a custom mode. + </description> + <arg name="width" type="int" summary="width of the mode in hardware units"/> + <arg name="height" type="int" summary="height of the mode in hardware units"/> + <arg name="refresh" type="int" summary="vertical refresh rate in mHz or zero"/> + </request> + + <request name="set_position"> + <description summary="set the position"> + This request sets the head's position in the global compositor space. + </description> + <arg name="x" type="int" summary="x position in the global compositor space"/> + <arg name="y" type="int" summary="y position in the global compositor space"/> + </request> + + <request name="set_transform"> + <description summary="set the transform"> + This request sets the head's transform. + </description> + <arg name="transform" type="int" enum="wl_output.transform"/> + </request> + + <request name="set_scale"> + <description summary="set the scale"> + This request sets the head's scale. + </description> + <arg name="scale" type="fixed"/> + </request> + + <!-- Version 4 additions --> + + <request name="set_adaptive_sync" since="4"> + <description summary="enable/disable adaptive sync"> + This request enables/disables adaptive sync. Adaptive sync is also + known as Variable Refresh Rate or VRR. + </description> + <arg name="state" type="uint" enum="zwlr_output_head_v1.adaptive_sync_state"/> + </request> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-output-power-management-unstable-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-output-power-management-unstable-v1.xml new file mode 100644 index 0000000..20dbb77 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-output-power-management-unstable-v1.xml @@ -0,0 +1,128 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="wlr_output_power_management_unstable_v1"> + <copyright> + Copyright © 2019 Purism SPC + + 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. + </copyright> + + <description summary="Control power management modes of outputs"> + This protocol allows clients to control power management modes + of outputs that are currently part of the compositor space. The + intent is to allow special clients like desktop shells to power + down outputs when the system is idle. + + To modify outputs not currently part of the compositor space see + wlr-output-management. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible changes + may be added together with the corresponding interface version bump. + Backward incompatible changes are done by bumping the version number in + the protocol and interface names and resetting the interface version. + Once the protocol is to be declared stable, the 'z' prefix and the + version number in the protocol and interface names are removed and the + interface version number is reset. + </description> + + <interface name="zwlr_output_power_manager_v1" version="1"> + <description summary="manager to create per-output power management"> + This interface is a manager that allows creating per-output power + management mode controls. + </description> + + <request name="get_output_power"> + <description summary="get a power management for an output"> + Create an output power management mode control that can be used to + adjust the power management mode for a given output. + </description> + <arg name="id" type="new_id" interface="zwlr_output_power_v1"/> + <arg name="output" type="object" interface="wl_output"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy the manager"> + All objects created by the manager will still remain valid, until their + appropriate destroy request has been called. + </description> + </request> + </interface> + + <interface name="zwlr_output_power_v1" version="1"> + <description summary="adjust power management mode for an output"> + This object offers requests to set the power management mode of + an output. + </description> + + <enum name="mode"> + <entry name="off" value="0" + summary="Output is turned off."/> + <entry name="on" value="1" + summary="Output is turned on, no power saving"/> + </enum> + + <enum name="error"> + <entry name="invalid_mode" value="1" summary="nonexistent power save mode"/> + </enum> + + <request name="set_mode"> + <description summary="Set an outputs power save mode"> + Set an output's power save mode to the given mode. The mode change + is effective immediately. If the output does not support the given + mode a failed event is sent. + </description> + <arg name="mode" type="uint" enum="mode" summary="the power save mode to set"/> + </request> + + <event name="mode"> + <description summary="Report a power management mode change"> + Report the power management mode change of an output. + + The mode event is sent after an output changed its power + management mode. The reason can be a client using set_mode or the + compositor deciding to change an output's mode. + This event is also sent immediately when the object is created + so the client is informed about the current power management mode. + </description> + <arg name="mode" type="uint" enum="mode" + summary="the output's new power management mode"/> + </event> + + <event name="failed"> + <description summary="object no longer valid"> + This event indicates that the output power management mode control + is no longer valid. This can happen for a number of reasons, + including: + - The output doesn't support power management + - Another client already has exclusive power management mode control + for this output + - The output disappeared + + Upon receiving this event, the client should destroy this object. + </description> + </event> + + <request name="destroy" type="destructor"> + <description summary="destroy this power management"> + Destroys the output power management mode control object. + </description> + </request> + </interface> +</protocol> diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-screencopy-unstable-v1.xml b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-screencopy-unstable-v1.xml new file mode 100644 index 0000000..8b20661 --- /dev/null +++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/proto/xml/wlr-screencopy-unstable-v1.xml @@ -0,0 +1,234 @@ +<?xml version="1.0" encoding="UTF-8"?> +<protocol name="wlr_screencopy_unstable_v1"> + <copyright> + Copyright © 2018 Simon Ser + Copyright © 2019 Andri Yngvason + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + </copyright> + + <description summary="screen content capturing on client buffers"> + This protocol allows clients to ask the compositor to copy part of the + screen content to a client buffer. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible changes + may be added together with the corresponding interface version bump. + Backward incompatible changes are done by bumping the version number in + the protocol and interface names and resetting the interface version. + Once the protocol is to be declared stable, the 'z' prefix and the + version number in the protocol and interface names are removed and the + interface version number is reset. + + Note! This protocol is deprecated and not intended for production use. + The ext-image-copy-capture-v1 protocol should be used instead. + </description> + + <interface name="zwlr_screencopy_manager_v1" version="3"> + <description summary="manager to inform clients and begin capturing"> + This object is a manager which offers requests to start capturing from a + source. + </description> + + <request name="capture_output"> + <description summary="capture an output"> + Capture the next frame of an entire output. + </description> + <arg name="frame" type="new_id" interface="zwlr_screencopy_frame_v1"/> + <arg name="overlay_cursor" type="int" + summary="composite cursor onto the frame"/> + <arg name="output" type="object" interface="wl_output"/> + </request> + + <request name="capture_output_region"> + <description summary="capture an output's region"> + Capture the next frame of an output's region. + + The region is given in output logical coordinates, see + xdg_output.logical_size. The region will be clipped to the output's + extents. + </description> + <arg name="frame" type="new_id" interface="zwlr_screencopy_frame_v1"/> + <arg name="overlay_cursor" type="int" + summary="composite cursor onto the frame"/> + <arg name="output" type="object" interface="wl_output"/> + <arg name="x" type="int"/> + <arg name="y" type="int"/> + <arg name="width" type="int"/> + <arg name="height" type="int"/> + </request> + + <request name="destroy" type="destructor"> + <description summary="destroy the manager"> + All objects created by the manager will still remain valid, until their + appropriate destroy request has been called. + </description> + </request> + </interface> + + <interface name="zwlr_screencopy_frame_v1" version="3"> + <description summary="a frame ready for copy"> + This object represents a single frame. + + When created, a series of buffer events will be sent, each representing a + supported buffer type. The "buffer_done" event is sent afterwards to + indicate that all supported buffer types have been enumerated. The client + will then be able to send a "copy" request. If the capture is successful, + the compositor will send a "flags" event followed by a "ready" event. + + For objects version 2 or lower, wl_shm buffers are always supported, ie. + the "buffer" event is guaranteed to be sent. + + If the capture failed, the "failed" event is sent. This can happen anytime + before the "ready" event. + + Once either a "ready" or a "failed" event is received, the client should + destroy the frame. + </description> + + <event name="buffer"> + <description summary="wl_shm buffer information"> + Provides information about wl_shm buffer parameters that need to be + used for this frame. This event is sent once after the frame is created + if wl_shm buffers are supported. + </description> + <arg name="format" type="uint" enum="wl_shm.format" summary="buffer format"/> + <arg name="width" type="uint" summary="buffer width"/> + <arg name="height" type="uint" summary="buffer height"/> + <arg name="stride" type="uint" summary="buffer stride"/> + </event> + + <request name="copy"> + <description summary="copy the frame"> + Copy the frame to the supplied buffer. The buffer must have the + correct size, see zwlr_screencopy_frame_v1.buffer and + zwlr_screencopy_frame_v1.linux_dmabuf. The buffer needs to have a + supported format. + + If the frame is successfully copied, "flags" and "ready" events are + sent. Otherwise, a "failed" event is sent. + </description> + <arg name="buffer" type="object" interface="wl_buffer"/> + </request> + + <enum name="error"> + <entry name="already_used" value="0" + summary="the object has already been used to copy a wl_buffer"/> + <entry name="invalid_buffer" value="1" + summary="buffer attributes are invalid"/> + </enum> + + <enum name="flags" bitfield="true"> + <entry name="y_invert" value="1" summary="contents are y-inverted"/> + </enum> + + <event name="flags"> + <description summary="frame flags"> + Provides flags about the frame. This event is sent once before the + "ready" event. + </description> + <arg name="flags" type="uint" enum="flags" summary="frame flags"/> + </event> + + <event name="ready"> + <description summary="indicates frame is available for reading"> + Called as soon as the frame is copied, indicating it is available + for reading. This event includes the time at which the presentation took place. + + The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples, + each component being an unsigned 32-bit value. Whole seconds are in + tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo, + and the additional fractional part in tv_nsec as nanoseconds. Hence, + for valid timestamps tv_nsec must be in [0, 999999999]. The seconds part + may have an arbitrary offset at start. + + After receiving this event, the client should destroy the object. + </description> + <arg name="tv_sec_hi" type="uint" + summary="high 32 bits of the seconds part of the timestamp"/> + <arg name="tv_sec_lo" type="uint" + summary="low 32 bits of the seconds part of the timestamp"/> + <arg name="tv_nsec" type="uint" + summary="nanoseconds part of the timestamp"/> + </event> + + <event name="failed"> + <description summary="frame copy failed"> + This event indicates that the attempted frame copy has failed. + + After receiving this event, the client should destroy the object. + </description> + </event> + + <request name="destroy" type="destructor"> + <description summary="delete this object, used or not"> + Destroys the frame. This request can be sent at any time by the client. + </description> + </request> + + <!-- Version 2 additions --> + <request name="copy_with_damage" since="2"> + <description summary="copy the frame when it's damaged"> + Same as copy, except it waits until there is damage to copy. + </description> + <arg name="buffer" type="object" interface="wl_buffer"/> + </request> + + <event name="damage" since="2"> + <description summary="carries the coordinates of the damaged region"> + This event is sent right before the ready event when copy_with_damage is + requested. It may be generated multiple times for each copy_with_damage + request. + + The arguments describe a box around an area that has changed since the + last copy request that was derived from the current screencopy manager + instance. + + The union of all regions received between the call to copy_with_damage + and a ready event is the total damage since the prior ready event. + </description> + <arg name="x" type="uint" summary="damaged x coordinates"/> + <arg name="y" type="uint" summary="damaged y coordinates"/> + <arg name="width" type="uint" summary="current width"/> + <arg name="height" type="uint" summary="current height"/> + </event> + + <!-- Version 3 additions --> + <event name="linux_dmabuf" since="3"> + <description summary="linux-dmabuf buffer information"> + Provides information about linux-dmabuf buffer parameters that need to + be used for this frame. This event is sent once after the frame is + created if linux-dmabuf buffers are supported. + </description> + <arg name="format" type="uint" summary="fourcc pixel format"/> + <arg name="width" type="uint" summary="buffer width"/> + <arg name="height" type="uint" summary="buffer height"/> + </event> + + <event name="buffer_done" since="3"> + <description summary="all buffer types reported"> + This event is sent once after all buffer events have been sent. + + The client should proceed to create a buffer of one of the supported + types, and send a "copy" request. + </description> + </event> + </interface> +</protocol> |