// Code generated by wlbgen; DO NOT EDIT.

// Upstream protocol copyright and license:
// Copyright 2014 © Stephen "Lyude" Chandler Paul
// Copyright 2015-2024 © 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 tablet

import (
	"fmt"
	wayland "github.com/bnema/go-wayland-bindings/server/wayland"
	"github.com/bnema/purego-libwayland/server"
	"runtime"
)

var ZwpTabletManagerV2Interface *server.Interface
var ZwpTabletSeatV2Interface *server.Interface
var ZwpTabletToolV2Interface *server.Interface
var ZwpTabletV2Interface *server.Interface
var ZwpTabletPadRingV2Interface *server.Interface
var ZwpTabletPadStripV2Interface *server.Interface
var ZwpTabletPadGroupV2Interface *server.Interface
var ZwpTabletPadV2Interface *server.Interface
var ZwpTabletPadDialV2Interface *server.Interface

func init() {
	ZwpTabletManagerV2Interface = &server.Interface{Name: "zwp_tablet_manager_v2", Version: 2}
	ZwpTabletSeatV2Interface = &server.Interface{Name: "zwp_tablet_seat_v2", Version: 2}
	ZwpTabletToolV2Interface = &server.Interface{Name: "zwp_tablet_tool_v2", Version: 2}
	ZwpTabletV2Interface = &server.Interface{Name: "zwp_tablet_v2", Version: 2}
	ZwpTabletPadRingV2Interface = &server.Interface{Name: "zwp_tablet_pad_ring_v2", Version: 2}
	ZwpTabletPadStripV2Interface = &server.Interface{Name: "zwp_tablet_pad_strip_v2", Version: 2}
	ZwpTabletPadGroupV2Interface = &server.Interface{Name: "zwp_tablet_pad_group_v2", Version: 2}
	ZwpTabletPadV2Interface = &server.Interface{Name: "zwp_tablet_pad_v2", Version: 2}
	ZwpTabletPadDialV2Interface = &server.Interface{Name: "zwp_tablet_pad_dial_v2", Version: 2}
	ZwpTabletManagerV2Interface.Requests = []server.Message{
		{Name: "get_tablet_seat", Signature: "no", Types: []*server.Interface{ZwpTabletSeatV2Interface, wayland.SeatInterface}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletManagerV2Interface.Events = []server.Message{}
	ZwpTabletSeatV2Interface.Requests = []server.Message{
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletSeatV2Interface.Events = []server.Message{
		{Name: "tablet_added", Signature: "n", Types: []*server.Interface{ZwpTabletV2Interface}},
		{Name: "tool_added", Signature: "n", Types: []*server.Interface{ZwpTabletToolV2Interface}},
		{Name: "pad_added", Signature: "n", Types: []*server.Interface{ZwpTabletPadV2Interface}},
	}
	ZwpTabletToolV2Interface.Requests = []server.Message{
		{Name: "set_cursor", Signature: "u?oii", Types: []*server.Interface{nil, wayland.SurfaceInterface, nil, nil}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletToolV2Interface.Events = []server.Message{
		{Name: "type", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "hardware_serial", Signature: "uu", Types: []*server.Interface{nil, nil}},
		{Name: "hardware_id_wacom", Signature: "uu", Types: []*server.Interface{nil, nil}},
		{Name: "capability", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "done", Signature: "", Types: []*server.Interface{}},
		{Name: "removed", Signature: "", Types: []*server.Interface{}},
		{Name: "proximity_in", Signature: "uoo", Types: []*server.Interface{nil, ZwpTabletV2Interface, wayland.SurfaceInterface}},
		{Name: "proximity_out", Signature: "", Types: []*server.Interface{}},
		{Name: "down", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "up", Signature: "", Types: []*server.Interface{}},
		{Name: "motion", Signature: "ff", Types: []*server.Interface{nil, nil}},
		{Name: "pressure", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "distance", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "tilt", Signature: "ff", Types: []*server.Interface{nil, nil}},
		{Name: "rotation", Signature: "f", Types: []*server.Interface{nil}},
		{Name: "slider", Signature: "i", Types: []*server.Interface{nil}},
		{Name: "wheel", Signature: "fi", Types: []*server.Interface{nil, nil}},
		{Name: "button", Signature: "uuu", Types: []*server.Interface{nil, nil, nil}},
		{Name: "frame", Signature: "u", Types: []*server.Interface{nil}},
	}
	ZwpTabletV2Interface.Requests = []server.Message{
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletV2Interface.Events = []server.Message{
		{Name: "name", Signature: "s", Types: []*server.Interface{nil}},
		{Name: "id", Signature: "uu", Types: []*server.Interface{nil, nil}},
		{Name: "path", Signature: "s", Types: []*server.Interface{nil}},
		{Name: "done", Signature: "", Types: []*server.Interface{}},
		{Name: "removed", Signature: "", Types: []*server.Interface{}},
		{Name: "bustype", Signature: "2u", Types: []*server.Interface{nil}},
	}
	ZwpTabletPadRingV2Interface.Requests = []server.Message{
		{Name: "set_feedback", Signature: "su", Types: []*server.Interface{nil, nil}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletPadRingV2Interface.Events = []server.Message{
		{Name: "source", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "angle", Signature: "f", Types: []*server.Interface{nil}},
		{Name: "stop", Signature: "", Types: []*server.Interface{}},
		{Name: "frame", Signature: "u", Types: []*server.Interface{nil}},
	}
	ZwpTabletPadStripV2Interface.Requests = []server.Message{
		{Name: "set_feedback", Signature: "su", Types: []*server.Interface{nil, nil}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletPadStripV2Interface.Events = []server.Message{
		{Name: "source", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "position", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "stop", Signature: "", Types: []*server.Interface{}},
		{Name: "frame", Signature: "u", Types: []*server.Interface{nil}},
	}
	ZwpTabletPadGroupV2Interface.Requests = []server.Message{
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletPadGroupV2Interface.Events = []server.Message{
		{Name: "buttons", Signature: "a", Types: []*server.Interface{nil}},
		{Name: "ring", Signature: "n", Types: []*server.Interface{ZwpTabletPadRingV2Interface}},
		{Name: "strip", Signature: "n", Types: []*server.Interface{ZwpTabletPadStripV2Interface}},
		{Name: "modes", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "done", Signature: "", Types: []*server.Interface{}},
		{Name: "mode_switch", Signature: "uuu", Types: []*server.Interface{nil, nil, nil}},
		{Name: "dial", Signature: "2n", Types: []*server.Interface{ZwpTabletPadDialV2Interface}},
	}
	ZwpTabletPadV2Interface.Requests = []server.Message{
		{Name: "set_feedback", Signature: "usu", Types: []*server.Interface{nil, nil, nil}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletPadV2Interface.Events = []server.Message{
		{Name: "group", Signature: "n", Types: []*server.Interface{ZwpTabletPadGroupV2Interface}},
		{Name: "path", Signature: "s", Types: []*server.Interface{nil}},
		{Name: "buttons", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "done", Signature: "", Types: []*server.Interface{}},
		{Name: "button", Signature: "uuu", Types: []*server.Interface{nil, nil, nil}},
		{Name: "enter", Signature: "uoo", Types: []*server.Interface{nil, ZwpTabletV2Interface, wayland.SurfaceInterface}},
		{Name: "leave", Signature: "uo", Types: []*server.Interface{nil, wayland.SurfaceInterface}},
		{Name: "removed", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletPadDialV2Interface.Requests = []server.Message{
		{Name: "set_feedback", Signature: "su", Types: []*server.Interface{nil, nil}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ZwpTabletPadDialV2Interface.Events = []server.Message{
		{Name: "delta", Signature: "i", Types: []*server.Interface{nil}},
		{Name: "frame", Signature: "u", Types: []*server.Interface{nil}},
	}
	if err := server.NewInterfaces(ZwpTabletManagerV2Interface, ZwpTabletSeatV2Interface, ZwpTabletToolV2Interface, ZwpTabletV2Interface, ZwpTabletPadRingV2Interface, ZwpTabletPadStripV2Interface, ZwpTabletPadGroupV2Interface, ZwpTabletPadV2Interface, ZwpTabletPadDialV2Interface); err != nil {
		panic(err)
	}
}

// ZwpTabletManagerV2 controller object for graphic tablet devices.
type ZwpTabletManagerV2 struct{ *server.Resource }

func WrapZwpTabletManagerV2(r *server.Resource) *ZwpTabletManagerV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletManagerV2{r}
}

const ZwpTabletManagerV2RequestGetTabletSeat uint32 = 0
const ZwpTabletManagerV2RequestDestroy uint32 = 1

// ZwpTabletManagerV2Handler handles zwp_tablet_manager_v2 requests.
type ZwpTabletManagerV2Handler interface {
	GetTabletSeat(self *ZwpTabletManagerV2, tabletSeat uint32, seat *wayland.Seat)
	Destroy(self *ZwpTabletManagerV2)
}

func NewZwpTabletManagerV2(c server.Client, version int32, id uint32, h ZwpTabletManagerV2Handler) (*ZwpTabletManagerV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_manager_v2")
	}
	var self *ZwpTabletManagerV2
	r, err := c.CreateResource(ZwpTabletManagerV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.GetTabletSeat(self, args[0].NewID(), wayland.WrapSeat(args[1].Resource()))
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletManagerV2(r)
	r.Data = self
	return self, nil
}
func NewZwpTabletManagerV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletManagerV2Interface, version, bind)
}

// ZwpTabletSeatV2 controller object for graphic tablet devices of a seat.
type ZwpTabletSeatV2 struct{ *server.Resource }

func WrapZwpTabletSeatV2(r *server.Resource) *ZwpTabletSeatV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletSeatV2{r}
}

const ZwpTabletSeatV2RequestDestroy uint32 = 0
const ZwpTabletSeatV2EventTabletAdded uint32 = 0
const ZwpTabletSeatV2EventToolAdded uint32 = 1
const ZwpTabletSeatV2EventPadAdded uint32 = 2

// ZwpTabletSeatV2Handler handles zwp_tablet_seat_v2 requests.
type ZwpTabletSeatV2Handler interface {
	Destroy(self *ZwpTabletSeatV2)
}

func NewZwpTabletSeatV2(c server.Client, version int32, id uint32, h ZwpTabletSeatV2Handler) (*ZwpTabletSeatV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_seat_v2")
	}
	var self *ZwpTabletSeatV2
	r, err := c.CreateResource(ZwpTabletSeatV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletSeatV2(r)
	r.Data = self
	return self, nil
}

// SendTabletAdded new device notification.
func (self *ZwpTabletSeatV2) SendTabletAdded(id *ZwpTabletV2) {
	self.PostEvent(ZwpTabletSeatV2EventTabletAdded, server.NewID(resourceOf(id)))
}

// SendToolAdded a new tool has been used with a tablet.
func (self *ZwpTabletSeatV2) SendToolAdded(id *ZwpTabletToolV2) {
	self.PostEvent(ZwpTabletSeatV2EventToolAdded, server.NewID(resourceOf(id)))
}

// SendPadAdded new pad notification.
func (self *ZwpTabletSeatV2) SendPadAdded(id *ZwpTabletPadV2) {
	self.PostEvent(ZwpTabletSeatV2EventPadAdded, server.NewID(resourceOf(id)))
}
func NewZwpTabletSeatV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletSeatV2Interface, version, bind)
}

// ZwpTabletToolV2 a physical tablet tool.
type ZwpTabletToolV2 struct{ *server.Resource }

func WrapZwpTabletToolV2(r *server.Resource) *ZwpTabletToolV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletToolV2{r}
}

const ZwpTabletToolV2RequestSetCursor uint32 = 0
const ZwpTabletToolV2RequestDestroy uint32 = 1
const ZwpTabletToolV2EventType uint32 = 0
const ZwpTabletToolV2EventHardwareSerial uint32 = 1
const ZwpTabletToolV2EventHardwareIdWacom uint32 = 2
const ZwpTabletToolV2EventCapability uint32 = 3
const ZwpTabletToolV2EventDone uint32 = 4
const ZwpTabletToolV2EventRemoved uint32 = 5
const ZwpTabletToolV2EventProximityIn uint32 = 6
const ZwpTabletToolV2EventProximityOut uint32 = 7
const ZwpTabletToolV2EventDown uint32 = 8
const ZwpTabletToolV2EventUp uint32 = 9
const ZwpTabletToolV2EventMotion uint32 = 10
const ZwpTabletToolV2EventPressure uint32 = 11
const ZwpTabletToolV2EventDistance uint32 = 12
const ZwpTabletToolV2EventTilt uint32 = 13
const ZwpTabletToolV2EventRotation uint32 = 14
const ZwpTabletToolV2EventSlider uint32 = 15
const ZwpTabletToolV2EventWheel uint32 = 16
const ZwpTabletToolV2EventButton uint32 = 17
const ZwpTabletToolV2EventFrame uint32 = 18

// ZwpTabletToolV2Type a physical tool type.
type ZwpTabletToolV2Type uint32

const (
	ZwpTabletToolV2TypePen      ZwpTabletToolV2Type = 0x140
	ZwpTabletToolV2TypeEraser   ZwpTabletToolV2Type = 0x141
	ZwpTabletToolV2TypeBrush    ZwpTabletToolV2Type = 0x142
	ZwpTabletToolV2TypePencil   ZwpTabletToolV2Type = 0x143
	ZwpTabletToolV2TypeAirbrush ZwpTabletToolV2Type = 0x144
	ZwpTabletToolV2TypeFinger   ZwpTabletToolV2Type = 0x145
	ZwpTabletToolV2TypeMouse    ZwpTabletToolV2Type = 0x146
	ZwpTabletToolV2TypeLens     ZwpTabletToolV2Type = 0x147
)

// ZwpTabletToolV2Capability capability flags for a tool.
type ZwpTabletToolV2Capability uint32

const (
	ZwpTabletToolV2CapabilityTilt     ZwpTabletToolV2Capability = 1
	ZwpTabletToolV2CapabilityPressure ZwpTabletToolV2Capability = 2
	ZwpTabletToolV2CapabilityDistance ZwpTabletToolV2Capability = 3
	ZwpTabletToolV2CapabilityRotation ZwpTabletToolV2Capability = 4
	ZwpTabletToolV2CapabilitySlider   ZwpTabletToolV2Capability = 5
	ZwpTabletToolV2CapabilityWheel    ZwpTabletToolV2Capability = 6
)

// ZwpTabletToolV2ButtonState physical button state.
type ZwpTabletToolV2ButtonState uint32

const (
	ZwpTabletToolV2ButtonStateReleased ZwpTabletToolV2ButtonState = 0
	ZwpTabletToolV2ButtonStatePressed  ZwpTabletToolV2ButtonState = 1
)

// ZwpTabletToolV2Error .
type ZwpTabletToolV2Error uint32

const (
	ZwpTabletToolV2ErrorRole ZwpTabletToolV2Error = 0
)

// ZwpTabletToolV2Handler handles zwp_tablet_tool_v2 requests.
type ZwpTabletToolV2Handler interface {
	SetCursor(self *ZwpTabletToolV2, serial uint32, surface *wayland.Surface, hotspotX int32, hotspotY int32)
	Destroy(self *ZwpTabletToolV2)
}

func NewZwpTabletToolV2(c server.Client, version int32, id uint32, h ZwpTabletToolV2Handler) (*ZwpTabletToolV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_tool_v2")
	}
	var self *ZwpTabletToolV2
	r, err := c.CreateResource(ZwpTabletToolV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.SetCursor(self, args[0].Uint(), wayland.WrapSurface(args[1].Resource()), args[2].Int(), args[3].Int())
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletToolV2(r)
	r.Data = self
	return self, nil
}

// SendType tool type.
func (self *ZwpTabletToolV2) SendType(toolType uint32) {
	self.PostEvent(ZwpTabletToolV2EventType, server.Uint(toolType))
}

// SendHardwareSerial unique hardware serial number of the tool.
func (self *ZwpTabletToolV2) SendHardwareSerial(hardwareSerialHi uint32, hardwareSerialLo uint32) {
	self.PostEvent(ZwpTabletToolV2EventHardwareSerial, server.Uint(hardwareSerialHi), server.Uint(hardwareSerialLo))
}

// SendHardwareIdWacom hardware id notification in Wacom's format.
func (self *ZwpTabletToolV2) SendHardwareIdWacom(hardwareIdHi uint32, hardwareIdLo uint32) {
	self.PostEvent(ZwpTabletToolV2EventHardwareIdWacom, server.Uint(hardwareIdHi), server.Uint(hardwareIdLo))
}

// SendCapability tool capability notification.
func (self *ZwpTabletToolV2) SendCapability(capability uint32) {
	self.PostEvent(ZwpTabletToolV2EventCapability, server.Uint(capability))
}

// SendDone tool description events sequence complete.
func (self *ZwpTabletToolV2) SendDone() {
	self.PostEvent(ZwpTabletToolV2EventDone)
}

// SendRemoved tool removed.
func (self *ZwpTabletToolV2) SendRemoved() {
	self.PostEvent(ZwpTabletToolV2EventRemoved)
}

// SendProximityIn proximity in event.
func (self *ZwpTabletToolV2) SendProximityIn(serial uint32, tablet *ZwpTabletV2, surface *wayland.Surface) {
	self.PostEvent(ZwpTabletToolV2EventProximityIn, server.Uint(serial), server.Object(resourceOf(tablet)), server.Object(resourceOf(surface)))
}

// SendProximityOut proximity out event.
func (self *ZwpTabletToolV2) SendProximityOut() {
	self.PostEvent(ZwpTabletToolV2EventProximityOut)
}

// SendDown tablet tool is making contact.
func (self *ZwpTabletToolV2) SendDown(serial uint32) {
	self.PostEvent(ZwpTabletToolV2EventDown, server.Uint(serial))
}

// SendUp tablet tool is no longer making contact.
func (self *ZwpTabletToolV2) SendUp() {
	self.PostEvent(ZwpTabletToolV2EventUp)
}

// SendMotion motion event.
func (self *ZwpTabletToolV2) SendMotion(x server.Fixed, y server.Fixed) {
	self.PostEvent(ZwpTabletToolV2EventMotion, server.FixedArg(x), server.FixedArg(y))
}

// SendPressure pressure change event.
func (self *ZwpTabletToolV2) SendPressure(pressure uint32) {
	self.PostEvent(ZwpTabletToolV2EventPressure, server.Uint(pressure))
}

// SendDistance distance change event.
func (self *ZwpTabletToolV2) SendDistance(distance uint32) {
	self.PostEvent(ZwpTabletToolV2EventDistance, server.Uint(distance))
}

// SendTilt tilt change event.
func (self *ZwpTabletToolV2) SendTilt(tiltX server.Fixed, tiltY server.Fixed) {
	self.PostEvent(ZwpTabletToolV2EventTilt, server.FixedArg(tiltX), server.FixedArg(tiltY))
}

// SendRotation z-rotation change event.
func (self *ZwpTabletToolV2) SendRotation(degrees server.Fixed) {
	self.PostEvent(ZwpTabletToolV2EventRotation, server.FixedArg(degrees))
}

// SendSlider Slider position change event.
func (self *ZwpTabletToolV2) SendSlider(position int32) {
	self.PostEvent(ZwpTabletToolV2EventSlider, server.Int(position))
}

// SendWheel Wheel delta event.
func (self *ZwpTabletToolV2) SendWheel(degrees server.Fixed, clicks int32) {
	self.PostEvent(ZwpTabletToolV2EventWheel, server.FixedArg(degrees), server.Int(clicks))
}

// SendButton button event.
func (self *ZwpTabletToolV2) SendButton(serial uint32, button uint32, state uint32) {
	self.PostEvent(ZwpTabletToolV2EventButton, server.Uint(serial), server.Uint(button), server.Uint(state))
}

// SendFrame frame event.
func (self *ZwpTabletToolV2) SendFrame(time uint32) {
	self.PostEvent(ZwpTabletToolV2EventFrame, server.Uint(time))
}
func NewZwpTabletToolV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletToolV2Interface, version, bind)
}

// ZwpTabletV2 graphics tablet device.
type ZwpTabletV2 struct{ *server.Resource }

func WrapZwpTabletV2(r *server.Resource) *ZwpTabletV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletV2{r}
}

const ZwpTabletV2RequestDestroy uint32 = 0
const ZwpTabletV2EventName uint32 = 0
const ZwpTabletV2EventId uint32 = 1
const ZwpTabletV2EventPath uint32 = 2
const ZwpTabletV2EventDone uint32 = 3
const ZwpTabletV2EventRemoved uint32 = 4
const ZwpTabletV2EventBustype uint32 = 5

// ZwpTabletV2Bustype bus type .
type ZwpTabletV2Bustype uint32

const (
	ZwpTabletV2BustypeUsb       ZwpTabletV2Bustype = 3
	ZwpTabletV2BustypeBluetooth ZwpTabletV2Bustype = 5
	ZwpTabletV2BustypeVirtual   ZwpTabletV2Bustype = 6
	ZwpTabletV2BustypeSerial    ZwpTabletV2Bustype = 17
	ZwpTabletV2BustypeI2c       ZwpTabletV2Bustype = 24
)

// ZwpTabletV2Handler handles zwp_tablet_v2 requests.
type ZwpTabletV2Handler interface {
	Destroy(self *ZwpTabletV2)
}

func NewZwpTabletV2(c server.Client, version int32, id uint32, h ZwpTabletV2Handler) (*ZwpTabletV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_v2")
	}
	var self *ZwpTabletV2
	r, err := c.CreateResource(ZwpTabletV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletV2(r)
	r.Data = self
	return self, nil
}

// SendName tablet device name.
func (self *ZwpTabletV2) SendName(name string) {
	var p runtime.Pinner
	defer p.Unpin()
	self.PostEvent(ZwpTabletV2EventName, server.String(&p, name, false))
}

// SendId tablet device vendor/product id.
func (self *ZwpTabletV2) SendId(vid uint32, pid uint32) {
	self.PostEvent(ZwpTabletV2EventId, server.Uint(vid), server.Uint(pid))
}

// SendPath path to the device.
func (self *ZwpTabletV2) SendPath(path string) {
	var p runtime.Pinner
	defer p.Unpin()
	self.PostEvent(ZwpTabletV2EventPath, server.String(&p, path, false))
}

// SendDone tablet description events sequence complete.
func (self *ZwpTabletV2) SendDone() {
	self.PostEvent(ZwpTabletV2EventDone)
}

// SendRemoved tablet removed event.
func (self *ZwpTabletV2) SendRemoved() {
	self.PostEvent(ZwpTabletV2EventRemoved)
}

// SendBustype tablet device bus type (since version 2).
func (self *ZwpTabletV2) SendBustype(bustype uint32) {
	self.PostEvent(ZwpTabletV2EventBustype, server.Uint(bustype))
}
func NewZwpTabletV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletV2Interface, version, bind)
}

// ZwpTabletPadRingV2 pad ring.
type ZwpTabletPadRingV2 struct{ *server.Resource }

func WrapZwpTabletPadRingV2(r *server.Resource) *ZwpTabletPadRingV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletPadRingV2{r}
}

const ZwpTabletPadRingV2RequestSetFeedback uint32 = 0
const ZwpTabletPadRingV2RequestDestroy uint32 = 1
const ZwpTabletPadRingV2EventSource uint32 = 0
const ZwpTabletPadRingV2EventAngle uint32 = 1
const ZwpTabletPadRingV2EventStop uint32 = 2
const ZwpTabletPadRingV2EventFrame uint32 = 3

// ZwpTabletPadRingV2Source ring axis source.
type ZwpTabletPadRingV2Source uint32

const (
	ZwpTabletPadRingV2SourceFinger ZwpTabletPadRingV2Source = 1
)

// ZwpTabletPadRingV2Handler handles zwp_tablet_pad_ring_v2 requests.
type ZwpTabletPadRingV2Handler interface {
	SetFeedback(self *ZwpTabletPadRingV2, description string, serial uint32)
	Destroy(self *ZwpTabletPadRingV2)
}

func NewZwpTabletPadRingV2(c server.Client, version int32, id uint32, h ZwpTabletPadRingV2Handler) (*ZwpTabletPadRingV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_pad_ring_v2")
	}
	var self *ZwpTabletPadRingV2
	r, err := c.CreateResource(ZwpTabletPadRingV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.SetFeedback(self, args[0].String(), args[1].Uint())
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletPadRingV2(r)
	r.Data = self
	return self, nil
}

// SendSource ring event source.
func (self *ZwpTabletPadRingV2) SendSource(source uint32) {
	self.PostEvent(ZwpTabletPadRingV2EventSource, server.Uint(source))
}

// SendAngle angle changed.
func (self *ZwpTabletPadRingV2) SendAngle(degrees server.Fixed) {
	self.PostEvent(ZwpTabletPadRingV2EventAngle, server.FixedArg(degrees))
}

// SendStop interaction stopped.
func (self *ZwpTabletPadRingV2) SendStop() {
	self.PostEvent(ZwpTabletPadRingV2EventStop)
}

// SendFrame end of a ring event sequence.
func (self *ZwpTabletPadRingV2) SendFrame(time uint32) {
	self.PostEvent(ZwpTabletPadRingV2EventFrame, server.Uint(time))
}
func NewZwpTabletPadRingV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletPadRingV2Interface, version, bind)
}

// ZwpTabletPadStripV2 pad strip.
type ZwpTabletPadStripV2 struct{ *server.Resource }

func WrapZwpTabletPadStripV2(r *server.Resource) *ZwpTabletPadStripV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletPadStripV2{r}
}

const ZwpTabletPadStripV2RequestSetFeedback uint32 = 0
const ZwpTabletPadStripV2RequestDestroy uint32 = 1
const ZwpTabletPadStripV2EventSource uint32 = 0
const ZwpTabletPadStripV2EventPosition uint32 = 1
const ZwpTabletPadStripV2EventStop uint32 = 2
const ZwpTabletPadStripV2EventFrame uint32 = 3

// ZwpTabletPadStripV2Source strip axis source.
type ZwpTabletPadStripV2Source uint32

const (
	ZwpTabletPadStripV2SourceFinger ZwpTabletPadStripV2Source = 1
)

// ZwpTabletPadStripV2Handler handles zwp_tablet_pad_strip_v2 requests.
type ZwpTabletPadStripV2Handler interface {
	SetFeedback(self *ZwpTabletPadStripV2, description string, serial uint32)
	Destroy(self *ZwpTabletPadStripV2)
}

func NewZwpTabletPadStripV2(c server.Client, version int32, id uint32, h ZwpTabletPadStripV2Handler) (*ZwpTabletPadStripV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_pad_strip_v2")
	}
	var self *ZwpTabletPadStripV2
	r, err := c.CreateResource(ZwpTabletPadStripV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.SetFeedback(self, args[0].String(), args[1].Uint())
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletPadStripV2(r)
	r.Data = self
	return self, nil
}

// SendSource strip event source.
func (self *ZwpTabletPadStripV2) SendSource(source uint32) {
	self.PostEvent(ZwpTabletPadStripV2EventSource, server.Uint(source))
}

// SendPosition position changed.
func (self *ZwpTabletPadStripV2) SendPosition(position uint32) {
	self.PostEvent(ZwpTabletPadStripV2EventPosition, server.Uint(position))
}

// SendStop interaction stopped.
func (self *ZwpTabletPadStripV2) SendStop() {
	self.PostEvent(ZwpTabletPadStripV2EventStop)
}

// SendFrame end of a strip event sequence.
func (self *ZwpTabletPadStripV2) SendFrame(time uint32) {
	self.PostEvent(ZwpTabletPadStripV2EventFrame, server.Uint(time))
}
func NewZwpTabletPadStripV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletPadStripV2Interface, version, bind)
}

