// Code generated by wlgen; DO NOT EDIT.
package extimagecopycapture

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

var ExtImageCopyCaptureManagerV1Interface *server.Interface
var ExtImageCopyCaptureSessionV1Interface *server.Interface
var ExtImageCopyCaptureFrameV1Interface *server.Interface
var ExtImageCopyCaptureCursorSessionV1Interface *server.Interface

func init() {
	ExtImageCopyCaptureManagerV1Interface = &server.Interface{Name: "ext_image_copy_capture_manager_v1", Version: 1}
	ExtImageCopyCaptureSessionV1Interface = &server.Interface{Name: "ext_image_copy_capture_session_v1", Version: 1}
	ExtImageCopyCaptureFrameV1Interface = &server.Interface{Name: "ext_image_copy_capture_frame_v1", Version: 1}
	ExtImageCopyCaptureCursorSessionV1Interface = &server.Interface{Name: "ext_image_copy_capture_cursor_session_v1", Version: 1}
	ExtImageCopyCaptureManagerV1Interface.Requests = []server.Message{
		{Name: "create_session", Signature: "nou", Types: []*server.Interface{ExtImageCopyCaptureSessionV1Interface, extimagecapturesource.ExtImageCaptureSourceV1Interface, nil}},
		{Name: "create_pointer_cursor_session", Signature: "noo", Types: []*server.Interface{ExtImageCopyCaptureCursorSessionV1Interface, extimagecapturesource.ExtImageCaptureSourceV1Interface, wayland.PointerInterface}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ExtImageCopyCaptureManagerV1Interface.Events = []server.Message{}
	ExtImageCopyCaptureSessionV1Interface.Requests = []server.Message{
		{Name: "create_frame", Signature: "n", Types: []*server.Interface{ExtImageCopyCaptureFrameV1Interface}},
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
	}
	ExtImageCopyCaptureSessionV1Interface.Events = []server.Message{
		{Name: "buffer_size", Signature: "uu", Types: []*server.Interface{nil, nil}},
		{Name: "shm_format", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "dmabuf_device", Signature: "a", Types: []*server.Interface{nil}},
		{Name: "dmabuf_format", Signature: "ua", Types: []*server.Interface{nil, nil}},
		{Name: "done", Signature: "", Types: []*server.Interface{}},
		{Name: "stopped", Signature: "", Types: []*server.Interface{}},
	}
	ExtImageCopyCaptureFrameV1Interface.Requests = []server.Message{
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
		{Name: "attach_buffer", Signature: "o", Types: []*server.Interface{wayland.BufferInterface}},
		{Name: "damage_buffer", Signature: "iiii", Types: []*server.Interface{nil, nil, nil, nil}},
		{Name: "capture", Signature: "", Types: []*server.Interface{}},
	}
	ExtImageCopyCaptureFrameV1Interface.Events = []server.Message{
		{Name: "transform", Signature: "u", Types: []*server.Interface{nil}},
		{Name: "damage", Signature: "iiii", Types: []*server.Interface{nil, nil, nil, nil}},
		{Name: "presentation_time", Signature: "uuu", Types: []*server.Interface{nil, nil, nil}},
		{Name: "ready", Signature: "", Types: []*server.Interface{}},
		{Name: "failed", Signature: "u", Types: []*server.Interface{nil}},
	}
	ExtImageCopyCaptureCursorSessionV1Interface.Requests = []server.Message{
		{Name: "destroy", Signature: "", Types: []*server.Interface{}},
		{Name: "get_capture_session", Signature: "n", Types: []*server.Interface{ExtImageCopyCaptureSessionV1Interface}},
	}
	ExtImageCopyCaptureCursorSessionV1Interface.Events = []server.Message{
		{Name: "enter", Signature: "", Types: []*server.Interface{}},
		{Name: "leave", Signature: "", Types: []*server.Interface{}},
		{Name: "position", Signature: "ii", Types: []*server.Interface{nil, nil}},
		{Name: "hotspot", Signature: "ii", Types: []*server.Interface{nil, nil}},
	}
	if err := server.NewInterfaces(ExtImageCopyCaptureManagerV1Interface, ExtImageCopyCaptureSessionV1Interface, ExtImageCopyCaptureFrameV1Interface, ExtImageCopyCaptureCursorSessionV1Interface); err != nil {
		panic(err)
	}
}

// ExtImageCopyCaptureManagerV1 manager to inform clients and begin capturing.
type ExtImageCopyCaptureManagerV1 struct{ *server.Resource }

func WrapExtImageCopyCaptureManagerV1(r *server.Resource) *ExtImageCopyCaptureManagerV1 {
	if r == nil {
		return nil
	}
	return &ExtImageCopyCaptureManagerV1{r}
}

const ExtImageCopyCaptureManagerV1RequestCreateSession uint32 = 0
const ExtImageCopyCaptureManagerV1RequestCreatePointerCursorSession uint32 = 1
const ExtImageCopyCaptureManagerV1RequestDestroy uint32 = 2

// ExtImageCopyCaptureManagerV1Error .
type ExtImageCopyCaptureManagerV1Error uint32

const (
	ExtImageCopyCaptureManagerV1ErrorInvalidOption ExtImageCopyCaptureManagerV1Error = 1
)

// ExtImageCopyCaptureManagerV1Options  (bitfield).
type ExtImageCopyCaptureManagerV1Options uint32

const (
	ExtImageCopyCaptureManagerV1OptionsPaintCursors ExtImageCopyCaptureManagerV1Options = 1
)

// ExtImageCopyCaptureManagerV1Handler handles ext_image_copy_capture_manager_v1 requests.
type ExtImageCopyCaptureManagerV1Handler interface {
	CreateSession(self *ExtImageCopyCaptureManagerV1, session uint32, source *extimagecapturesource.ExtImageCaptureSourceV1, options uint32)
	CreatePointerCursorSession(self *ExtImageCopyCaptureManagerV1, session uint32, source *extimagecapturesource.ExtImageCaptureSourceV1, pointer *wayland.Pointer)
	Destroy(self *ExtImageCopyCaptureManagerV1)
}

func NewExtImageCopyCaptureManagerV1(c server.Client, version int32, id uint32, h ExtImageCopyCaptureManagerV1Handler) (*ExtImageCopyCaptureManagerV1, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for ext_image_copy_capture_manager_v1")
	}
	var self *ExtImageCopyCaptureManagerV1
	r, err := c.CreateResource(ExtImageCopyCaptureManagerV1Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.CreateSession(self, args[0].NewID(), extimagecapturesource.WrapExtImageCaptureSourceV1(args[1].Resource()), args[2].Uint())
		case 1:
			h.CreatePointerCursorSession(self, args[0].NewID(), extimagecapturesource.WrapExtImageCaptureSourceV1(args[1].Resource()), wayland.WrapPointer(args[2].Resource()))
		case 2:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapExtImageCopyCaptureManagerV1(r)
	r.Data = self
	return self, nil
}
func NewExtImageCopyCaptureManagerV1Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ExtImageCopyCaptureManagerV1Interface, version, bind)
}

