269 lines
8.9 KiB
Go
269 lines
8.9 KiB
Go
// Generated by go-wayland-scanner
|
|
// https://github.com/yaslama/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/yaslama/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.Context().Unregister(i)
|
|
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.Context().Unregister(i)
|
|
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)
|
|
}
|
|
}
|