// ZwpTabletPadGroupV2 a set of buttons, rings and strips.
type ZwpTabletPadGroupV2 struct{ *server.Resource }

func WrapZwpTabletPadGroupV2(r *server.Resource) *ZwpTabletPadGroupV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletPadGroupV2{r}
}

const ZwpTabletPadGroupV2RequestDestroy uint32 = 0
const ZwpTabletPadGroupV2EventButtons uint32 = 0
const ZwpTabletPadGroupV2EventRing uint32 = 1
const ZwpTabletPadGroupV2EventStrip uint32 = 2
const ZwpTabletPadGroupV2EventModes uint32 = 3
const ZwpTabletPadGroupV2EventDone uint32 = 4
const ZwpTabletPadGroupV2EventModeSwitch uint32 = 5
const ZwpTabletPadGroupV2EventDial uint32 = 6

// ZwpTabletPadGroupV2Handler handles zwp_tablet_pad_group_v2 requests.
type ZwpTabletPadGroupV2Handler interface {
	Destroy(self *ZwpTabletPadGroupV2)
}

func NewZwpTabletPadGroupV2(c server.Client, version int32, id uint32, h ZwpTabletPadGroupV2Handler) (*ZwpTabletPadGroupV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_pad_group_v2")
	}
	var self *ZwpTabletPadGroupV2
	r, err := c.CreateResource(ZwpTabletPadGroupV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletPadGroupV2(r)
	r.Data = self
	return self, nil
}