// ExtImageCopyCaptureSessionV1 image copy capture session.
type ExtImageCopyCaptureSessionV1 struct{ *server.Resource }

func WrapExtImageCopyCaptureSessionV1(r *server.Resource) *ExtImageCopyCaptureSessionV1 {
	if r == nil {
		return nil
	}
	return &ExtImageCopyCaptureSessionV1{r}
}

const ExtImageCopyCaptureSessionV1RequestCreateFrame uint32 = 0
const ExtImageCopyCaptureSessionV1RequestDestroy uint32 = 1
const ExtImageCopyCaptureSessionV1EventBufferSize uint32 = 0
const ExtImageCopyCaptureSessionV1EventShmFormat uint32 = 1
const ExtImageCopyCaptureSessionV1EventDmabufDevice uint32 = 2
const ExtImageCopyCaptureSessionV1EventDmabufFormat uint32 = 3
const ExtImageCopyCaptureSessionV1EventDone uint32 = 4
const ExtImageCopyCaptureSessionV1EventStopped uint32 = 5

// ExtImageCopyCaptureSessionV1Error .
type ExtImageCopyCaptureSessionV1Error uint32

const (
	ExtImageCopyCaptureSessionV1ErrorDuplicateFrame ExtImageCopyCaptureSessionV1Error = 1
)