// SendButtons buttons announced.
func (self *ZwpTabletPadGroupV2) SendButtons(buttons []byte) {
	var p runtime.Pinner
	defer p.Unpin()
	self.PostEvent(ZwpTabletPadGroupV2EventButtons, server.Array(&p, buttons))
}

// SendRing ring announced.
func (self *ZwpTabletPadGroupV2) SendRing(ring *ZwpTabletPadRingV2) {
	self.PostEvent(ZwpTabletPadGroupV2EventRing, server.NewID(resourceOf(ring)))
}

// SendStrip strip announced.
func (self *ZwpTabletPadGroupV2) SendStrip(strip *ZwpTabletPadStripV2) {
	self.PostEvent(ZwpTabletPadGroupV2EventStrip, server.NewID(resourceOf(strip)))
}

// SendModes mode-switch ability announced.
func (self *ZwpTabletPadGroupV2) SendModes(modes uint32) {
	self.PostEvent(ZwpTabletPadGroupV2EventModes, server.Uint(modes))
}

// SendDone tablet group description events sequence complete.
func (self *ZwpTabletPadGroupV2) SendDone() {
	self.PostEvent(ZwpTabletPadGroupV2EventDone)
}

// SendModeSwitch mode switch event.
func (self *ZwpTabletPadGroupV2) SendModeSwitch(time uint32, serial uint32, mode uint32) {
	self.PostEvent(ZwpTabletPadGroupV2EventModeSwitch, server.Uint(time), server.Uint(serial), server.Uint(mode))
}

// SendDial dial announced (since version 2).
func (self *ZwpTabletPadGroupV2) SendDial(dial *ZwpTabletPadDialV2) {
	self.PostEvent(ZwpTabletPadGroupV2EventDial, server.NewID(resourceOf(dial)))
}
func NewZwpTabletPadGroupV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletPadGroupV2Interface, version, bind)
}

// ZwpTabletPadV2 a set of buttons, rings, strips and dials.
type ZwpTabletPadV2 struct{ *server.Resource }

func WrapZwpTabletPadV2(r *server.Resource) *ZwpTabletPadV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletPadV2{r}
}

const ZwpTabletPadV2RequestSetFeedback uint32 = 0
const ZwpTabletPadV2RequestDestroy uint32 = 1
const ZwpTabletPadV2EventGroup uint32 = 0
const ZwpTabletPadV2EventPath uint32 = 1
const ZwpTabletPadV2EventButtons uint32 = 2
const ZwpTabletPadV2EventDone uint32 = 3
const ZwpTabletPadV2EventButton uint32 = 4
const ZwpTabletPadV2EventEnter uint32 = 5
const ZwpTabletPadV2EventLeave uint32 = 6
const ZwpTabletPadV2EventRemoved uint32 = 7

// ZwpTabletPadV2ButtonState physical button state.
type ZwpTabletPadV2ButtonState uint32