// ExtImageCopyCaptureSessionV1Handler handles ext_image_copy_capture_session_v1 requests.
type ExtImageCopyCaptureSessionV1Handler interface {
	CreateFrame(self *ExtImageCopyCaptureSessionV1, frame uint32)
	Destroy(self *ExtImageCopyCaptureSessionV1)
}

func NewExtImageCopyCaptureSessionV1(c server.Client, version int32, id uint32, h ExtImageCopyCaptureSessionV1Handler) (*ExtImageCopyCaptureSessionV1, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for ext_image_copy_capture_session_v1")
	}
	var self *ExtImageCopyCaptureSessionV1
	r, err := c.CreateResource(ExtImageCopyCaptureSessionV1Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.CreateFrame(self, args[0].NewID())
		case 1:
			h.Destroy(self)
			self.Destroy()
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapExtImageCopyCaptureSessionV1(r)
	r.Data = self
	return self, nil
}

// SendBufferSize image capture source dimensions.
func (self *ExtImageCopyCaptureSessionV1) SendBufferSize(width uint32, height uint32) {
	self.PostEvent(ExtImageCopyCaptureSessionV1EventBufferSize, server.Uint(width), server.Uint(height))
}

// SendShmFormat shm buffer format.
func (self *ExtImageCopyCaptureSessionV1) SendShmFormat(format uint32) {
	self.PostEvent(ExtImageCopyCaptureSessionV1EventShmFormat, server.Uint(format))
}

// SendDmabufDevice dma-buf device.
func (self *ExtImageCopyCaptureSessionV1) SendDmabufDevice(device []byte) {
	var p runtime.Pinner
	defer p.Unpin()
	self.PostEvent(ExtImageCopyCaptureSessionV1EventDmabufDevice, server.Array(&p, device))
}

// SendDmabufFormat dma-buf format.
func (self *ExtImageCopyCaptureSessionV1) SendDmabufFormat(format uint32, modifiers []byte) {
	var p runtime.Pinner
	defer p.Unpin()
	self.PostEvent(ExtImageCopyCaptureSessionV1EventDmabufFormat, server.Uint(format), server.Array(&p, modifiers))
}

// SendDone all constraints have been sent.
func (self *ExtImageCopyCaptureSessionV1) SendDone() {
	self.PostEvent(ExtImageCopyCaptureSessionV1EventDone)
}

// SendStopped session is no longer available.
func (self *ExtImageCopyCaptureSessionV1) SendStopped() {
	self.PostEvent(ExtImageCopyCaptureSessionV1EventStopped)
}
func NewExtImageCopyCaptureSessionV1Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ExtImageCopyCaptureSessionV1Interface, version, bind)
}

// ExtImageCopyCaptureFrameV1 image capture frame.
type ExtImageCopyCaptureFrameV1 struct{ *server.Resource }

func WrapExtImageCopyCaptureFrameV1(r *server.Resource) *ExtImageCopyCaptureFrameV1 {
	if r == nil {
		return nil
	}
	return &ExtImageCopyCaptureFrameV1{r}
}

const ExtImageCopyCaptureFrameV1RequestDestroy uint32 = 0
const ExtImageCopyCaptureFrameV1RequestAttachBuffer uint32 = 1
const ExtImageCopyCaptureFrameV1RequestDamageBuffer uint32 = 2
const ExtImageCopyCaptureFrameV1RequestCapture uint32 = 3
const ExtImageCopyCaptureFrameV1EventTransform uint32 = 0
const ExtImageCopyCaptureFrameV1EventDamage uint32 = 1
const ExtImageCopyCaptureFrameV1EventPresentationTime uint32 = 2
const ExtImageCopyCaptureFrameV1EventReady uint32 = 3
const ExtImageCopyCaptureFrameV1EventFailed uint32 = 4

// ExtImageCopyCaptureFrameV1Error .
type ExtImageCopyCaptureFrameV1Error uint32

const (
	ExtImageCopyCaptureFrameV1ErrorNoBuffer            ExtImageCopyCaptureFrameV1Error = 1
	ExtImageCopyCaptureFrameV1ErrorInvalidBufferDamage ExtImageCopyCaptureFrameV1Error = 2
	ExtImageCopyCaptureFrameV1ErrorAlreadyCaptured     ExtImageCopyCaptureFrameV1Error = 3
)

// ExtImageCopyCaptureFrameV1FailureReason .
type ExtImageCopyCaptureFrameV1FailureReason uint32

const (
	ExtImageCopyCaptureFrameV1FailureReasonUnknown           ExtImageCopyCaptureFrameV1FailureReason = 0
	ExtImageCopyCaptureFrameV1FailureReasonBufferConstraints ExtImageCopyCaptureFrameV1FailureReason = 1
	ExtImageCopyCaptureFrameV1FailureReasonStopped           ExtImageCopyCaptureFrameV1FailureReason = 2
)

// ExtImageCopyCaptureFrameV1Handler handles ext_image_copy_capture_frame_v1 requests.
type ExtImageCopyCaptureFrameV1Handler interface {
	Destroy(self *ExtImageCopyCaptureFrameV1)
	AttachBuffer(self *ExtImageCopyCaptureFrameV1, buffer *wayland.Buffer)
	DamageBuffer(self *ExtImageCopyCaptureFrameV1, x int32, y int32, width int32, height int32)
	Capture(self *ExtImageCopyCaptureFrameV1)
}

func NewExtImageCopyCaptureFrameV1(c server.Client, version int32, id uint32, h ExtImageCopyCaptureFrameV1Handler) (*ExtImageCopyCaptureFrameV1, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for ext_image_copy_capture_frame_v1")
	}
	var self *ExtImageCopyCaptureFrameV1
	r, err := c.CreateResource(ExtImageCopyCaptureFrameV1Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.Destroy(self)
			self.Destroy()
		case 1:
			h.AttachBuffer(self, wayland.WrapBuffer(args[0].Resource()))
		case 2:
			h.DamageBuffer(self, args[0].Int(), args[1].Int(), args[2].Int(), args[3].Int())
		case 3:
			h.Capture(self)
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapExtImageCopyCaptureFrameV1(r)
	r.Data = self
	return self, nil
}

// SendTransform buffer transform.
func (self *ExtImageCopyCaptureFrameV1) SendTransform(transform uint32) {
	self.PostEvent(ExtImageCopyCaptureFrameV1EventTransform, server.Uint(transform))
}

// SendDamage buffer damaged region.
func (self *ExtImageCopyCaptureFrameV1) SendDamage(x int32, y int32, width int32, height int32) {
	self.PostEvent(ExtImageCopyCaptureFrameV1EventDamage, server.Int(x), server.Int(y), server.Int(width), server.Int(height))
}

// SendPresentationTime presentation time of the frame.
func (self *ExtImageCopyCaptureFrameV1) SendPresentationTime(tvSecHi uint32, tvSecLo uint32, tvNsec uint32) {
	self.PostEvent(ExtImageCopyCaptureFrameV1EventPresentationTime, server.Uint(tvSecHi), server.Uint(tvSecLo), server.Uint(tvNsec))
}

// SendReady frame is available for reading.
func (self *ExtImageCopyCaptureFrameV1) SendReady() {
	self.PostEvent(ExtImageCopyCaptureFrameV1EventReady)
}

// SendFailed capture failed.
func (self *ExtImageCopyCaptureFrameV1) SendFailed(reason uint32) {
	self.PostEvent(ExtImageCopyCaptureFrameV1EventFailed, server.Uint(reason))
}
func NewExtImageCopyCaptureFrameV1Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ExtImageCopyCaptureFrameV1Interface, version, bind)
}

// ExtImageCopyCaptureCursorSessionV1 cursor capture session.
type ExtImageCopyCaptureCursorSessionV1 struct{ *server.Resource }