const (
	ZwpTabletPadV2ButtonStateReleased ZwpTabletPadV2ButtonState = 0
	ZwpTabletPadV2ButtonStatePressed  ZwpTabletPadV2ButtonState = 1
)

// ZwpTabletPadV2Handler handles zwp_tablet_pad_v2 requests.
type ZwpTabletPadV2Handler interface {
	SetFeedback(self *ZwpTabletPadV2, button uint32, description string, serial uint32)
	Destroy(self *ZwpTabletPadV2)
}

func NewZwpTabletPadV2(c server.Client, version int32, id uint32, h ZwpTabletPadV2Handler) (*ZwpTabletPadV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_pad_v2")
	}
	var self *ZwpTabletPadV2
	r, err := c.CreateResource(ZwpTabletPadV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.SetFeedback(self, args[0].Uint(), args[1].String(), args[2].Uint())
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletPadV2(r)
	r.Data = self
	return self, nil
}

// SendGroup group announced.
func (self *ZwpTabletPadV2) SendGroup(padGroup *ZwpTabletPadGroupV2) {
	self.PostEvent(ZwpTabletPadV2EventGroup, server.NewID(resourceOf(padGroup)))
}

// SendPath path to the device.
func (self *ZwpTabletPadV2) SendPath(path string) {
	var p runtime.Pinner
	defer p.Unpin()
	self.PostEvent(ZwpTabletPadV2EventPath, server.String(&p, path, false))
}

// SendButtons buttons announced.
func (self *ZwpTabletPadV2) SendButtons(buttons uint32) {
	self.PostEvent(ZwpTabletPadV2EventButtons, server.Uint(buttons))
}

// SendDone pad description event sequence complete.
func (self *ZwpTabletPadV2) SendDone() {
	self.PostEvent(ZwpTabletPadV2EventDone)
}

// SendButton physical button state.
func (self *ZwpTabletPadV2) SendButton(time uint32, button uint32, state uint32) {
	self.PostEvent(ZwpTabletPadV2EventButton, server.Uint(time), server.Uint(button), server.Uint(state))
}

// SendEnter enter event.
func (self *ZwpTabletPadV2) SendEnter(serial uint32, tablet *ZwpTabletV2, surface *wayland.Surface) {
	self.PostEvent(ZwpTabletPadV2EventEnter, server.Uint(serial), server.Object(resourceOf(tablet)), server.Object(resourceOf(surface)))
}

// SendLeave leave event.
func (self *ZwpTabletPadV2) SendLeave(serial uint32, surface *wayland.Surface) {
	self.PostEvent(ZwpTabletPadV2EventLeave, server.Uint(serial), server.Object(resourceOf(surface)))
}

// SendRemoved pad removed event.
func (self *ZwpTabletPadV2) SendRemoved() {
	self.PostEvent(ZwpTabletPadV2EventRemoved)
}
func NewZwpTabletPadV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletPadV2Interface, version, bind)
}