func WrapExtImageCopyCaptureCursorSessionV1(r *server.Resource) *ExtImageCopyCaptureCursorSessionV1 {
	if r == nil {
		return nil
	}
	return &ExtImageCopyCaptureCursorSessionV1{r}
}

const ExtImageCopyCaptureCursorSessionV1RequestDestroy uint32 = 0
const ExtImageCopyCaptureCursorSessionV1RequestGetCaptureSession uint32 = 1
const ExtImageCopyCaptureCursorSessionV1EventEnter uint32 = 0
const ExtImageCopyCaptureCursorSessionV1EventLeave uint32 = 1
const ExtImageCopyCaptureCursorSessionV1EventPosition uint32 = 2
const ExtImageCopyCaptureCursorSessionV1EventHotspot uint32 = 3

// ExtImageCopyCaptureCursorSessionV1Error .
type ExtImageCopyCaptureCursorSessionV1Error uint32

const (
	ExtImageCopyCaptureCursorSessionV1ErrorDuplicateSession ExtImageCopyCaptureCursorSessionV1Error = 1
)

// ExtImageCopyCaptureCursorSessionV1Handler handles ext_image_copy_capture_cursor_session_v1 requests.
type ExtImageCopyCaptureCursorSessionV1Handler interface {
	Destroy(self *ExtImageCopyCaptureCursorSessionV1)
	GetCaptureSession(self *ExtImageCopyCaptureCursorSessionV1, session uint32)
}

func NewExtImageCopyCaptureCursorSessionV1(c server.Client, version int32, id uint32, h ExtImageCopyCaptureCursorSessionV1Handler) (*ExtImageCopyCaptureCursorSessionV1, error) {
	if h == nil {
		return nil, fmt.Errorf("purego-libwayland: nil handler for ext_image_copy_capture_cursor_session_v1")
	}
	var self *ExtImageCopyCaptureCursorSessionV1
	r, err := c.CreateResource(ExtImageCopyCaptureCursorSessionV1Interface, version, id, func(_ *server.Resource, opcode uint32, args []server.Arg) {
		switch opcode {
		case 0:
			h.Destroy(self)
			self.Destroy()
		case 1:
			h.GetCaptureSession(self, args[0].NewID())
		}
	})
	if err != nil {
		return nil, err
	}
	self = WrapExtImageCopyCaptureCursorSessionV1(r)
	r.Data = self
	return self, nil
}

// SendEnter cursor entered captured area.
func (self *ExtImageCopyCaptureCursorSessionV1) SendEnter() {
	self.PostEvent(ExtImageCopyCaptureCursorSessionV1EventEnter)
}

// SendLeave cursor left captured area.
func (self *ExtImageCopyCaptureCursorSessionV1) SendLeave() {
	self.PostEvent(ExtImageCopyCaptureCursorSessionV1EventLeave)
}

// SendPosition position changed.
func (self *ExtImageCopyCaptureCursorSessionV1) SendPosition(x int32, y int32) {
	self.PostEvent(ExtImageCopyCaptureCursorSessionV1EventPosition, server.Int(x), server.Int(y))
}

// SendHotspot hotspot changed.
func (self *ExtImageCopyCaptureCursorSessionV1) SendHotspot(x int32, y int32) {
	self.PostEvent(ExtImageCopyCaptureCursorSessionV1EventHotspot, server.Int(x), server.Int(y))
}
func NewExtImageCopyCaptureCursorSessionV1Global(d *server.Display, version int32, bind server.BindFunc) error {
	return d.CreateGlobal(ExtImageCopyCaptureCursorSessionV1Interface, version, bind)
}
func resourceOf(v interface{ GetResource() *server.Resource }) *server.Resource {
	if v == nil {
		return nil
	}
	return v.GetResource()
}
func (self *ExtImageCopyCaptureManagerV1) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ExtImageCopyCaptureSessionV1) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ExtImageCopyCaptureFrameV1) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}
func (self *ExtImageCopyCaptureCursorSessionV1) GetResource() *server.Resource {
	if self == nil {
		return nil
	}
	return self.Resource
}