// ZwpTabletPadDialV2 pad dial.
type ZwpTabletPadDialV2 struct{ *server.Resource }

func WrapZwpTabletPadDialV2(r *server.Resource) *ZwpTabletPadDialV2 {
	if r == nil {
		return nil
	}
	return &ZwpTabletPadDialV2{r}
}

const ZwpTabletPadDialV2RequestSetFeedback uint32 = 0
const ZwpTabletPadDialV2RequestDestroy uint32 = 1
const ZwpTabletPadDialV2EventDelta uint32 = 0
const ZwpTabletPadDialV2EventFrame uint32 = 1

// ZwpTabletPadDialV2Handler handles zwp_tablet_pad_dial_v2 requests.
type ZwpTabletPadDialV2Handler interface {
	SetFeedback(self *ZwpTabletPadDialV2, description string, serial uint32)
	Destroy(self *ZwpTabletPadDialV2)
}

func NewZwpTabletPadDialV2(c server.Client, version int32, id uint32, h ZwpTabletPadDialV2Handler) (*ZwpTabletPadDialV2, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for zwp_tablet_pad_dial_v2")
	}
	var self *ZwpTabletPadDialV2
	r, err := c.CreateResource(ZwpTabletPadDialV2Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.SetFeedback(self, args[0].String(), args[1].Uint())
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapZwpTabletPadDialV2(r)
	r.Data = self
	return self, nil
}

// SendDelta delta movement.
func (self *ZwpTabletPadDialV2) SendDelta(value120 int32) {
	self.PostEvent(ZwpTabletPadDialV2EventDelta, server.Int(value120))
}

// SendFrame end of a dial event sequence.
func (self *ZwpTabletPadDialV2) SendFrame(time uint32) {
	self.PostEvent(ZwpTabletPadDialV2EventFrame, server.Uint(time))
}
func NewZwpTabletPadDialV2Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ZwpTabletPadDialV2Interface, version, bind)
}
func resourceOf(v interface{ GetResource() *server.Resource }) *server.Resource {
	if v == nil {
		return nil
	}
	return v.GetResource()
}
func (self *ZwpTabletManagerV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletSeatV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletToolV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletPadRingV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletPadStripV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletPadGroupV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletPadV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ZwpTabletPadDialV2) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}