package qt6

/*

#include "gen_qevent.h"
#include <stdlib.h>

*/
import "C"

import (
	"runtime"
	"runtime/cgo"
	"unsafe"
)

type QWheelEvent__ int

const (
	QWheelEvent__DefaultDeltasPerStep QWheelEvent__ = 120
)

type QPlatformSurfaceEvent__SurfaceEventType int

const (
	QPlatformSurfaceEvent__SurfaceCreated            QPlatformSurfaceEvent__SurfaceEventType = 0
	QPlatformSurfaceEvent__SurfaceAboutToBeDestroyed QPlatformSurfaceEvent__SurfaceEventType = 1
)

type QContextMenuEvent__Reason int

const (
	QContextMenuEvent__Mouse    QContextMenuEvent__Reason = 0
	QContextMenuEvent__Keyboard QContextMenuEvent__Reason = 1
	QContextMenuEvent__Other    QContextMenuEvent__Reason = 2
)

type QInputMethodEvent__AttributeType int

const (
	QInputMethodEvent__TextFormat QInputMethodEvent__AttributeType = 0
	QInputMethodEvent__Cursor     QInputMethodEvent__AttributeType = 1
	QInputMethodEvent__Language   QInputMethodEvent__AttributeType = 2
	QInputMethodEvent__Ruby       QInputMethodEvent__AttributeType = 3
	QInputMethodEvent__Selection  QInputMethodEvent__AttributeType = 4
)

type QScrollEvent__ScrollState int

const (
	QScrollEvent__ScrollStarted  QScrollEvent__ScrollState = 0
	QScrollEvent__ScrollUpdated  QScrollEvent__ScrollState = 1
	QScrollEvent__ScrollFinished QScrollEvent__ScrollState = 2
)

type QInputEvent struct {
	h          *C.QInputEvent
	isSubclass bool
	*QEvent
}

func (this *QInputEvent) cPointer() *C.QInputEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QInputEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQInputEvent constructs the type using only CGO pointers.
func newQInputEvent(h *C.QInputEvent, h_QEvent *C.QEvent) *QInputEvent {
	if h == nil {
		return nil
	}
	return &QInputEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQInputEvent constructs the type using only unsafe pointers.
func UnsafeNewQInputEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QInputEvent {
	if h == nil {
		return nil
	}

	return &QInputEvent{h: (*C.QInputEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQInputEvent constructs a new QInputEvent object.
func NewQInputEvent(typeVal QEvent__Type, m_dev *QInputDevice) *QInputEvent {
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QInputEvent_new((C.int)(typeVal), m_dev.cPointer(), &outptr_QInputEvent, &outptr_QEvent)
	ret := newQInputEvent(outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQInputEvent2 constructs a new QInputEvent object.
func NewQInputEvent2(typeVal QEvent__Type, m_dev *QInputDevice, modifiers KeyboardModifier) *QInputEvent {
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QInputEvent_new2((C.int)(typeVal), m_dev.cPointer(), (C.int)(modifiers), &outptr_QInputEvent, &outptr_QEvent)
	ret := newQInputEvent(outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QInputEvent) Clone() *QInputEvent {
	return UnsafeNewQInputEvent(unsafe.Pointer(C.QInputEvent_Clone(this.h)), nil)
}

func (this *QInputEvent) Device() *QInputDevice {
	return UnsafeNewQInputDevice(unsafe.Pointer(C.QInputEvent_Device(this.h)), nil)
}

func (this *QInputEvent) DeviceType() QInputDevice__DeviceType {
	return (QInputDevice__DeviceType)(C.QInputEvent_DeviceType(this.h))
}

func (this *QInputEvent) Modifiers() KeyboardModifier {
	return (KeyboardModifier)(C.QInputEvent_Modifiers(this.h))
}

func (this *QInputEvent) SetModifiers(modifiers KeyboardModifier) {
	C.QInputEvent_SetModifiers(this.h, (C.int)(modifiers))
}

func (this *QInputEvent) Timestamp() uint64 {
	return (uint64)(C.QInputEvent_Timestamp(this.h))
}

func (this *QInputEvent) SetTimestamp(timestamp uint64) {
	C.QInputEvent_SetTimestamp(this.h, (C.ulonglong)(timestamp))
}

func (this *QInputEvent) callVirtualBase_Clone() *QInputEvent {

	return UnsafeNewQInputEvent(unsafe.Pointer(C.QInputEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QInputEvent) OnClone(slot func(super func() *QInputEvent) *QInputEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputEvent_Clone
func miqt_exec_callback_QInputEvent_Clone(self *C.QInputEvent, cb C.intptr_t) *C.QInputEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QInputEvent) *QInputEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QInputEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QInputEvent) callVirtualBase_SetTimestamp(timestamp uint64) {

	C.QInputEvent_virtualbase_SetTimestamp(unsafe.Pointer(this.h), (C.ulonglong)(timestamp))

}
func (this *QInputEvent) OnSetTimestamp(slot func(super func(timestamp uint64), timestamp uint64)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputEvent_override_virtual_SetTimestamp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputEvent_SetTimestamp
func miqt_exec_callback_QInputEvent_SetTimestamp(self *C.QInputEvent, cb C.intptr_t, timestamp C.ulonglong) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(timestamp uint64), timestamp uint64))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (uint64)(timestamp)

	gofunc((&QInputEvent{h: self}).callVirtualBase_SetTimestamp, slotval1)

}

func (this *QInputEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QInputEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QInputEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputEvent_SetAccepted
func miqt_exec_callback_QInputEvent_SetAccepted(self *C.QInputEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QInputEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QInputEvent) Delete() {
	C.QInputEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QInputEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QInputEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QPointerEvent struct {
	h          *C.QPointerEvent
	isSubclass bool
	*QInputEvent
}

func (this *QPointerEvent) cPointer() *C.QPointerEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QPointerEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQPointerEvent constructs the type using only CGO pointers.
func newQPointerEvent(h *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QPointerEvent {
	if h == nil {
		return nil
	}
	return &QPointerEvent{h: h,
		QInputEvent: newQInputEvent(h_QInputEvent, h_QEvent)}
}

// UnsafeNewQPointerEvent constructs the type using only unsafe pointers.
func UnsafeNewQPointerEvent(h unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QPointerEvent {
	if h == nil {
		return nil
	}

	return &QPointerEvent{h: (*C.QPointerEvent)(h),
		QInputEvent: UnsafeNewQInputEvent(h_QInputEvent, h_QEvent)}
}

// NewQPointerEvent constructs a new QPointerEvent object.
func NewQPointerEvent(typeVal QEvent__Type, dev *QPointingDevice) *QPointerEvent {
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QPointerEvent_new((C.int)(typeVal), dev.cPointer(), &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQPointerEvent(outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQPointerEvent2 constructs a new QPointerEvent object.
func NewQPointerEvent2(typeVal QEvent__Type, dev *QPointingDevice, modifiers KeyboardModifier) *QPointerEvent {
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QPointerEvent_new2((C.int)(typeVal), dev.cPointer(), (C.int)(modifiers), &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQPointerEvent(outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQPointerEvent3 constructs a new QPointerEvent object.
func NewQPointerEvent3(typeVal QEvent__Type, dev *QPointingDevice, modifiers KeyboardModifier, points []QEventPoint) *QPointerEvent {
	points_CArray := (*[0xffff]*C.QEventPoint)(C.malloc(C.size_t(8 * len(points))))
	defer C.free(unsafe.Pointer(points_CArray))
	for i := range points {
		points_CArray[i] = points[i].cPointer()
	}
	points_ma := C.struct_miqt_array{len: C.size_t(len(points)), data: unsafe.Pointer(points_CArray)}
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QPointerEvent_new3((C.int)(typeVal), dev.cPointer(), (C.int)(modifiers), points_ma, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQPointerEvent(outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QPointerEvent) Clone() *QPointerEvent {
	return UnsafeNewQPointerEvent(unsafe.Pointer(C.QPointerEvent_Clone(this.h)), nil, nil)
}

func (this *QPointerEvent) PointingDevice() *QPointingDevice {
	return UnsafeNewQPointingDevice(unsafe.Pointer(C.QPointerEvent_PointingDevice(this.h)), nil, nil)
}

func (this *QPointerEvent) PointerType() QPointingDevice__PointerType {
	return (QPointingDevice__PointerType)(C.QPointerEvent_PointerType(this.h))
}

func (this *QPointerEvent) SetTimestamp(timestamp uint64) {
	C.QPointerEvent_SetTimestamp(this.h, (C.ulonglong)(timestamp))
}

func (this *QPointerEvent) PointCount() int64 {
	return (int64)(C.QPointerEvent_PointCount(this.h))
}

func (this *QPointerEvent) Point(i int64) *QEventPoint {
	return UnsafeNewQEventPoint(unsafe.Pointer(C.QPointerEvent_Point(this.h, (C.ptrdiff_t)(i))))
}

func (this *QPointerEvent) Points() []QEventPoint {
	var _ma C.struct_miqt_array = C.QPointerEvent_Points(this.h)
	_ret := make([]QEventPoint, int(_ma.len))
	_outCast := (*[0xffff]*C.QEventPoint)(unsafe.Pointer(_ma.data)) // hey ya
	for i := 0; i < int(_ma.len); i++ {
		_lv_ret := _outCast[i]
		_lv_goptr := newQEventPoint(_lv_ret)
		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
		_ret[i] = *_lv_goptr
	}
	return _ret
}

func (this *QPointerEvent) PointById(id int) *QEventPoint {
	return UnsafeNewQEventPoint(unsafe.Pointer(C.QPointerEvent_PointById(this.h, (C.int)(id))))
}

func (this *QPointerEvent) AllPointsGrabbed() bool {
	return (bool)(C.QPointerEvent_AllPointsGrabbed(this.h))
}

func (this *QPointerEvent) IsBeginEvent() bool {
	return (bool)(C.QPointerEvent_IsBeginEvent(this.h))
}

func (this *QPointerEvent) IsUpdateEvent() bool {
	return (bool)(C.QPointerEvent_IsUpdateEvent(this.h))
}

func (this *QPointerEvent) IsEndEvent() bool {
	return (bool)(C.QPointerEvent_IsEndEvent(this.h))
}

func (this *QPointerEvent) AllPointsAccepted() bool {
	return (bool)(C.QPointerEvent_AllPointsAccepted(this.h))
}

func (this *QPointerEvent) SetAccepted(accepted bool) {
	C.QPointerEvent_SetAccepted(this.h, (C.bool)(accepted))
}

func (this *QPointerEvent) ExclusiveGrabber(point *QEventPoint) *QObject {
	return UnsafeNewQObject(unsafe.Pointer(C.QPointerEvent_ExclusiveGrabber(this.h, point.cPointer())))
}

func (this *QPointerEvent) SetExclusiveGrabber(point *QEventPoint, exclusiveGrabber *QObject) {
	C.QPointerEvent_SetExclusiveGrabber(this.h, point.cPointer(), exclusiveGrabber.cPointer())
}

func (this *QPointerEvent) ClearPassiveGrabbers(point *QEventPoint) {
	C.QPointerEvent_ClearPassiveGrabbers(this.h, point.cPointer())
}

func (this *QPointerEvent) AddPassiveGrabber(point *QEventPoint, grabber *QObject) bool {
	return (bool)(C.QPointerEvent_AddPassiveGrabber(this.h, point.cPointer(), grabber.cPointer()))
}

func (this *QPointerEvent) RemovePassiveGrabber(point *QEventPoint, grabber *QObject) bool {
	return (bool)(C.QPointerEvent_RemovePassiveGrabber(this.h, point.cPointer(), grabber.cPointer()))
}

func (this *QPointerEvent) callVirtualBase_Clone() *QPointerEvent {

	return UnsafeNewQPointerEvent(unsafe.Pointer(C.QPointerEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil)
}
func (this *QPointerEvent) OnClone(slot func(super func() *QPointerEvent) *QPointerEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPointerEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPointerEvent_Clone
func miqt_exec_callback_QPointerEvent_Clone(self *C.QPointerEvent, cb C.intptr_t) *C.QPointerEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QPointerEvent) *QPointerEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QPointerEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QPointerEvent) callVirtualBase_SetTimestamp(timestamp uint64) {

	C.QPointerEvent_virtualbase_SetTimestamp(unsafe.Pointer(this.h), (C.ulonglong)(timestamp))

}
func (this *QPointerEvent) OnSetTimestamp(slot func(super func(timestamp uint64), timestamp uint64)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPointerEvent_override_virtual_SetTimestamp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPointerEvent_SetTimestamp
func miqt_exec_callback_QPointerEvent_SetTimestamp(self *C.QPointerEvent, cb C.intptr_t, timestamp C.ulonglong) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(timestamp uint64), timestamp uint64))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (uint64)(timestamp)

	gofunc((&QPointerEvent{h: self}).callVirtualBase_SetTimestamp, slotval1)

}

func (this *QPointerEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QPointerEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QPointerEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPointerEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPointerEvent_IsBeginEvent
func miqt_exec_callback_QPointerEvent_IsBeginEvent(self *C.QPointerEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QPointerEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QPointerEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QPointerEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QPointerEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPointerEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPointerEvent_IsUpdateEvent
func miqt_exec_callback_QPointerEvent_IsUpdateEvent(self *C.QPointerEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QPointerEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QPointerEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QPointerEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QPointerEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPointerEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPointerEvent_IsEndEvent
func miqt_exec_callback_QPointerEvent_IsEndEvent(self *C.QPointerEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QPointerEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

func (this *QPointerEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QPointerEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QPointerEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPointerEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPointerEvent_SetAccepted
func miqt_exec_callback_QPointerEvent_SetAccepted(self *C.QPointerEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QPointerEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QPointerEvent) Delete() {
	C.QPointerEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QPointerEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QPointerEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QSinglePointEvent struct {
	h          *C.QSinglePointEvent
	isSubclass bool
	*QPointerEvent
}

func (this *QSinglePointEvent) cPointer() *C.QSinglePointEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QSinglePointEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQSinglePointEvent constructs the type using only CGO pointers.
func newQSinglePointEvent(h *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QSinglePointEvent {
	if h == nil {
		return nil
	}
	return &QSinglePointEvent{h: h,
		QPointerEvent: newQPointerEvent(h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQSinglePointEvent constructs the type using only unsafe pointers.
func UnsafeNewQSinglePointEvent(h unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QSinglePointEvent {
	if h == nil {
		return nil
	}

	return &QSinglePointEvent{h: (*C.QSinglePointEvent)(h),
		QPointerEvent: UnsafeNewQPointerEvent(h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

func (this *QSinglePointEvent) Clone() *QSinglePointEvent {
	return UnsafeNewQSinglePointEvent(unsafe.Pointer(C.QSinglePointEvent_Clone(this.h)), nil, nil, nil)
}

func (this *QSinglePointEvent) Button() MouseButton {
	return (MouseButton)(C.QSinglePointEvent_Button(this.h))
}

func (this *QSinglePointEvent) Buttons() MouseButton {
	return (MouseButton)(C.QSinglePointEvent_Buttons(this.h))
}

func (this *QSinglePointEvent) Position() *QPointF {
	_ret := C.QSinglePointEvent_Position(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QSinglePointEvent) ScenePosition() *QPointF {
	_ret := C.QSinglePointEvent_ScenePosition(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QSinglePointEvent) GlobalPosition() *QPointF {
	_ret := C.QSinglePointEvent_GlobalPosition(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QSinglePointEvent) IsBeginEvent() bool {
	return (bool)(C.QSinglePointEvent_IsBeginEvent(this.h))
}

func (this *QSinglePointEvent) IsUpdateEvent() bool {
	return (bool)(C.QSinglePointEvent_IsUpdateEvent(this.h))
}

func (this *QSinglePointEvent) IsEndEvent() bool {
	return (bool)(C.QSinglePointEvent_IsEndEvent(this.h))
}

func (this *QSinglePointEvent) ExclusivePointGrabber() *QObject {
	return UnsafeNewQObject(unsafe.Pointer(C.QSinglePointEvent_ExclusivePointGrabber(this.h)))
}

func (this *QSinglePointEvent) SetExclusivePointGrabber(exclusiveGrabber *QObject) {
	C.QSinglePointEvent_SetExclusivePointGrabber(this.h, exclusiveGrabber.cPointer())
}

// Delete this object from C++ memory.
func (this *QSinglePointEvent) Delete() {
	C.QSinglePointEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QSinglePointEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QSinglePointEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QEnterEvent struct {
	h          *C.QEnterEvent
	isSubclass bool
	*QSinglePointEvent
}

func (this *QEnterEvent) cPointer() *C.QEnterEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QEnterEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQEnterEvent constructs the type using only CGO pointers.
func newQEnterEvent(h *C.QEnterEvent, h_QSinglePointEvent *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QEnterEvent {
	if h == nil {
		return nil
	}
	return &QEnterEvent{h: h,
		QSinglePointEvent: newQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQEnterEvent constructs the type using only unsafe pointers.
func UnsafeNewQEnterEvent(h unsafe.Pointer, h_QSinglePointEvent unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QEnterEvent {
	if h == nil {
		return nil
	}

	return &QEnterEvent{h: (*C.QEnterEvent)(h),
		QSinglePointEvent: UnsafeNewQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQEnterEvent constructs a new QEnterEvent object.
func NewQEnterEvent(localPos *QPointF, scenePos *QPointF, globalPos *QPointF) *QEnterEvent {
	var outptr_QEnterEvent *C.QEnterEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QEnterEvent_new(localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), &outptr_QEnterEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQEnterEvent(outptr_QEnterEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQEnterEvent2 constructs a new QEnterEvent object.
func NewQEnterEvent2(localPos *QPointF, scenePos *QPointF, globalPos *QPointF, device *QPointingDevice) *QEnterEvent {
	var outptr_QEnterEvent *C.QEnterEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QEnterEvent_new2(localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), device.cPointer(), &outptr_QEnterEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQEnterEvent(outptr_QEnterEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QEnterEvent) Clone() *QEnterEvent {
	return UnsafeNewQEnterEvent(unsafe.Pointer(C.QEnterEvent_Clone(this.h)), nil, nil, nil, nil)
}

func (this *QEnterEvent) Pos() *QPoint {
	_ret := C.QEnterEvent_Pos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QEnterEvent) GlobalPos() *QPoint {
	_ret := C.QEnterEvent_GlobalPos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QEnterEvent) X() int {
	return (int)(C.QEnterEvent_X(this.h))
}

func (this *QEnterEvent) Y() int {
	return (int)(C.QEnterEvent_Y(this.h))
}

func (this *QEnterEvent) GlobalX() int {
	return (int)(C.QEnterEvent_GlobalX(this.h))
}

func (this *QEnterEvent) GlobalY() int {
	return (int)(C.QEnterEvent_GlobalY(this.h))
}

func (this *QEnterEvent) LocalPos() *QPointF {
	_ret := C.QEnterEvent_LocalPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QEnterEvent) WindowPos() *QPointF {
	_ret := C.QEnterEvent_WindowPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QEnterEvent) ScreenPos() *QPointF {
	_ret := C.QEnterEvent_ScreenPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QEnterEvent) callVirtualBase_Clone() *QEnterEvent {

	return UnsafeNewQEnterEvent(unsafe.Pointer(C.QEnterEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil, nil)
}
func (this *QEnterEvent) OnClone(slot func(super func() *QEnterEvent) *QEnterEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QEnterEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QEnterEvent_Clone
func miqt_exec_callback_QEnterEvent_Clone(self *C.QEnterEvent, cb C.intptr_t) *C.QEnterEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QEnterEvent) *QEnterEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QEnterEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QEnterEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QEnterEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QEnterEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QEnterEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QEnterEvent_IsBeginEvent
func miqt_exec_callback_QEnterEvent_IsBeginEvent(self *C.QEnterEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QEnterEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QEnterEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QEnterEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QEnterEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QEnterEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QEnterEvent_IsUpdateEvent
func miqt_exec_callback_QEnterEvent_IsUpdateEvent(self *C.QEnterEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QEnterEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QEnterEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QEnterEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QEnterEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QEnterEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QEnterEvent_IsEndEvent
func miqt_exec_callback_QEnterEvent_IsEndEvent(self *C.QEnterEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QEnterEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

// Delete this object from C++ memory.
func (this *QEnterEvent) Delete() {
	C.QEnterEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QEnterEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QEnterEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QMouseEvent struct {
	h          *C.QMouseEvent
	isSubclass bool
	*QSinglePointEvent
}

func (this *QMouseEvent) cPointer() *C.QMouseEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QMouseEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQMouseEvent constructs the type using only CGO pointers.
func newQMouseEvent(h *C.QMouseEvent, h_QSinglePointEvent *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QMouseEvent {
	if h == nil {
		return nil
	}
	return &QMouseEvent{h: h,
		QSinglePointEvent: newQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQMouseEvent constructs the type using only unsafe pointers.
func UnsafeNewQMouseEvent(h unsafe.Pointer, h_QSinglePointEvent unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QMouseEvent {
	if h == nil {
		return nil
	}

	return &QMouseEvent{h: (*C.QMouseEvent)(h),
		QSinglePointEvent: UnsafeNewQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQMouseEvent constructs a new QMouseEvent object.
func NewQMouseEvent(typeVal QEvent__Type, localPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new((C.int)(typeVal), localPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent2 constructs a new QMouseEvent object.
func NewQMouseEvent2(typeVal QEvent__Type, localPos *QPointF, globalPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new2((C.int)(typeVal), localPos.cPointer(), globalPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent3 constructs a new QMouseEvent object.
func NewQMouseEvent3(typeVal QEvent__Type, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new3((C.int)(typeVal), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent4 constructs a new QMouseEvent object.
func NewQMouseEvent4(typeVal QEvent__Type, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier, source MouseEventSource) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new4((C.int)(typeVal), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), (C.int)(source), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent5 constructs a new QMouseEvent object.
func NewQMouseEvent5(typeVal QEvent__Type, localPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier, device *QPointingDevice) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new5((C.int)(typeVal), localPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), device.cPointer(), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent6 constructs a new QMouseEvent object.
func NewQMouseEvent6(typeVal QEvent__Type, localPos *QPointF, globalPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier, device *QPointingDevice) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new6((C.int)(typeVal), localPos.cPointer(), globalPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), device.cPointer(), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent7 constructs a new QMouseEvent object.
func NewQMouseEvent7(typeVal QEvent__Type, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier, device *QPointingDevice) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new7((C.int)(typeVal), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), device.cPointer(), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQMouseEvent8 constructs a new QMouseEvent object.
func NewQMouseEvent8(typeVal QEvent__Type, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, button MouseButton, buttons MouseButton, modifiers KeyboardModifier, source MouseEventSource, device *QPointingDevice) *QMouseEvent {
	var outptr_QMouseEvent *C.QMouseEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMouseEvent_new8((C.int)(typeVal), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.int)(button), (C.int)(buttons), (C.int)(modifiers), (C.int)(source), device.cPointer(), &outptr_QMouseEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQMouseEvent(outptr_QMouseEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QMouseEvent) Clone() *QMouseEvent {
	return UnsafeNewQMouseEvent(unsafe.Pointer(C.QMouseEvent_Clone(this.h)), nil, nil, nil, nil)
}

func (this *QMouseEvent) Pos() *QPoint {
	_ret := C.QMouseEvent_Pos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QMouseEvent) GlobalPos() *QPoint {
	_ret := C.QMouseEvent_GlobalPos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QMouseEvent) X() int {
	return (int)(C.QMouseEvent_X(this.h))
}

func (this *QMouseEvent) Y() int {
	return (int)(C.QMouseEvent_Y(this.h))
}

func (this *QMouseEvent) GlobalX() int {
	return (int)(C.QMouseEvent_GlobalX(this.h))
}

func (this *QMouseEvent) GlobalY() int {
	return (int)(C.QMouseEvent_GlobalY(this.h))
}

func (this *QMouseEvent) LocalPos() *QPointF {
	_ret := C.QMouseEvent_LocalPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QMouseEvent) WindowPos() *QPointF {
	_ret := C.QMouseEvent_WindowPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QMouseEvent) ScreenPos() *QPointF {
	_ret := C.QMouseEvent_ScreenPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QMouseEvent) Source() MouseEventSource {
	return (MouseEventSource)(C.QMouseEvent_Source(this.h))
}

func (this *QMouseEvent) Flags() MouseEventFlag {
	return (MouseEventFlag)(C.QMouseEvent_Flags(this.h))
}

func (this *QMouseEvent) callVirtualBase_Clone() *QMouseEvent {

	return UnsafeNewQMouseEvent(unsafe.Pointer(C.QMouseEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil, nil)
}
func (this *QMouseEvent) OnClone(slot func(super func() *QMouseEvent) *QMouseEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QMouseEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QMouseEvent_Clone
func miqt_exec_callback_QMouseEvent_Clone(self *C.QMouseEvent, cb C.intptr_t) *C.QMouseEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QMouseEvent) *QMouseEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QMouseEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QMouseEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QMouseEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QMouseEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QMouseEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QMouseEvent_IsBeginEvent
func miqt_exec_callback_QMouseEvent_IsBeginEvent(self *C.QMouseEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QMouseEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QMouseEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QMouseEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QMouseEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QMouseEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QMouseEvent_IsUpdateEvent
func miqt_exec_callback_QMouseEvent_IsUpdateEvent(self *C.QMouseEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QMouseEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QMouseEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QMouseEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QMouseEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QMouseEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QMouseEvent_IsEndEvent
func miqt_exec_callback_QMouseEvent_IsEndEvent(self *C.QMouseEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QMouseEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

// Delete this object from C++ memory.
func (this *QMouseEvent) Delete() {
	C.QMouseEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMouseEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QMouseEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QHoverEvent struct {
	h          *C.QHoverEvent
	isSubclass bool
	*QSinglePointEvent
}

func (this *QHoverEvent) cPointer() *C.QHoverEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QHoverEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQHoverEvent constructs the type using only CGO pointers.
func newQHoverEvent(h *C.QHoverEvent, h_QSinglePointEvent *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QHoverEvent {
	if h == nil {
		return nil
	}
	return &QHoverEvent{h: h,
		QSinglePointEvent: newQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQHoverEvent constructs the type using only unsafe pointers.
func UnsafeNewQHoverEvent(h unsafe.Pointer, h_QSinglePointEvent unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QHoverEvent {
	if h == nil {
		return nil
	}

	return &QHoverEvent{h: (*C.QHoverEvent)(h),
		QSinglePointEvent: UnsafeNewQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQHoverEvent constructs a new QHoverEvent object.
func NewQHoverEvent(typeVal QEvent__Type, scenePos *QPointF, globalPos *QPointF, oldPos *QPointF) *QHoverEvent {
	var outptr_QHoverEvent *C.QHoverEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHoverEvent_new((C.int)(typeVal), scenePos.cPointer(), globalPos.cPointer(), oldPos.cPointer(), &outptr_QHoverEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQHoverEvent(outptr_QHoverEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQHoverEvent2 constructs a new QHoverEvent object.
func NewQHoverEvent2(typeVal QEvent__Type, pos *QPointF, oldPos *QPointF) *QHoverEvent {
	var outptr_QHoverEvent *C.QHoverEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHoverEvent_new2((C.int)(typeVal), pos.cPointer(), oldPos.cPointer(), &outptr_QHoverEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQHoverEvent(outptr_QHoverEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQHoverEvent3 constructs a new QHoverEvent object.
func NewQHoverEvent3(typeVal QEvent__Type, scenePos *QPointF, globalPos *QPointF, oldPos *QPointF, modifiers KeyboardModifier) *QHoverEvent {
	var outptr_QHoverEvent *C.QHoverEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHoverEvent_new3((C.int)(typeVal), scenePos.cPointer(), globalPos.cPointer(), oldPos.cPointer(), (C.int)(modifiers), &outptr_QHoverEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQHoverEvent(outptr_QHoverEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQHoverEvent4 constructs a new QHoverEvent object.
func NewQHoverEvent4(typeVal QEvent__Type, scenePos *QPointF, globalPos *QPointF, oldPos *QPointF, modifiers KeyboardModifier, device *QPointingDevice) *QHoverEvent {
	var outptr_QHoverEvent *C.QHoverEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHoverEvent_new4((C.int)(typeVal), scenePos.cPointer(), globalPos.cPointer(), oldPos.cPointer(), (C.int)(modifiers), device.cPointer(), &outptr_QHoverEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQHoverEvent(outptr_QHoverEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQHoverEvent5 constructs a new QHoverEvent object.
func NewQHoverEvent5(typeVal QEvent__Type, pos *QPointF, oldPos *QPointF, modifiers KeyboardModifier) *QHoverEvent {
	var outptr_QHoverEvent *C.QHoverEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHoverEvent_new5((C.int)(typeVal), pos.cPointer(), oldPos.cPointer(), (C.int)(modifiers), &outptr_QHoverEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQHoverEvent(outptr_QHoverEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQHoverEvent6 constructs a new QHoverEvent object.
func NewQHoverEvent6(typeVal QEvent__Type, pos *QPointF, oldPos *QPointF, modifiers KeyboardModifier, device *QPointingDevice) *QHoverEvent {
	var outptr_QHoverEvent *C.QHoverEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHoverEvent_new6((C.int)(typeVal), pos.cPointer(), oldPos.cPointer(), (C.int)(modifiers), device.cPointer(), &outptr_QHoverEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQHoverEvent(outptr_QHoverEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QHoverEvent) Clone() *QHoverEvent {
	return UnsafeNewQHoverEvent(unsafe.Pointer(C.QHoverEvent_Clone(this.h)), nil, nil, nil, nil)
}

func (this *QHoverEvent) Pos() *QPoint {
	_ret := C.QHoverEvent_Pos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QHoverEvent) PosF() *QPointF {
	_ret := C.QHoverEvent_PosF(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QHoverEvent) IsUpdateEvent() bool {
	return (bool)(C.QHoverEvent_IsUpdateEvent(this.h))
}

func (this *QHoverEvent) OldPos() *QPoint {
	_ret := C.QHoverEvent_OldPos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QHoverEvent) OldPosF() *QPointF {
	_ret := C.QHoverEvent_OldPosF(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QHoverEvent) callVirtualBase_Clone() *QHoverEvent {

	return UnsafeNewQHoverEvent(unsafe.Pointer(C.QHoverEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil, nil)
}
func (this *QHoverEvent) OnClone(slot func(super func() *QHoverEvent) *QHoverEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHoverEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHoverEvent_Clone
func miqt_exec_callback_QHoverEvent_Clone(self *C.QHoverEvent, cb C.intptr_t) *C.QHoverEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QHoverEvent) *QHoverEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QHoverEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QHoverEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QHoverEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QHoverEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHoverEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHoverEvent_IsUpdateEvent
func miqt_exec_callback_QHoverEvent_IsUpdateEvent(self *C.QHoverEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QHoverEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QHoverEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QHoverEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QHoverEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHoverEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHoverEvent_IsBeginEvent
func miqt_exec_callback_QHoverEvent_IsBeginEvent(self *C.QHoverEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QHoverEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QHoverEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QHoverEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QHoverEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHoverEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHoverEvent_IsEndEvent
func miqt_exec_callback_QHoverEvent_IsEndEvent(self *C.QHoverEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QHoverEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

// Delete this object from C++ memory.
func (this *QHoverEvent) Delete() {
	C.QHoverEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QHoverEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QHoverEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QWheelEvent struct {
	h          *C.QWheelEvent
	isSubclass bool
	*QSinglePointEvent
}

func (this *QWheelEvent) cPointer() *C.QWheelEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QWheelEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQWheelEvent constructs the type using only CGO pointers.
func newQWheelEvent(h *C.QWheelEvent, h_QSinglePointEvent *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QWheelEvent {
	if h == nil {
		return nil
	}
	return &QWheelEvent{h: h,
		QSinglePointEvent: newQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQWheelEvent constructs the type using only unsafe pointers.
func UnsafeNewQWheelEvent(h unsafe.Pointer, h_QSinglePointEvent unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QWheelEvent {
	if h == nil {
		return nil
	}

	return &QWheelEvent{h: (*C.QWheelEvent)(h),
		QSinglePointEvent: UnsafeNewQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQWheelEvent constructs a new QWheelEvent object.
func NewQWheelEvent(pos *QPointF, globalPos *QPointF, pixelDelta QPoint, angleDelta QPoint, buttons MouseButton, modifiers KeyboardModifier, phase ScrollPhase, inverted bool) *QWheelEvent {
	var outptr_QWheelEvent *C.QWheelEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QWheelEvent_new(pos.cPointer(), globalPos.cPointer(), pixelDelta.cPointer(), angleDelta.cPointer(), (C.int)(buttons), (C.int)(modifiers), (C.int)(phase), (C.bool)(inverted), &outptr_QWheelEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQWheelEvent(outptr_QWheelEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQWheelEvent2 constructs a new QWheelEvent object.
func NewQWheelEvent2(pos *QPointF, globalPos *QPointF, pixelDelta QPoint, angleDelta QPoint, buttons MouseButton, modifiers KeyboardModifier, phase ScrollPhase, inverted bool, source MouseEventSource) *QWheelEvent {
	var outptr_QWheelEvent *C.QWheelEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QWheelEvent_new2(pos.cPointer(), globalPos.cPointer(), pixelDelta.cPointer(), angleDelta.cPointer(), (C.int)(buttons), (C.int)(modifiers), (C.int)(phase), (C.bool)(inverted), (C.int)(source), &outptr_QWheelEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQWheelEvent(outptr_QWheelEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQWheelEvent3 constructs a new QWheelEvent object.
func NewQWheelEvent3(pos *QPointF, globalPos *QPointF, pixelDelta QPoint, angleDelta QPoint, buttons MouseButton, modifiers KeyboardModifier, phase ScrollPhase, inverted bool, source MouseEventSource, device *QPointingDevice) *QWheelEvent {
	var outptr_QWheelEvent *C.QWheelEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QWheelEvent_new3(pos.cPointer(), globalPos.cPointer(), pixelDelta.cPointer(), angleDelta.cPointer(), (C.int)(buttons), (C.int)(modifiers), (C.int)(phase), (C.bool)(inverted), (C.int)(source), device.cPointer(), &outptr_QWheelEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQWheelEvent(outptr_QWheelEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QWheelEvent) Clone() *QWheelEvent {
	return UnsafeNewQWheelEvent(unsafe.Pointer(C.QWheelEvent_Clone(this.h)), nil, nil, nil, nil)
}

func (this *QWheelEvent) PixelDelta() *QPoint {
	_ret := C.QWheelEvent_PixelDelta(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QWheelEvent) AngleDelta() *QPoint {
	_ret := C.QWheelEvent_AngleDelta(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QWheelEvent) Phase() ScrollPhase {
	return (ScrollPhase)(C.QWheelEvent_Phase(this.h))
}

func (this *QWheelEvent) Inverted() bool {
	return (bool)(C.QWheelEvent_Inverted(this.h))
}

func (this *QWheelEvent) IsInverted() bool {
	return (bool)(C.QWheelEvent_IsInverted(this.h))
}

func (this *QWheelEvent) HasPixelDelta() bool {
	return (bool)(C.QWheelEvent_HasPixelDelta(this.h))
}

func (this *QWheelEvent) IsBeginEvent() bool {
	return (bool)(C.QWheelEvent_IsBeginEvent(this.h))
}

func (this *QWheelEvent) IsUpdateEvent() bool {
	return (bool)(C.QWheelEvent_IsUpdateEvent(this.h))
}

func (this *QWheelEvent) IsEndEvent() bool {
	return (bool)(C.QWheelEvent_IsEndEvent(this.h))
}

func (this *QWheelEvent) Source() MouseEventSource {
	return (MouseEventSource)(C.QWheelEvent_Source(this.h))
}

func (this *QWheelEvent) callVirtualBase_Clone() *QWheelEvent {

	return UnsafeNewQWheelEvent(unsafe.Pointer(C.QWheelEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil, nil)
}
func (this *QWheelEvent) OnClone(slot func(super func() *QWheelEvent) *QWheelEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWheelEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWheelEvent_Clone
func miqt_exec_callback_QWheelEvent_Clone(self *C.QWheelEvent, cb C.intptr_t) *C.QWheelEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QWheelEvent) *QWheelEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QWheelEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QWheelEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QWheelEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QWheelEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWheelEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWheelEvent_IsBeginEvent
func miqt_exec_callback_QWheelEvent_IsBeginEvent(self *C.QWheelEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QWheelEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QWheelEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QWheelEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QWheelEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWheelEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWheelEvent_IsUpdateEvent
func miqt_exec_callback_QWheelEvent_IsUpdateEvent(self *C.QWheelEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QWheelEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QWheelEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QWheelEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QWheelEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWheelEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWheelEvent_IsEndEvent
func miqt_exec_callback_QWheelEvent_IsEndEvent(self *C.QWheelEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QWheelEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

// Delete this object from C++ memory.
func (this *QWheelEvent) Delete() {
	C.QWheelEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QWheelEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QWheelEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QTabletEvent struct {
	h          *C.QTabletEvent
	isSubclass bool
	*QSinglePointEvent
}

func (this *QTabletEvent) cPointer() *C.QTabletEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QTabletEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQTabletEvent constructs the type using only CGO pointers.
func newQTabletEvent(h *C.QTabletEvent, h_QSinglePointEvent *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QTabletEvent {
	if h == nil {
		return nil
	}
	return &QTabletEvent{h: h,
		QSinglePointEvent: newQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQTabletEvent constructs the type using only unsafe pointers.
func UnsafeNewQTabletEvent(h unsafe.Pointer, h_QSinglePointEvent unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QTabletEvent {
	if h == nil {
		return nil
	}

	return &QTabletEvent{h: (*C.QTabletEvent)(h),
		QSinglePointEvent: UnsafeNewQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQTabletEvent constructs a new QTabletEvent object.
func NewQTabletEvent(t QEvent__Type, device *QPointingDevice, pos *QPointF, globalPos *QPointF, pressure float64, xTilt float32, yTilt float32, tangentialPressure float32, rotation float64, z float32, keyState KeyboardModifier, button MouseButton, buttons MouseButton) *QTabletEvent {
	var outptr_QTabletEvent *C.QTabletEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTabletEvent_new((C.int)(t), device.cPointer(), pos.cPointer(), globalPos.cPointer(), (C.double)(pressure), (C.float)(xTilt), (C.float)(yTilt), (C.float)(tangentialPressure), (C.double)(rotation), (C.float)(z), (C.int)(keyState), (C.int)(button), (C.int)(buttons), &outptr_QTabletEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTabletEvent(outptr_QTabletEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QTabletEvent) Clone() *QTabletEvent {
	return UnsafeNewQTabletEvent(unsafe.Pointer(C.QTabletEvent_Clone(this.h)), nil, nil, nil, nil)
}

func (this *QTabletEvent) Pos() *QPoint {
	_ret := C.QTabletEvent_Pos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QTabletEvent) GlobalPos() *QPoint {
	_ret := C.QTabletEvent_GlobalPos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QTabletEvent) PosF() *QPointF {
	_ret := C.QTabletEvent_PosF(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QTabletEvent) GlobalPosF() *QPointF {
	_ret := C.QTabletEvent_GlobalPosF(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QTabletEvent) X() int {
	return (int)(C.QTabletEvent_X(this.h))
}

func (this *QTabletEvent) Y() int {
	return (int)(C.QTabletEvent_Y(this.h))
}

func (this *QTabletEvent) GlobalX() int {
	return (int)(C.QTabletEvent_GlobalX(this.h))
}

func (this *QTabletEvent) GlobalY() int {
	return (int)(C.QTabletEvent_GlobalY(this.h))
}

func (this *QTabletEvent) HiResGlobalX() float64 {
	return (float64)(C.QTabletEvent_HiResGlobalX(this.h))
}

func (this *QTabletEvent) HiResGlobalY() float64 {
	return (float64)(C.QTabletEvent_HiResGlobalY(this.h))
}

func (this *QTabletEvent) UniqueId() int64 {
	return (int64)(C.QTabletEvent_UniqueId(this.h))
}

func (this *QTabletEvent) Pressure() float64 {
	return (float64)(C.QTabletEvent_Pressure(this.h))
}

func (this *QTabletEvent) Rotation() float64 {
	return (float64)(C.QTabletEvent_Rotation(this.h))
}

func (this *QTabletEvent) Z() float64 {
	return (float64)(C.QTabletEvent_Z(this.h))
}

func (this *QTabletEvent) TangentialPressure() float64 {
	return (float64)(C.QTabletEvent_TangentialPressure(this.h))
}

func (this *QTabletEvent) XTilt() float64 {
	return (float64)(C.QTabletEvent_XTilt(this.h))
}

func (this *QTabletEvent) YTilt() float64 {
	return (float64)(C.QTabletEvent_YTilt(this.h))
}

func (this *QTabletEvent) callVirtualBase_Clone() *QTabletEvent {

	return UnsafeNewQTabletEvent(unsafe.Pointer(C.QTabletEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil, nil)
}
func (this *QTabletEvent) OnClone(slot func(super func() *QTabletEvent) *QTabletEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTabletEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTabletEvent_Clone
func miqt_exec_callback_QTabletEvent_Clone(self *C.QTabletEvent, cb C.intptr_t) *C.QTabletEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QTabletEvent) *QTabletEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTabletEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QTabletEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QTabletEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QTabletEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTabletEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTabletEvent_IsBeginEvent
func miqt_exec_callback_QTabletEvent_IsBeginEvent(self *C.QTabletEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTabletEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QTabletEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QTabletEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QTabletEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTabletEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTabletEvent_IsUpdateEvent
func miqt_exec_callback_QTabletEvent_IsUpdateEvent(self *C.QTabletEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTabletEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QTabletEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QTabletEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QTabletEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTabletEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTabletEvent_IsEndEvent
func miqt_exec_callback_QTabletEvent_IsEndEvent(self *C.QTabletEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTabletEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

// Delete this object from C++ memory.
func (this *QTabletEvent) Delete() {
	C.QTabletEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QTabletEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QTabletEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QNativeGestureEvent struct {
	h          *C.QNativeGestureEvent
	isSubclass bool
	*QSinglePointEvent
}

func (this *QNativeGestureEvent) cPointer() *C.QNativeGestureEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QNativeGestureEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQNativeGestureEvent constructs the type using only CGO pointers.
func newQNativeGestureEvent(h *C.QNativeGestureEvent, h_QSinglePointEvent *C.QSinglePointEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QNativeGestureEvent {
	if h == nil {
		return nil
	}
	return &QNativeGestureEvent{h: h,
		QSinglePointEvent: newQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQNativeGestureEvent constructs the type using only unsafe pointers.
func UnsafeNewQNativeGestureEvent(h unsafe.Pointer, h_QSinglePointEvent unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QNativeGestureEvent {
	if h == nil {
		return nil
	}

	return &QNativeGestureEvent{h: (*C.QNativeGestureEvent)(h),
		QSinglePointEvent: UnsafeNewQSinglePointEvent(h_QSinglePointEvent, h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQNativeGestureEvent constructs a new QNativeGestureEvent object.
func NewQNativeGestureEvent(typeVal NativeGestureType, dev *QPointingDevice, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, value float64, sequenceId uint64, intArgument uint64) *QNativeGestureEvent {
	var outptr_QNativeGestureEvent *C.QNativeGestureEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QNativeGestureEvent_new((C.int)(typeVal), dev.cPointer(), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.double)(value), (C.ulonglong)(sequenceId), (C.ulonglong)(intArgument), &outptr_QNativeGestureEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQNativeGestureEvent(outptr_QNativeGestureEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQNativeGestureEvent2 constructs a new QNativeGestureEvent object.
func NewQNativeGestureEvent2(typeVal NativeGestureType, dev *QPointingDevice, fingerCount int, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, value float64, delta *QPointF) *QNativeGestureEvent {
	var outptr_QNativeGestureEvent *C.QNativeGestureEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QNativeGestureEvent_new2((C.int)(typeVal), dev.cPointer(), (C.int)(fingerCount), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.double)(value), delta.cPointer(), &outptr_QNativeGestureEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQNativeGestureEvent(outptr_QNativeGestureEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQNativeGestureEvent3 constructs a new QNativeGestureEvent object.
func NewQNativeGestureEvent3(typeVal NativeGestureType, dev *QPointingDevice, fingerCount int, localPos *QPointF, scenePos *QPointF, globalPos *QPointF, value float64, delta *QPointF, sequenceId uint64) *QNativeGestureEvent {
	var outptr_QNativeGestureEvent *C.QNativeGestureEvent = nil
	var outptr_QSinglePointEvent *C.QSinglePointEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QNativeGestureEvent_new3((C.int)(typeVal), dev.cPointer(), (C.int)(fingerCount), localPos.cPointer(), scenePos.cPointer(), globalPos.cPointer(), (C.double)(value), delta.cPointer(), (C.ulonglong)(sequenceId), &outptr_QNativeGestureEvent, &outptr_QSinglePointEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQNativeGestureEvent(outptr_QNativeGestureEvent, outptr_QSinglePointEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QNativeGestureEvent) Clone() *QNativeGestureEvent {
	return UnsafeNewQNativeGestureEvent(unsafe.Pointer(C.QNativeGestureEvent_Clone(this.h)), nil, nil, nil, nil)
}

func (this *QNativeGestureEvent) GestureType() NativeGestureType {
	return (NativeGestureType)(C.QNativeGestureEvent_GestureType(this.h))
}

func (this *QNativeGestureEvent) FingerCount() int {
	return (int)(C.QNativeGestureEvent_FingerCount(this.h))
}

func (this *QNativeGestureEvent) Value() float64 {
	return (float64)(C.QNativeGestureEvent_Value(this.h))
}

func (this *QNativeGestureEvent) Delta() *QPointF {
	_ret := C.QNativeGestureEvent_Delta(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QNativeGestureEvent) Pos() *QPoint {
	_ret := C.QNativeGestureEvent_Pos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QNativeGestureEvent) GlobalPos() *QPoint {
	_ret := C.QNativeGestureEvent_GlobalPos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QNativeGestureEvent) LocalPos() *QPointF {
	_ret := C.QNativeGestureEvent_LocalPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QNativeGestureEvent) WindowPos() *QPointF {
	_ret := C.QNativeGestureEvent_WindowPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QNativeGestureEvent) ScreenPos() *QPointF {
	_ret := C.QNativeGestureEvent_ScreenPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QNativeGestureEvent) callVirtualBase_Clone() *QNativeGestureEvent {

	return UnsafeNewQNativeGestureEvent(unsafe.Pointer(C.QNativeGestureEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil, nil)
}
func (this *QNativeGestureEvent) OnClone(slot func(super func() *QNativeGestureEvent) *QNativeGestureEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QNativeGestureEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QNativeGestureEvent_Clone
func miqt_exec_callback_QNativeGestureEvent_Clone(self *C.QNativeGestureEvent, cb C.intptr_t) *C.QNativeGestureEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QNativeGestureEvent) *QNativeGestureEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QNativeGestureEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QNativeGestureEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QNativeGestureEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QNativeGestureEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QNativeGestureEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QNativeGestureEvent_IsBeginEvent
func miqt_exec_callback_QNativeGestureEvent_IsBeginEvent(self *C.QNativeGestureEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QNativeGestureEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QNativeGestureEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QNativeGestureEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QNativeGestureEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QNativeGestureEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QNativeGestureEvent_IsUpdateEvent
func miqt_exec_callback_QNativeGestureEvent_IsUpdateEvent(self *C.QNativeGestureEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QNativeGestureEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QNativeGestureEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QNativeGestureEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QNativeGestureEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QNativeGestureEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QNativeGestureEvent_IsEndEvent
func miqt_exec_callback_QNativeGestureEvent_IsEndEvent(self *C.QNativeGestureEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QNativeGestureEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

// Delete this object from C++ memory.
func (this *QNativeGestureEvent) Delete() {
	C.QNativeGestureEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QNativeGestureEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QNativeGestureEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QKeyEvent struct {
	h          *C.QKeyEvent
	isSubclass bool
	*QInputEvent
}

func (this *QKeyEvent) cPointer() *C.QKeyEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QKeyEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQKeyEvent constructs the type using only CGO pointers.
func newQKeyEvent(h *C.QKeyEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QKeyEvent {
	if h == nil {
		return nil
	}
	return &QKeyEvent{h: h,
		QInputEvent: newQInputEvent(h_QInputEvent, h_QEvent)}
}

// UnsafeNewQKeyEvent constructs the type using only unsafe pointers.
func UnsafeNewQKeyEvent(h unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QKeyEvent {
	if h == nil {
		return nil
	}

	return &QKeyEvent{h: (*C.QKeyEvent)(h),
		QInputEvent: UnsafeNewQInputEvent(h_QInputEvent, h_QEvent)}
}

// NewQKeyEvent constructs a new QKeyEvent object.
func NewQKeyEvent(typeVal QEvent__Type, key int, modifiers KeyboardModifier) *QKeyEvent {
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent2 constructs a new QKeyEvent object.
func NewQKeyEvent2(typeVal QEvent__Type, key int, modifiers KeyboardModifier, nativeScanCode uint, nativeVirtualKey uint, nativeModifiers uint) *QKeyEvent {
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new2((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), (C.uint)(nativeScanCode), (C.uint)(nativeVirtualKey), (C.uint)(nativeModifiers), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent3 constructs a new QKeyEvent object.
func NewQKeyEvent3(typeVal QEvent__Type, key int, modifiers KeyboardModifier, text string) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new3((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), text_ms, &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent4 constructs a new QKeyEvent object.
func NewQKeyEvent4(typeVal QEvent__Type, key int, modifiers KeyboardModifier, text string, autorep bool) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new4((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), text_ms, (C.bool)(autorep), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent5 constructs a new QKeyEvent object.
func NewQKeyEvent5(typeVal QEvent__Type, key int, modifiers KeyboardModifier, text string, autorep bool, count uint16) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new5((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), text_ms, (C.bool)(autorep), (C.uint16_t)(count), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent6 constructs a new QKeyEvent object.
func NewQKeyEvent6(typeVal QEvent__Type, key int, modifiers KeyboardModifier, nativeScanCode uint, nativeVirtualKey uint, nativeModifiers uint, text string) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new6((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), (C.uint)(nativeScanCode), (C.uint)(nativeVirtualKey), (C.uint)(nativeModifiers), text_ms, &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent7 constructs a new QKeyEvent object.
func NewQKeyEvent7(typeVal QEvent__Type, key int, modifiers KeyboardModifier, nativeScanCode uint, nativeVirtualKey uint, nativeModifiers uint, text string, autorep bool) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new7((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), (C.uint)(nativeScanCode), (C.uint)(nativeVirtualKey), (C.uint)(nativeModifiers), text_ms, (C.bool)(autorep), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent8 constructs a new QKeyEvent object.
func NewQKeyEvent8(typeVal QEvent__Type, key int, modifiers KeyboardModifier, nativeScanCode uint, nativeVirtualKey uint, nativeModifiers uint, text string, autorep bool, count uint16) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new8((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), (C.uint)(nativeScanCode), (C.uint)(nativeVirtualKey), (C.uint)(nativeModifiers), text_ms, (C.bool)(autorep), (C.uint16_t)(count), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQKeyEvent9 constructs a new QKeyEvent object.
func NewQKeyEvent9(typeVal QEvent__Type, key int, modifiers KeyboardModifier, nativeScanCode uint, nativeVirtualKey uint, nativeModifiers uint, text string, autorep bool, count uint16, device *QInputDevice) *QKeyEvent {
	text_ms := C.struct_miqt_string{}
	text_ms.data = C.CString(text)
	text_ms.len = C.size_t(len(text))
	defer C.free(unsafe.Pointer(text_ms.data))
	var outptr_QKeyEvent *C.QKeyEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QKeyEvent_new9((C.int)(typeVal), (C.int)(key), (C.int)(modifiers), (C.uint)(nativeScanCode), (C.uint)(nativeVirtualKey), (C.uint)(nativeModifiers), text_ms, (C.bool)(autorep), (C.uint16_t)(count), device.cPointer(), &outptr_QKeyEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQKeyEvent(outptr_QKeyEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QKeyEvent) Clone() *QKeyEvent {
	return UnsafeNewQKeyEvent(unsafe.Pointer(C.QKeyEvent_Clone(this.h)), nil, nil)
}

func (this *QKeyEvent) Key() int {
	return (int)(C.QKeyEvent_Key(this.h))
}

func (this *QKeyEvent) Matches(key QKeySequence__StandardKey) bool {
	return (bool)(C.QKeyEvent_Matches(this.h, (C.int)(key)))
}

func (this *QKeyEvent) Modifiers() KeyboardModifier {
	return (KeyboardModifier)(C.QKeyEvent_Modifiers(this.h))
}

func (this *QKeyEvent) KeyCombination() *QKeyCombination {
	_ret := C.QKeyEvent_KeyCombination(this.h)
	_goptr := newQKeyCombination(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QKeyEvent) Text() string {
	var _ms C.struct_miqt_string = C.QKeyEvent_Text(this.h)
	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
	C.free(unsafe.Pointer(_ms.data))
	return _ret
}

func (this *QKeyEvent) IsAutoRepeat() bool {
	return (bool)(C.QKeyEvent_IsAutoRepeat(this.h))
}

func (this *QKeyEvent) Count() int {
	return (int)(C.QKeyEvent_Count(this.h))
}

func (this *QKeyEvent) NativeScanCode() uint {
	return (uint)(C.QKeyEvent_NativeScanCode(this.h))
}

func (this *QKeyEvent) NativeVirtualKey() uint {
	return (uint)(C.QKeyEvent_NativeVirtualKey(this.h))
}

func (this *QKeyEvent) NativeModifiers() uint {
	return (uint)(C.QKeyEvent_NativeModifiers(this.h))
}

func (this *QKeyEvent) callVirtualBase_Clone() *QKeyEvent {

	return UnsafeNewQKeyEvent(unsafe.Pointer(C.QKeyEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil)
}
func (this *QKeyEvent) OnClone(slot func(super func() *QKeyEvent) *QKeyEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QKeyEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QKeyEvent_Clone
func miqt_exec_callback_QKeyEvent_Clone(self *C.QKeyEvent, cb C.intptr_t) *C.QKeyEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QKeyEvent) *QKeyEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QKeyEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QKeyEvent) callVirtualBase_SetTimestamp(timestamp uint64) {

	C.QKeyEvent_virtualbase_SetTimestamp(unsafe.Pointer(this.h), (C.ulonglong)(timestamp))

}
func (this *QKeyEvent) OnSetTimestamp(slot func(super func(timestamp uint64), timestamp uint64)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QKeyEvent_override_virtual_SetTimestamp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QKeyEvent_SetTimestamp
func miqt_exec_callback_QKeyEvent_SetTimestamp(self *C.QKeyEvent, cb C.intptr_t, timestamp C.ulonglong) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(timestamp uint64), timestamp uint64))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (uint64)(timestamp)

	gofunc((&QKeyEvent{h: self}).callVirtualBase_SetTimestamp, slotval1)

}

// Delete this object from C++ memory.
func (this *QKeyEvent) Delete() {
	C.QKeyEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QKeyEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QKeyEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QFocusEvent struct {
	h          *C.QFocusEvent
	isSubclass bool
	*QEvent
}

func (this *QFocusEvent) cPointer() *C.QFocusEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QFocusEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQFocusEvent constructs the type using only CGO pointers.
func newQFocusEvent(h *C.QFocusEvent, h_QEvent *C.QEvent) *QFocusEvent {
	if h == nil {
		return nil
	}
	return &QFocusEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQFocusEvent constructs the type using only unsafe pointers.
func UnsafeNewQFocusEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QFocusEvent {
	if h == nil {
		return nil
	}

	return &QFocusEvent{h: (*C.QFocusEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQFocusEvent constructs a new QFocusEvent object.
func NewQFocusEvent(typeVal QEvent__Type) *QFocusEvent {
	var outptr_QFocusEvent *C.QFocusEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QFocusEvent_new((C.int)(typeVal), &outptr_QFocusEvent, &outptr_QEvent)
	ret := newQFocusEvent(outptr_QFocusEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQFocusEvent2 constructs a new QFocusEvent object.
func NewQFocusEvent2(typeVal QEvent__Type, reason FocusReason) *QFocusEvent {
	var outptr_QFocusEvent *C.QFocusEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QFocusEvent_new2((C.int)(typeVal), (C.int)(reason), &outptr_QFocusEvent, &outptr_QEvent)
	ret := newQFocusEvent(outptr_QFocusEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QFocusEvent) Clone() *QFocusEvent {
	return UnsafeNewQFocusEvent(unsafe.Pointer(C.QFocusEvent_Clone(this.h)), nil)
}

func (this *QFocusEvent) GotFocus() bool {
	return (bool)(C.QFocusEvent_GotFocus(this.h))
}

func (this *QFocusEvent) LostFocus() bool {
	return (bool)(C.QFocusEvent_LostFocus(this.h))
}

func (this *QFocusEvent) Reason() FocusReason {
	return (FocusReason)(C.QFocusEvent_Reason(this.h))
}

func (this *QFocusEvent) callVirtualBase_Clone() *QFocusEvent {

	return UnsafeNewQFocusEvent(unsafe.Pointer(C.QFocusEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QFocusEvent) OnClone(slot func(super func() *QFocusEvent) *QFocusEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QFocusEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QFocusEvent_Clone
func miqt_exec_callback_QFocusEvent_Clone(self *C.QFocusEvent, cb C.intptr_t) *C.QFocusEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QFocusEvent) *QFocusEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QFocusEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QFocusEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QFocusEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QFocusEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QFocusEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QFocusEvent_SetAccepted
func miqt_exec_callback_QFocusEvent_SetAccepted(self *C.QFocusEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QFocusEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QFocusEvent) Delete() {
	C.QFocusEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QFocusEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QFocusEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QPaintEvent struct {
	h          *C.QPaintEvent
	isSubclass bool
	*QEvent
}

func (this *QPaintEvent) cPointer() *C.QPaintEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QPaintEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQPaintEvent constructs the type using only CGO pointers.
func newQPaintEvent(h *C.QPaintEvent, h_QEvent *C.QEvent) *QPaintEvent {
	if h == nil {
		return nil
	}
	return &QPaintEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQPaintEvent constructs the type using only unsafe pointers.
func UnsafeNewQPaintEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QPaintEvent {
	if h == nil {
		return nil
	}

	return &QPaintEvent{h: (*C.QPaintEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQPaintEvent constructs a new QPaintEvent object.
func NewQPaintEvent(paintRegion *QRegion) *QPaintEvent {
	var outptr_QPaintEvent *C.QPaintEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QPaintEvent_new(paintRegion.cPointer(), &outptr_QPaintEvent, &outptr_QEvent)
	ret := newQPaintEvent(outptr_QPaintEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQPaintEvent2 constructs a new QPaintEvent object.
func NewQPaintEvent2(paintRect *QRect) *QPaintEvent {
	var outptr_QPaintEvent *C.QPaintEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QPaintEvent_new2(paintRect.cPointer(), &outptr_QPaintEvent, &outptr_QEvent)
	ret := newQPaintEvent(outptr_QPaintEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QPaintEvent) Clone() *QPaintEvent {
	return UnsafeNewQPaintEvent(unsafe.Pointer(C.QPaintEvent_Clone(this.h)), nil)
}

func (this *QPaintEvent) Rect() *QRect {
	return UnsafeNewQRect(unsafe.Pointer(C.QPaintEvent_Rect(this.h)))
}

func (this *QPaintEvent) Region() *QRegion {
	return UnsafeNewQRegion(unsafe.Pointer(C.QPaintEvent_Region(this.h)))
}

func (this *QPaintEvent) callVirtualBase_Clone() *QPaintEvent {

	return UnsafeNewQPaintEvent(unsafe.Pointer(C.QPaintEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QPaintEvent) OnClone(slot func(super func() *QPaintEvent) *QPaintEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPaintEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPaintEvent_Clone
func miqt_exec_callback_QPaintEvent_Clone(self *C.QPaintEvent, cb C.intptr_t) *C.QPaintEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QPaintEvent) *QPaintEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QPaintEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QPaintEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QPaintEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QPaintEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPaintEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPaintEvent_SetAccepted
func miqt_exec_callback_QPaintEvent_SetAccepted(self *C.QPaintEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QPaintEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QPaintEvent) Delete() {
	C.QPaintEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QPaintEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QPaintEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QMoveEvent struct {
	h          *C.QMoveEvent
	isSubclass bool
	*QEvent
}

func (this *QMoveEvent) cPointer() *C.QMoveEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QMoveEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQMoveEvent constructs the type using only CGO pointers.
func newQMoveEvent(h *C.QMoveEvent, h_QEvent *C.QEvent) *QMoveEvent {
	if h == nil {
		return nil
	}
	return &QMoveEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQMoveEvent constructs the type using only unsafe pointers.
func UnsafeNewQMoveEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QMoveEvent {
	if h == nil {
		return nil
	}

	return &QMoveEvent{h: (*C.QMoveEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQMoveEvent constructs a new QMoveEvent object.
func NewQMoveEvent(pos *QPoint, oldPos *QPoint) *QMoveEvent {
	var outptr_QMoveEvent *C.QMoveEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QMoveEvent_new(pos.cPointer(), oldPos.cPointer(), &outptr_QMoveEvent, &outptr_QEvent)
	ret := newQMoveEvent(outptr_QMoveEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QMoveEvent) Clone() *QMoveEvent {
	return UnsafeNewQMoveEvent(unsafe.Pointer(C.QMoveEvent_Clone(this.h)), nil)
}

func (this *QMoveEvent) Pos() *QPoint {
	return UnsafeNewQPoint(unsafe.Pointer(C.QMoveEvent_Pos(this.h)))
}

func (this *QMoveEvent) OldPos() *QPoint {
	return UnsafeNewQPoint(unsafe.Pointer(C.QMoveEvent_OldPos(this.h)))
}

func (this *QMoveEvent) callVirtualBase_Clone() *QMoveEvent {

	return UnsafeNewQMoveEvent(unsafe.Pointer(C.QMoveEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QMoveEvent) OnClone(slot func(super func() *QMoveEvent) *QMoveEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QMoveEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QMoveEvent_Clone
func miqt_exec_callback_QMoveEvent_Clone(self *C.QMoveEvent, cb C.intptr_t) *C.QMoveEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QMoveEvent) *QMoveEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QMoveEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QMoveEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QMoveEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QMoveEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QMoveEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QMoveEvent_SetAccepted
func miqt_exec_callback_QMoveEvent_SetAccepted(self *C.QMoveEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QMoveEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QMoveEvent) Delete() {
	C.QMoveEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMoveEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QMoveEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QExposeEvent struct {
	h          *C.QExposeEvent
	isSubclass bool
	*QEvent
}

func (this *QExposeEvent) cPointer() *C.QExposeEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QExposeEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQExposeEvent constructs the type using only CGO pointers.
func newQExposeEvent(h *C.QExposeEvent, h_QEvent *C.QEvent) *QExposeEvent {
	if h == nil {
		return nil
	}
	return &QExposeEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQExposeEvent constructs the type using only unsafe pointers.
func UnsafeNewQExposeEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QExposeEvent {
	if h == nil {
		return nil
	}

	return &QExposeEvent{h: (*C.QExposeEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQExposeEvent constructs a new QExposeEvent object.
func NewQExposeEvent(m_region *QRegion) *QExposeEvent {
	var outptr_QExposeEvent *C.QExposeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QExposeEvent_new(m_region.cPointer(), &outptr_QExposeEvent, &outptr_QEvent)
	ret := newQExposeEvent(outptr_QExposeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QExposeEvent) Clone() *QExposeEvent {
	return UnsafeNewQExposeEvent(unsafe.Pointer(C.QExposeEvent_Clone(this.h)), nil)
}

func (this *QExposeEvent) Region() *QRegion {
	return UnsafeNewQRegion(unsafe.Pointer(C.QExposeEvent_Region(this.h)))
}

func (this *QExposeEvent) callVirtualBase_Clone() *QExposeEvent {

	return UnsafeNewQExposeEvent(unsafe.Pointer(C.QExposeEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QExposeEvent) OnClone(slot func(super func() *QExposeEvent) *QExposeEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QExposeEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QExposeEvent_Clone
func miqt_exec_callback_QExposeEvent_Clone(self *C.QExposeEvent, cb C.intptr_t) *C.QExposeEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QExposeEvent) *QExposeEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QExposeEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QExposeEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QExposeEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QExposeEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QExposeEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QExposeEvent_SetAccepted
func miqt_exec_callback_QExposeEvent_SetAccepted(self *C.QExposeEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QExposeEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QExposeEvent) Delete() {
	C.QExposeEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QExposeEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QExposeEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QPlatformSurfaceEvent struct {
	h          *C.QPlatformSurfaceEvent
	isSubclass bool
	*QEvent
}

func (this *QPlatformSurfaceEvent) cPointer() *C.QPlatformSurfaceEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QPlatformSurfaceEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQPlatformSurfaceEvent constructs the type using only CGO pointers.
func newQPlatformSurfaceEvent(h *C.QPlatformSurfaceEvent, h_QEvent *C.QEvent) *QPlatformSurfaceEvent {
	if h == nil {
		return nil
	}
	return &QPlatformSurfaceEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQPlatformSurfaceEvent constructs the type using only unsafe pointers.
func UnsafeNewQPlatformSurfaceEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QPlatformSurfaceEvent {
	if h == nil {
		return nil
	}

	return &QPlatformSurfaceEvent{h: (*C.QPlatformSurfaceEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQPlatformSurfaceEvent constructs a new QPlatformSurfaceEvent object.
func NewQPlatformSurfaceEvent(surfaceEventType QPlatformSurfaceEvent__SurfaceEventType) *QPlatformSurfaceEvent {
	var outptr_QPlatformSurfaceEvent *C.QPlatformSurfaceEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QPlatformSurfaceEvent_new((C.int)(surfaceEventType), &outptr_QPlatformSurfaceEvent, &outptr_QEvent)
	ret := newQPlatformSurfaceEvent(outptr_QPlatformSurfaceEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QPlatformSurfaceEvent) Clone() *QPlatformSurfaceEvent {
	return UnsafeNewQPlatformSurfaceEvent(unsafe.Pointer(C.QPlatformSurfaceEvent_Clone(this.h)), nil)
}

func (this *QPlatformSurfaceEvent) SurfaceEventType() QPlatformSurfaceEvent__SurfaceEventType {
	return (QPlatformSurfaceEvent__SurfaceEventType)(C.QPlatformSurfaceEvent_SurfaceEventType(this.h))
}

func (this *QPlatformSurfaceEvent) callVirtualBase_Clone() *QPlatformSurfaceEvent {

	return UnsafeNewQPlatformSurfaceEvent(unsafe.Pointer(C.QPlatformSurfaceEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QPlatformSurfaceEvent) OnClone(slot func(super func() *QPlatformSurfaceEvent) *QPlatformSurfaceEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPlatformSurfaceEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPlatformSurfaceEvent_Clone
func miqt_exec_callback_QPlatformSurfaceEvent_Clone(self *C.QPlatformSurfaceEvent, cb C.intptr_t) *C.QPlatformSurfaceEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QPlatformSurfaceEvent) *QPlatformSurfaceEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QPlatformSurfaceEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QPlatformSurfaceEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QPlatformSurfaceEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QPlatformSurfaceEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QPlatformSurfaceEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QPlatformSurfaceEvent_SetAccepted
func miqt_exec_callback_QPlatformSurfaceEvent_SetAccepted(self *C.QPlatformSurfaceEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QPlatformSurfaceEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QPlatformSurfaceEvent) Delete() {
	C.QPlatformSurfaceEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QPlatformSurfaceEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QPlatformSurfaceEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QResizeEvent struct {
	h          *C.QResizeEvent
	isSubclass bool
	*QEvent
}

func (this *QResizeEvent) cPointer() *C.QResizeEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QResizeEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQResizeEvent constructs the type using only CGO pointers.
func newQResizeEvent(h *C.QResizeEvent, h_QEvent *C.QEvent) *QResizeEvent {
	if h == nil {
		return nil
	}
	return &QResizeEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQResizeEvent constructs the type using only unsafe pointers.
func UnsafeNewQResizeEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QResizeEvent {
	if h == nil {
		return nil
	}

	return &QResizeEvent{h: (*C.QResizeEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQResizeEvent constructs a new QResizeEvent object.
func NewQResizeEvent(size *QSize, oldSize *QSize) *QResizeEvent {
	var outptr_QResizeEvent *C.QResizeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QResizeEvent_new(size.cPointer(), oldSize.cPointer(), &outptr_QResizeEvent, &outptr_QEvent)
	ret := newQResizeEvent(outptr_QResizeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QResizeEvent) Clone() *QResizeEvent {
	return UnsafeNewQResizeEvent(unsafe.Pointer(C.QResizeEvent_Clone(this.h)), nil)
}

func (this *QResizeEvent) Size() *QSize {
	return UnsafeNewQSize(unsafe.Pointer(C.QResizeEvent_Size(this.h)))
}

func (this *QResizeEvent) OldSize() *QSize {
	return UnsafeNewQSize(unsafe.Pointer(C.QResizeEvent_OldSize(this.h)))
}

func (this *QResizeEvent) callVirtualBase_Clone() *QResizeEvent {

	return UnsafeNewQResizeEvent(unsafe.Pointer(C.QResizeEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QResizeEvent) OnClone(slot func(super func() *QResizeEvent) *QResizeEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QResizeEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QResizeEvent_Clone
func miqt_exec_callback_QResizeEvent_Clone(self *C.QResizeEvent, cb C.intptr_t) *C.QResizeEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QResizeEvent) *QResizeEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QResizeEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QResizeEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QResizeEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QResizeEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QResizeEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QResizeEvent_SetAccepted
func miqt_exec_callback_QResizeEvent_SetAccepted(self *C.QResizeEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QResizeEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QResizeEvent) Delete() {
	C.QResizeEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QResizeEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QResizeEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QCloseEvent struct {
	h          *C.QCloseEvent
	isSubclass bool
	*QEvent
}

func (this *QCloseEvent) cPointer() *C.QCloseEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QCloseEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQCloseEvent constructs the type using only CGO pointers.
func newQCloseEvent(h *C.QCloseEvent, h_QEvent *C.QEvent) *QCloseEvent {
	if h == nil {
		return nil
	}
	return &QCloseEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQCloseEvent constructs the type using only unsafe pointers.
func UnsafeNewQCloseEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QCloseEvent {
	if h == nil {
		return nil
	}

	return &QCloseEvent{h: (*C.QCloseEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQCloseEvent constructs a new QCloseEvent object.
func NewQCloseEvent() *QCloseEvent {
	var outptr_QCloseEvent *C.QCloseEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QCloseEvent_new(&outptr_QCloseEvent, &outptr_QEvent)
	ret := newQCloseEvent(outptr_QCloseEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QCloseEvent) Clone() *QCloseEvent {
	return UnsafeNewQCloseEvent(unsafe.Pointer(C.QCloseEvent_Clone(this.h)), nil)
}

func (this *QCloseEvent) callVirtualBase_Clone() *QCloseEvent {

	return UnsafeNewQCloseEvent(unsafe.Pointer(C.QCloseEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QCloseEvent) OnClone(slot func(super func() *QCloseEvent) *QCloseEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QCloseEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QCloseEvent_Clone
func miqt_exec_callback_QCloseEvent_Clone(self *C.QCloseEvent, cb C.intptr_t) *C.QCloseEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QCloseEvent) *QCloseEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QCloseEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QCloseEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QCloseEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QCloseEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QCloseEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QCloseEvent_SetAccepted
func miqt_exec_callback_QCloseEvent_SetAccepted(self *C.QCloseEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QCloseEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QCloseEvent) Delete() {
	C.QCloseEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QCloseEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QCloseEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QIconDragEvent struct {
	h          *C.QIconDragEvent
	isSubclass bool
	*QEvent
}

func (this *QIconDragEvent) cPointer() *C.QIconDragEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QIconDragEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQIconDragEvent constructs the type using only CGO pointers.
func newQIconDragEvent(h *C.QIconDragEvent, h_QEvent *C.QEvent) *QIconDragEvent {
	if h == nil {
		return nil
	}
	return &QIconDragEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQIconDragEvent constructs the type using only unsafe pointers.
func UnsafeNewQIconDragEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QIconDragEvent {
	if h == nil {
		return nil
	}

	return &QIconDragEvent{h: (*C.QIconDragEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQIconDragEvent constructs a new QIconDragEvent object.
func NewQIconDragEvent() *QIconDragEvent {
	var outptr_QIconDragEvent *C.QIconDragEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QIconDragEvent_new(&outptr_QIconDragEvent, &outptr_QEvent)
	ret := newQIconDragEvent(outptr_QIconDragEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QIconDragEvent) Clone() *QIconDragEvent {
	return UnsafeNewQIconDragEvent(unsafe.Pointer(C.QIconDragEvent_Clone(this.h)), nil)
}

func (this *QIconDragEvent) callVirtualBase_Clone() *QIconDragEvent {

	return UnsafeNewQIconDragEvent(unsafe.Pointer(C.QIconDragEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QIconDragEvent) OnClone(slot func(super func() *QIconDragEvent) *QIconDragEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QIconDragEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QIconDragEvent_Clone
func miqt_exec_callback_QIconDragEvent_Clone(self *C.QIconDragEvent, cb C.intptr_t) *C.QIconDragEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QIconDragEvent) *QIconDragEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QIconDragEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QIconDragEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QIconDragEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QIconDragEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QIconDragEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QIconDragEvent_SetAccepted
func miqt_exec_callback_QIconDragEvent_SetAccepted(self *C.QIconDragEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QIconDragEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QIconDragEvent) Delete() {
	C.QIconDragEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QIconDragEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QIconDragEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QShowEvent struct {
	h          *C.QShowEvent
	isSubclass bool
	*QEvent
}

func (this *QShowEvent) cPointer() *C.QShowEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QShowEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQShowEvent constructs the type using only CGO pointers.
func newQShowEvent(h *C.QShowEvent, h_QEvent *C.QEvent) *QShowEvent {
	if h == nil {
		return nil
	}
	return &QShowEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQShowEvent constructs the type using only unsafe pointers.
func UnsafeNewQShowEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QShowEvent {
	if h == nil {
		return nil
	}

	return &QShowEvent{h: (*C.QShowEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQShowEvent constructs a new QShowEvent object.
func NewQShowEvent() *QShowEvent {
	var outptr_QShowEvent *C.QShowEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QShowEvent_new(&outptr_QShowEvent, &outptr_QEvent)
	ret := newQShowEvent(outptr_QShowEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QShowEvent) Clone() *QShowEvent {
	return UnsafeNewQShowEvent(unsafe.Pointer(C.QShowEvent_Clone(this.h)), nil)
}

func (this *QShowEvent) callVirtualBase_Clone() *QShowEvent {

	return UnsafeNewQShowEvent(unsafe.Pointer(C.QShowEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QShowEvent) OnClone(slot func(super func() *QShowEvent) *QShowEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QShowEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QShowEvent_Clone
func miqt_exec_callback_QShowEvent_Clone(self *C.QShowEvent, cb C.intptr_t) *C.QShowEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QShowEvent) *QShowEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QShowEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QShowEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QShowEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QShowEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QShowEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QShowEvent_SetAccepted
func miqt_exec_callback_QShowEvent_SetAccepted(self *C.QShowEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QShowEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QShowEvent) Delete() {
	C.QShowEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QShowEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QShowEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QHideEvent struct {
	h          *C.QHideEvent
	isSubclass bool
	*QEvent
}

func (this *QHideEvent) cPointer() *C.QHideEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QHideEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQHideEvent constructs the type using only CGO pointers.
func newQHideEvent(h *C.QHideEvent, h_QEvent *C.QEvent) *QHideEvent {
	if h == nil {
		return nil
	}
	return &QHideEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQHideEvent constructs the type using only unsafe pointers.
func UnsafeNewQHideEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QHideEvent {
	if h == nil {
		return nil
	}

	return &QHideEvent{h: (*C.QHideEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQHideEvent constructs a new QHideEvent object.
func NewQHideEvent() *QHideEvent {
	var outptr_QHideEvent *C.QHideEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHideEvent_new(&outptr_QHideEvent, &outptr_QEvent)
	ret := newQHideEvent(outptr_QHideEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QHideEvent) Clone() *QHideEvent {
	return UnsafeNewQHideEvent(unsafe.Pointer(C.QHideEvent_Clone(this.h)), nil)
}

func (this *QHideEvent) callVirtualBase_Clone() *QHideEvent {

	return UnsafeNewQHideEvent(unsafe.Pointer(C.QHideEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QHideEvent) OnClone(slot func(super func() *QHideEvent) *QHideEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHideEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHideEvent_Clone
func miqt_exec_callback_QHideEvent_Clone(self *C.QHideEvent, cb C.intptr_t) *C.QHideEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QHideEvent) *QHideEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QHideEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QHideEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QHideEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QHideEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHideEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHideEvent_SetAccepted
func miqt_exec_callback_QHideEvent_SetAccepted(self *C.QHideEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QHideEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QHideEvent) Delete() {
	C.QHideEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QHideEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QHideEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QContextMenuEvent struct {
	h          *C.QContextMenuEvent
	isSubclass bool
	*QInputEvent
}

func (this *QContextMenuEvent) cPointer() *C.QContextMenuEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QContextMenuEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQContextMenuEvent constructs the type using only CGO pointers.
func newQContextMenuEvent(h *C.QContextMenuEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QContextMenuEvent {
	if h == nil {
		return nil
	}
	return &QContextMenuEvent{h: h,
		QInputEvent: newQInputEvent(h_QInputEvent, h_QEvent)}
}

// UnsafeNewQContextMenuEvent constructs the type using only unsafe pointers.
func UnsafeNewQContextMenuEvent(h unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QContextMenuEvent {
	if h == nil {
		return nil
	}

	return &QContextMenuEvent{h: (*C.QContextMenuEvent)(h),
		QInputEvent: UnsafeNewQInputEvent(h_QInputEvent, h_QEvent)}
}

// NewQContextMenuEvent constructs a new QContextMenuEvent object.
func NewQContextMenuEvent(reason QContextMenuEvent__Reason, pos *QPoint, globalPos *QPoint) *QContextMenuEvent {
	var outptr_QContextMenuEvent *C.QContextMenuEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QContextMenuEvent_new((C.int)(reason), pos.cPointer(), globalPos.cPointer(), &outptr_QContextMenuEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQContextMenuEvent(outptr_QContextMenuEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQContextMenuEvent2 constructs a new QContextMenuEvent object.
func NewQContextMenuEvent2(reason QContextMenuEvent__Reason, pos *QPoint) *QContextMenuEvent {
	var outptr_QContextMenuEvent *C.QContextMenuEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QContextMenuEvent_new2((C.int)(reason), pos.cPointer(), &outptr_QContextMenuEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQContextMenuEvent(outptr_QContextMenuEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQContextMenuEvent3 constructs a new QContextMenuEvent object.
func NewQContextMenuEvent3(reason QContextMenuEvent__Reason, pos *QPoint, globalPos *QPoint, modifiers KeyboardModifier) *QContextMenuEvent {
	var outptr_QContextMenuEvent *C.QContextMenuEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QContextMenuEvent_new3((C.int)(reason), pos.cPointer(), globalPos.cPointer(), (C.int)(modifiers), &outptr_QContextMenuEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQContextMenuEvent(outptr_QContextMenuEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QContextMenuEvent) Clone() *QContextMenuEvent {
	return UnsafeNewQContextMenuEvent(unsafe.Pointer(C.QContextMenuEvent_Clone(this.h)), nil, nil)
}

func (this *QContextMenuEvent) X() int {
	return (int)(C.QContextMenuEvent_X(this.h))
}

func (this *QContextMenuEvent) Y() int {
	return (int)(C.QContextMenuEvent_Y(this.h))
}

func (this *QContextMenuEvent) GlobalX() int {
	return (int)(C.QContextMenuEvent_GlobalX(this.h))
}

func (this *QContextMenuEvent) GlobalY() int {
	return (int)(C.QContextMenuEvent_GlobalY(this.h))
}

func (this *QContextMenuEvent) Pos() *QPoint {
	return UnsafeNewQPoint(unsafe.Pointer(C.QContextMenuEvent_Pos(this.h)))
}

func (this *QContextMenuEvent) GlobalPos() *QPoint {
	return UnsafeNewQPoint(unsafe.Pointer(C.QContextMenuEvent_GlobalPos(this.h)))
}

func (this *QContextMenuEvent) Reason() QContextMenuEvent__Reason {
	return (QContextMenuEvent__Reason)(C.QContextMenuEvent_Reason(this.h))
}

func (this *QContextMenuEvent) callVirtualBase_Clone() *QContextMenuEvent {

	return UnsafeNewQContextMenuEvent(unsafe.Pointer(C.QContextMenuEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil)
}
func (this *QContextMenuEvent) OnClone(slot func(super func() *QContextMenuEvent) *QContextMenuEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QContextMenuEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QContextMenuEvent_Clone
func miqt_exec_callback_QContextMenuEvent_Clone(self *C.QContextMenuEvent, cb C.intptr_t) *C.QContextMenuEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QContextMenuEvent) *QContextMenuEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QContextMenuEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QContextMenuEvent) callVirtualBase_SetTimestamp(timestamp uint64) {

	C.QContextMenuEvent_virtualbase_SetTimestamp(unsafe.Pointer(this.h), (C.ulonglong)(timestamp))

}
func (this *QContextMenuEvent) OnSetTimestamp(slot func(super func(timestamp uint64), timestamp uint64)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QContextMenuEvent_override_virtual_SetTimestamp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QContextMenuEvent_SetTimestamp
func miqt_exec_callback_QContextMenuEvent_SetTimestamp(self *C.QContextMenuEvent, cb C.intptr_t, timestamp C.ulonglong) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(timestamp uint64), timestamp uint64))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (uint64)(timestamp)

	gofunc((&QContextMenuEvent{h: self}).callVirtualBase_SetTimestamp, slotval1)

}

// Delete this object from C++ memory.
func (this *QContextMenuEvent) Delete() {
	C.QContextMenuEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QContextMenuEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QContextMenuEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QInputMethodEvent struct {
	h          *C.QInputMethodEvent
	isSubclass bool
	*QEvent
}

func (this *QInputMethodEvent) cPointer() *C.QInputMethodEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QInputMethodEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQInputMethodEvent constructs the type using only CGO pointers.
func newQInputMethodEvent(h *C.QInputMethodEvent, h_QEvent *C.QEvent) *QInputMethodEvent {
	if h == nil {
		return nil
	}
	return &QInputMethodEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQInputMethodEvent constructs the type using only unsafe pointers.
func UnsafeNewQInputMethodEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QInputMethodEvent {
	if h == nil {
		return nil
	}

	return &QInputMethodEvent{h: (*C.QInputMethodEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQInputMethodEvent constructs a new QInputMethodEvent object.
func NewQInputMethodEvent() *QInputMethodEvent {
	var outptr_QInputMethodEvent *C.QInputMethodEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QInputMethodEvent_new(&outptr_QInputMethodEvent, &outptr_QEvent)
	ret := newQInputMethodEvent(outptr_QInputMethodEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQInputMethodEvent2 constructs a new QInputMethodEvent object.
func NewQInputMethodEvent2(preeditText string, attributes []QInputMethodEvent__Attribute) *QInputMethodEvent {
	preeditText_ms := C.struct_miqt_string{}
	preeditText_ms.data = C.CString(preeditText)
	preeditText_ms.len = C.size_t(len(preeditText))
	defer C.free(unsafe.Pointer(preeditText_ms.data))
	attributes_CArray := (*[0xffff]*C.QInputMethodEvent__Attribute)(C.malloc(C.size_t(8 * len(attributes))))
	defer C.free(unsafe.Pointer(attributes_CArray))
	for i := range attributes {
		attributes_CArray[i] = attributes[i].cPointer()
	}
	attributes_ma := C.struct_miqt_array{len: C.size_t(len(attributes)), data: unsafe.Pointer(attributes_CArray)}
	var outptr_QInputMethodEvent *C.QInputMethodEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QInputMethodEvent_new2(preeditText_ms, attributes_ma, &outptr_QInputMethodEvent, &outptr_QEvent)
	ret := newQInputMethodEvent(outptr_QInputMethodEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QInputMethodEvent) Clone() *QInputMethodEvent {
	return UnsafeNewQInputMethodEvent(unsafe.Pointer(C.QInputMethodEvent_Clone(this.h)), nil)
}

func (this *QInputMethodEvent) SetCommitString(commitString string) {
	commitString_ms := C.struct_miqt_string{}
	commitString_ms.data = C.CString(commitString)
	commitString_ms.len = C.size_t(len(commitString))
	defer C.free(unsafe.Pointer(commitString_ms.data))
	C.QInputMethodEvent_SetCommitString(this.h, commitString_ms)
}

func (this *QInputMethodEvent) Attributes() []QInputMethodEvent__Attribute {
	var _ma C.struct_miqt_array = C.QInputMethodEvent_Attributes(this.h)
	_ret := make([]QInputMethodEvent__Attribute, int(_ma.len))
	_outCast := (*[0xffff]*C.QInputMethodEvent__Attribute)(unsafe.Pointer(_ma.data)) // hey ya
	for i := 0; i < int(_ma.len); i++ {
		_lv_ret := _outCast[i]
		_lv_goptr := newQInputMethodEvent__Attribute(_lv_ret)
		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
		_ret[i] = *_lv_goptr
	}
	return _ret
}

func (this *QInputMethodEvent) PreeditString() string {
	var _ms C.struct_miqt_string = C.QInputMethodEvent_PreeditString(this.h)
	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
	C.free(unsafe.Pointer(_ms.data))
	return _ret
}

func (this *QInputMethodEvent) CommitString() string {
	var _ms C.struct_miqt_string = C.QInputMethodEvent_CommitString(this.h)
	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
	C.free(unsafe.Pointer(_ms.data))
	return _ret
}

func (this *QInputMethodEvent) ReplacementStart() int {
	return (int)(C.QInputMethodEvent_ReplacementStart(this.h))
}

func (this *QInputMethodEvent) ReplacementLength() int {
	return (int)(C.QInputMethodEvent_ReplacementLength(this.h))
}

func (this *QInputMethodEvent) SetCommitString2(commitString string, replaceFrom int) {
	commitString_ms := C.struct_miqt_string{}
	commitString_ms.data = C.CString(commitString)
	commitString_ms.len = C.size_t(len(commitString))
	defer C.free(unsafe.Pointer(commitString_ms.data))
	C.QInputMethodEvent_SetCommitString2(this.h, commitString_ms, (C.int)(replaceFrom))
}

func (this *QInputMethodEvent) SetCommitString3(commitString string, replaceFrom int, replaceLength int) {
	commitString_ms := C.struct_miqt_string{}
	commitString_ms.data = C.CString(commitString)
	commitString_ms.len = C.size_t(len(commitString))
	defer C.free(unsafe.Pointer(commitString_ms.data))
	C.QInputMethodEvent_SetCommitString3(this.h, commitString_ms, (C.int)(replaceFrom), (C.int)(replaceLength))
}

func (this *QInputMethodEvent) callVirtualBase_Clone() *QInputMethodEvent {

	return UnsafeNewQInputMethodEvent(unsafe.Pointer(C.QInputMethodEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QInputMethodEvent) OnClone(slot func(super func() *QInputMethodEvent) *QInputMethodEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputMethodEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputMethodEvent_Clone
func miqt_exec_callback_QInputMethodEvent_Clone(self *C.QInputMethodEvent, cb C.intptr_t) *C.QInputMethodEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QInputMethodEvent) *QInputMethodEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QInputMethodEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QInputMethodEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QInputMethodEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QInputMethodEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputMethodEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputMethodEvent_SetAccepted
func miqt_exec_callback_QInputMethodEvent_SetAccepted(self *C.QInputMethodEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QInputMethodEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QInputMethodEvent) Delete() {
	C.QInputMethodEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QInputMethodEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QInputMethodEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QInputMethodQueryEvent struct {
	h          *C.QInputMethodQueryEvent
	isSubclass bool
	*QEvent
}

func (this *QInputMethodQueryEvent) cPointer() *C.QInputMethodQueryEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QInputMethodQueryEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQInputMethodQueryEvent constructs the type using only CGO pointers.
func newQInputMethodQueryEvent(h *C.QInputMethodQueryEvent, h_QEvent *C.QEvent) *QInputMethodQueryEvent {
	if h == nil {
		return nil
	}
	return &QInputMethodQueryEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQInputMethodQueryEvent constructs the type using only unsafe pointers.
func UnsafeNewQInputMethodQueryEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QInputMethodQueryEvent {
	if h == nil {
		return nil
	}

	return &QInputMethodQueryEvent{h: (*C.QInputMethodQueryEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQInputMethodQueryEvent constructs a new QInputMethodQueryEvent object.
func NewQInputMethodQueryEvent(queries InputMethodQuery) *QInputMethodQueryEvent {
	var outptr_QInputMethodQueryEvent *C.QInputMethodQueryEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QInputMethodQueryEvent_new((C.int)(queries), &outptr_QInputMethodQueryEvent, &outptr_QEvent)
	ret := newQInputMethodQueryEvent(outptr_QInputMethodQueryEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QInputMethodQueryEvent) Clone() *QInputMethodQueryEvent {
	return UnsafeNewQInputMethodQueryEvent(unsafe.Pointer(C.QInputMethodQueryEvent_Clone(this.h)), nil)
}

func (this *QInputMethodQueryEvent) Queries() InputMethodQuery {
	return (InputMethodQuery)(C.QInputMethodQueryEvent_Queries(this.h))
}

func (this *QInputMethodQueryEvent) SetValue(query InputMethodQuery, value *QVariant) {
	C.QInputMethodQueryEvent_SetValue(this.h, (C.int)(query), value.cPointer())
}

func (this *QInputMethodQueryEvent) Value(query InputMethodQuery) *QVariant {
	_ret := C.QInputMethodQueryEvent_Value(this.h, (C.int)(query))
	_goptr := newQVariant(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QInputMethodQueryEvent) callVirtualBase_Clone() *QInputMethodQueryEvent {

	return UnsafeNewQInputMethodQueryEvent(unsafe.Pointer(C.QInputMethodQueryEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QInputMethodQueryEvent) OnClone(slot func(super func() *QInputMethodQueryEvent) *QInputMethodQueryEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputMethodQueryEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputMethodQueryEvent_Clone
func miqt_exec_callback_QInputMethodQueryEvent_Clone(self *C.QInputMethodQueryEvent, cb C.intptr_t) *C.QInputMethodQueryEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QInputMethodQueryEvent) *QInputMethodQueryEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QInputMethodQueryEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QInputMethodQueryEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QInputMethodQueryEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QInputMethodQueryEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QInputMethodQueryEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QInputMethodQueryEvent_SetAccepted
func miqt_exec_callback_QInputMethodQueryEvent_SetAccepted(self *C.QInputMethodQueryEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QInputMethodQueryEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QInputMethodQueryEvent) Delete() {
	C.QInputMethodQueryEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QInputMethodQueryEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QInputMethodQueryEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QDropEvent struct {
	h          *C.QDropEvent
	isSubclass bool
	*QEvent
}

func (this *QDropEvent) cPointer() *C.QDropEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QDropEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQDropEvent constructs the type using only CGO pointers.
func newQDropEvent(h *C.QDropEvent, h_QEvent *C.QEvent) *QDropEvent {
	if h == nil {
		return nil
	}
	return &QDropEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQDropEvent constructs the type using only unsafe pointers.
func UnsafeNewQDropEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QDropEvent {
	if h == nil {
		return nil
	}

	return &QDropEvent{h: (*C.QDropEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQDropEvent constructs a new QDropEvent object.
func NewQDropEvent(pos *QPointF, actions DropAction, data *QMimeData, buttons MouseButton, modifiers KeyboardModifier) *QDropEvent {
	var outptr_QDropEvent *C.QDropEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QDropEvent_new(pos.cPointer(), (C.int)(actions), data.cPointer(), (C.int)(buttons), (C.int)(modifiers), &outptr_QDropEvent, &outptr_QEvent)
	ret := newQDropEvent(outptr_QDropEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQDropEvent2 constructs a new QDropEvent object.
func NewQDropEvent2(pos *QPointF, actions DropAction, data *QMimeData, buttons MouseButton, modifiers KeyboardModifier, typeVal QEvent__Type) *QDropEvent {
	var outptr_QDropEvent *C.QDropEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QDropEvent_new2(pos.cPointer(), (C.int)(actions), data.cPointer(), (C.int)(buttons), (C.int)(modifiers), (C.int)(typeVal), &outptr_QDropEvent, &outptr_QEvent)
	ret := newQDropEvent(outptr_QDropEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QDropEvent) Clone() *QDropEvent {
	return UnsafeNewQDropEvent(unsafe.Pointer(C.QDropEvent_Clone(this.h)), nil)
}

func (this *QDropEvent) Pos() *QPoint {
	_ret := C.QDropEvent_Pos(this.h)
	_goptr := newQPoint(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QDropEvent) PosF() *QPointF {
	_ret := C.QDropEvent_PosF(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QDropEvent) MouseButtons() MouseButton {
	return (MouseButton)(C.QDropEvent_MouseButtons(this.h))
}

func (this *QDropEvent) KeyboardModifiers() KeyboardModifier {
	return (KeyboardModifier)(C.QDropEvent_KeyboardModifiers(this.h))
}

func (this *QDropEvent) Position() *QPointF {
	_ret := C.QDropEvent_Position(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QDropEvent) Buttons() MouseButton {
	return (MouseButton)(C.QDropEvent_Buttons(this.h))
}

func (this *QDropEvent) Modifiers() KeyboardModifier {
	return (KeyboardModifier)(C.QDropEvent_Modifiers(this.h))
}

func (this *QDropEvent) PossibleActions() DropAction {
	return (DropAction)(C.QDropEvent_PossibleActions(this.h))
}

func (this *QDropEvent) ProposedAction() DropAction {
	return (DropAction)(C.QDropEvent_ProposedAction(this.h))
}

func (this *QDropEvent) AcceptProposedAction() {
	C.QDropEvent_AcceptProposedAction(this.h)
}

func (this *QDropEvent) DropAction() DropAction {
	return (DropAction)(C.QDropEvent_DropAction(this.h))
}

func (this *QDropEvent) SetDropAction(action DropAction) {
	C.QDropEvent_SetDropAction(this.h, (C.int)(action))
}

func (this *QDropEvent) Source() *QObject {
	return UnsafeNewQObject(unsafe.Pointer(C.QDropEvent_Source(this.h)))
}

func (this *QDropEvent) MimeData() *QMimeData {
	return UnsafeNewQMimeData(unsafe.Pointer(C.QDropEvent_MimeData(this.h)), nil)
}

func (this *QDropEvent) callVirtualBase_Clone() *QDropEvent {

	return UnsafeNewQDropEvent(unsafe.Pointer(C.QDropEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QDropEvent) OnClone(slot func(super func() *QDropEvent) *QDropEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QDropEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QDropEvent_Clone
func miqt_exec_callback_QDropEvent_Clone(self *C.QDropEvent, cb C.intptr_t) *C.QDropEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QDropEvent) *QDropEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QDropEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QDropEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QDropEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QDropEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QDropEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QDropEvent_SetAccepted
func miqt_exec_callback_QDropEvent_SetAccepted(self *C.QDropEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QDropEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QDropEvent) Delete() {
	C.QDropEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QDropEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QDropEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QDragMoveEvent struct {
	h          *C.QDragMoveEvent
	isSubclass bool
	*QDropEvent
}

func (this *QDragMoveEvent) cPointer() *C.QDragMoveEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QDragMoveEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQDragMoveEvent constructs the type using only CGO pointers.
func newQDragMoveEvent(h *C.QDragMoveEvent, h_QDropEvent *C.QDropEvent, h_QEvent *C.QEvent) *QDragMoveEvent {
	if h == nil {
		return nil
	}
	return &QDragMoveEvent{h: h,
		QDropEvent: newQDropEvent(h_QDropEvent, h_QEvent)}
}

// UnsafeNewQDragMoveEvent constructs the type using only unsafe pointers.
func UnsafeNewQDragMoveEvent(h unsafe.Pointer, h_QDropEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QDragMoveEvent {
	if h == nil {
		return nil
	}

	return &QDragMoveEvent{h: (*C.QDragMoveEvent)(h),
		QDropEvent: UnsafeNewQDropEvent(h_QDropEvent, h_QEvent)}
}

// NewQDragMoveEvent constructs a new QDragMoveEvent object.
func NewQDragMoveEvent(pos *QPoint, actions DropAction, data *QMimeData, buttons MouseButton, modifiers KeyboardModifier) *QDragMoveEvent {
	var outptr_QDragMoveEvent *C.QDragMoveEvent = nil
	var outptr_QDropEvent *C.QDropEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QDragMoveEvent_new(pos.cPointer(), (C.int)(actions), data.cPointer(), (C.int)(buttons), (C.int)(modifiers), &outptr_QDragMoveEvent, &outptr_QDropEvent, &outptr_QEvent)
	ret := newQDragMoveEvent(outptr_QDragMoveEvent, outptr_QDropEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQDragMoveEvent2 constructs a new QDragMoveEvent object.
func NewQDragMoveEvent2(pos *QPoint, actions DropAction, data *QMimeData, buttons MouseButton, modifiers KeyboardModifier, typeVal QEvent__Type) *QDragMoveEvent {
	var outptr_QDragMoveEvent *C.QDragMoveEvent = nil
	var outptr_QDropEvent *C.QDropEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QDragMoveEvent_new2(pos.cPointer(), (C.int)(actions), data.cPointer(), (C.int)(buttons), (C.int)(modifiers), (C.int)(typeVal), &outptr_QDragMoveEvent, &outptr_QDropEvent, &outptr_QEvent)
	ret := newQDragMoveEvent(outptr_QDragMoveEvent, outptr_QDropEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QDragMoveEvent) Clone() *QDragMoveEvent {
	return UnsafeNewQDragMoveEvent(unsafe.Pointer(C.QDragMoveEvent_Clone(this.h)), nil, nil)
}

func (this *QDragMoveEvent) AnswerRect() *QRect {
	_ret := C.QDragMoveEvent_AnswerRect(this.h)
	_goptr := newQRect(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QDragMoveEvent) Accept() {
	C.QDragMoveEvent_Accept(this.h)
}

func (this *QDragMoveEvent) Ignore() {
	C.QDragMoveEvent_Ignore(this.h)
}

func (this *QDragMoveEvent) AcceptWithQRect(r *QRect) {
	C.QDragMoveEvent_AcceptWithQRect(this.h, r.cPointer())
}

func (this *QDragMoveEvent) IgnoreWithQRect(r *QRect) {
	C.QDragMoveEvent_IgnoreWithQRect(this.h, r.cPointer())
}

func (this *QDragMoveEvent) callVirtualBase_Clone() *QDragMoveEvent {

	return UnsafeNewQDragMoveEvent(unsafe.Pointer(C.QDragMoveEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil)
}
func (this *QDragMoveEvent) OnClone(slot func(super func() *QDragMoveEvent) *QDragMoveEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QDragMoveEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QDragMoveEvent_Clone
func miqt_exec_callback_QDragMoveEvent_Clone(self *C.QDragMoveEvent, cb C.intptr_t) *C.QDragMoveEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QDragMoveEvent) *QDragMoveEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QDragMoveEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

// Delete this object from C++ memory.
func (this *QDragMoveEvent) Delete() {
	C.QDragMoveEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QDragMoveEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QDragMoveEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QDragEnterEvent struct {
	h          *C.QDragEnterEvent
	isSubclass bool
	*QDragMoveEvent
}

func (this *QDragEnterEvent) cPointer() *C.QDragEnterEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QDragEnterEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQDragEnterEvent constructs the type using only CGO pointers.
func newQDragEnterEvent(h *C.QDragEnterEvent, h_QDragMoveEvent *C.QDragMoveEvent, h_QDropEvent *C.QDropEvent, h_QEvent *C.QEvent) *QDragEnterEvent {
	if h == nil {
		return nil
	}
	return &QDragEnterEvent{h: h,
		QDragMoveEvent: newQDragMoveEvent(h_QDragMoveEvent, h_QDropEvent, h_QEvent)}
}

// UnsafeNewQDragEnterEvent constructs the type using only unsafe pointers.
func UnsafeNewQDragEnterEvent(h unsafe.Pointer, h_QDragMoveEvent unsafe.Pointer, h_QDropEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QDragEnterEvent {
	if h == nil {
		return nil
	}

	return &QDragEnterEvent{h: (*C.QDragEnterEvent)(h),
		QDragMoveEvent: UnsafeNewQDragMoveEvent(h_QDragMoveEvent, h_QDropEvent, h_QEvent)}
}

// NewQDragEnterEvent constructs a new QDragEnterEvent object.
func NewQDragEnterEvent(pos *QPoint, actions DropAction, data *QMimeData, buttons MouseButton, modifiers KeyboardModifier) *QDragEnterEvent {
	var outptr_QDragEnterEvent *C.QDragEnterEvent = nil
	var outptr_QDragMoveEvent *C.QDragMoveEvent = nil
	var outptr_QDropEvent *C.QDropEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QDragEnterEvent_new(pos.cPointer(), (C.int)(actions), data.cPointer(), (C.int)(buttons), (C.int)(modifiers), &outptr_QDragEnterEvent, &outptr_QDragMoveEvent, &outptr_QDropEvent, &outptr_QEvent)
	ret := newQDragEnterEvent(outptr_QDragEnterEvent, outptr_QDragMoveEvent, outptr_QDropEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QDragEnterEvent) Clone() *QDragEnterEvent {
	return UnsafeNewQDragEnterEvent(unsafe.Pointer(C.QDragEnterEvent_Clone(this.h)), nil, nil, nil)
}

func (this *QDragEnterEvent) callVirtualBase_Clone() *QDragEnterEvent {

	return UnsafeNewQDragEnterEvent(unsafe.Pointer(C.QDragEnterEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil)
}
func (this *QDragEnterEvent) OnClone(slot func(super func() *QDragEnterEvent) *QDragEnterEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QDragEnterEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QDragEnterEvent_Clone
func miqt_exec_callback_QDragEnterEvent_Clone(self *C.QDragEnterEvent, cb C.intptr_t) *C.QDragEnterEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QDragEnterEvent) *QDragEnterEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QDragEnterEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

// Delete this object from C++ memory.
func (this *QDragEnterEvent) Delete() {
	C.QDragEnterEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QDragEnterEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QDragEnterEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QDragLeaveEvent struct {
	h          *C.QDragLeaveEvent
	isSubclass bool
	*QEvent
}

func (this *QDragLeaveEvent) cPointer() *C.QDragLeaveEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QDragLeaveEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQDragLeaveEvent constructs the type using only CGO pointers.
func newQDragLeaveEvent(h *C.QDragLeaveEvent, h_QEvent *C.QEvent) *QDragLeaveEvent {
	if h == nil {
		return nil
	}
	return &QDragLeaveEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQDragLeaveEvent constructs the type using only unsafe pointers.
func UnsafeNewQDragLeaveEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QDragLeaveEvent {
	if h == nil {
		return nil
	}

	return &QDragLeaveEvent{h: (*C.QDragLeaveEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQDragLeaveEvent constructs a new QDragLeaveEvent object.
func NewQDragLeaveEvent() *QDragLeaveEvent {
	var outptr_QDragLeaveEvent *C.QDragLeaveEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QDragLeaveEvent_new(&outptr_QDragLeaveEvent, &outptr_QEvent)
	ret := newQDragLeaveEvent(outptr_QDragLeaveEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QDragLeaveEvent) Clone() *QDragLeaveEvent {
	return UnsafeNewQDragLeaveEvent(unsafe.Pointer(C.QDragLeaveEvent_Clone(this.h)), nil)
}

func (this *QDragLeaveEvent) callVirtualBase_Clone() *QDragLeaveEvent {

	return UnsafeNewQDragLeaveEvent(unsafe.Pointer(C.QDragLeaveEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QDragLeaveEvent) OnClone(slot func(super func() *QDragLeaveEvent) *QDragLeaveEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QDragLeaveEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QDragLeaveEvent_Clone
func miqt_exec_callback_QDragLeaveEvent_Clone(self *C.QDragLeaveEvent, cb C.intptr_t) *C.QDragLeaveEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QDragLeaveEvent) *QDragLeaveEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QDragLeaveEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QDragLeaveEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QDragLeaveEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QDragLeaveEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QDragLeaveEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QDragLeaveEvent_SetAccepted
func miqt_exec_callback_QDragLeaveEvent_SetAccepted(self *C.QDragLeaveEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QDragLeaveEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QDragLeaveEvent) Delete() {
	C.QDragLeaveEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QDragLeaveEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QDragLeaveEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QHelpEvent struct {
	h          *C.QHelpEvent
	isSubclass bool
	*QEvent
}

func (this *QHelpEvent) cPointer() *C.QHelpEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QHelpEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQHelpEvent constructs the type using only CGO pointers.
func newQHelpEvent(h *C.QHelpEvent, h_QEvent *C.QEvent) *QHelpEvent {
	if h == nil {
		return nil
	}
	return &QHelpEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQHelpEvent constructs the type using only unsafe pointers.
func UnsafeNewQHelpEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QHelpEvent {
	if h == nil {
		return nil
	}

	return &QHelpEvent{h: (*C.QHelpEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQHelpEvent constructs a new QHelpEvent object.
func NewQHelpEvent(typeVal QEvent__Type, pos *QPoint, globalPos *QPoint) *QHelpEvent {
	var outptr_QHelpEvent *C.QHelpEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QHelpEvent_new((C.int)(typeVal), pos.cPointer(), globalPos.cPointer(), &outptr_QHelpEvent, &outptr_QEvent)
	ret := newQHelpEvent(outptr_QHelpEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QHelpEvent) Clone() *QHelpEvent {
	return UnsafeNewQHelpEvent(unsafe.Pointer(C.QHelpEvent_Clone(this.h)), nil)
}

func (this *QHelpEvent) X() int {
	return (int)(C.QHelpEvent_X(this.h))
}

func (this *QHelpEvent) Y() int {
	return (int)(C.QHelpEvent_Y(this.h))
}

func (this *QHelpEvent) GlobalX() int {
	return (int)(C.QHelpEvent_GlobalX(this.h))
}

func (this *QHelpEvent) GlobalY() int {
	return (int)(C.QHelpEvent_GlobalY(this.h))
}

func (this *QHelpEvent) Pos() *QPoint {
	return UnsafeNewQPoint(unsafe.Pointer(C.QHelpEvent_Pos(this.h)))
}

func (this *QHelpEvent) GlobalPos() *QPoint {
	return UnsafeNewQPoint(unsafe.Pointer(C.QHelpEvent_GlobalPos(this.h)))
}

func (this *QHelpEvent) callVirtualBase_Clone() *QHelpEvent {

	return UnsafeNewQHelpEvent(unsafe.Pointer(C.QHelpEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QHelpEvent) OnClone(slot func(super func() *QHelpEvent) *QHelpEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHelpEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHelpEvent_Clone
func miqt_exec_callback_QHelpEvent_Clone(self *C.QHelpEvent, cb C.intptr_t) *C.QHelpEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QHelpEvent) *QHelpEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QHelpEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QHelpEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QHelpEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QHelpEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QHelpEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QHelpEvent_SetAccepted
func miqt_exec_callback_QHelpEvent_SetAccepted(self *C.QHelpEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QHelpEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QHelpEvent) Delete() {
	C.QHelpEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QHelpEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QHelpEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QStatusTipEvent struct {
	h          *C.QStatusTipEvent
	isSubclass bool
	*QEvent
}

func (this *QStatusTipEvent) cPointer() *C.QStatusTipEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QStatusTipEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQStatusTipEvent constructs the type using only CGO pointers.
func newQStatusTipEvent(h *C.QStatusTipEvent, h_QEvent *C.QEvent) *QStatusTipEvent {
	if h == nil {
		return nil
	}
	return &QStatusTipEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQStatusTipEvent constructs the type using only unsafe pointers.
func UnsafeNewQStatusTipEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QStatusTipEvent {
	if h == nil {
		return nil
	}

	return &QStatusTipEvent{h: (*C.QStatusTipEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQStatusTipEvent constructs a new QStatusTipEvent object.
func NewQStatusTipEvent(tip string) *QStatusTipEvent {
	tip_ms := C.struct_miqt_string{}
	tip_ms.data = C.CString(tip)
	tip_ms.len = C.size_t(len(tip))
	defer C.free(unsafe.Pointer(tip_ms.data))
	var outptr_QStatusTipEvent *C.QStatusTipEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QStatusTipEvent_new(tip_ms, &outptr_QStatusTipEvent, &outptr_QEvent)
	ret := newQStatusTipEvent(outptr_QStatusTipEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QStatusTipEvent) Clone() *QStatusTipEvent {
	return UnsafeNewQStatusTipEvent(unsafe.Pointer(C.QStatusTipEvent_Clone(this.h)), nil)
}

func (this *QStatusTipEvent) Tip() string {
	var _ms C.struct_miqt_string = C.QStatusTipEvent_Tip(this.h)
	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
	C.free(unsafe.Pointer(_ms.data))
	return _ret
}

func (this *QStatusTipEvent) callVirtualBase_Clone() *QStatusTipEvent {

	return UnsafeNewQStatusTipEvent(unsafe.Pointer(C.QStatusTipEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QStatusTipEvent) OnClone(slot func(super func() *QStatusTipEvent) *QStatusTipEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QStatusTipEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QStatusTipEvent_Clone
func miqt_exec_callback_QStatusTipEvent_Clone(self *C.QStatusTipEvent, cb C.intptr_t) *C.QStatusTipEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QStatusTipEvent) *QStatusTipEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QStatusTipEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QStatusTipEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QStatusTipEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QStatusTipEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QStatusTipEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QStatusTipEvent_SetAccepted
func miqt_exec_callback_QStatusTipEvent_SetAccepted(self *C.QStatusTipEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QStatusTipEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QStatusTipEvent) Delete() {
	C.QStatusTipEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QStatusTipEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QStatusTipEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QWhatsThisClickedEvent struct {
	h          *C.QWhatsThisClickedEvent
	isSubclass bool
	*QEvent
}

func (this *QWhatsThisClickedEvent) cPointer() *C.QWhatsThisClickedEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QWhatsThisClickedEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQWhatsThisClickedEvent constructs the type using only CGO pointers.
func newQWhatsThisClickedEvent(h *C.QWhatsThisClickedEvent, h_QEvent *C.QEvent) *QWhatsThisClickedEvent {
	if h == nil {
		return nil
	}
	return &QWhatsThisClickedEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQWhatsThisClickedEvent constructs the type using only unsafe pointers.
func UnsafeNewQWhatsThisClickedEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QWhatsThisClickedEvent {
	if h == nil {
		return nil
	}

	return &QWhatsThisClickedEvent{h: (*C.QWhatsThisClickedEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQWhatsThisClickedEvent constructs a new QWhatsThisClickedEvent object.
func NewQWhatsThisClickedEvent(href string) *QWhatsThisClickedEvent {
	href_ms := C.struct_miqt_string{}
	href_ms.data = C.CString(href)
	href_ms.len = C.size_t(len(href))
	defer C.free(unsafe.Pointer(href_ms.data))
	var outptr_QWhatsThisClickedEvent *C.QWhatsThisClickedEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QWhatsThisClickedEvent_new(href_ms, &outptr_QWhatsThisClickedEvent, &outptr_QEvent)
	ret := newQWhatsThisClickedEvent(outptr_QWhatsThisClickedEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QWhatsThisClickedEvent) Clone() *QWhatsThisClickedEvent {
	return UnsafeNewQWhatsThisClickedEvent(unsafe.Pointer(C.QWhatsThisClickedEvent_Clone(this.h)), nil)
}

func (this *QWhatsThisClickedEvent) Href() string {
	var _ms C.struct_miqt_string = C.QWhatsThisClickedEvent_Href(this.h)
	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
	C.free(unsafe.Pointer(_ms.data))
	return _ret
}

func (this *QWhatsThisClickedEvent) callVirtualBase_Clone() *QWhatsThisClickedEvent {

	return UnsafeNewQWhatsThisClickedEvent(unsafe.Pointer(C.QWhatsThisClickedEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QWhatsThisClickedEvent) OnClone(slot func(super func() *QWhatsThisClickedEvent) *QWhatsThisClickedEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWhatsThisClickedEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWhatsThisClickedEvent_Clone
func miqt_exec_callback_QWhatsThisClickedEvent_Clone(self *C.QWhatsThisClickedEvent, cb C.intptr_t) *C.QWhatsThisClickedEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QWhatsThisClickedEvent) *QWhatsThisClickedEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QWhatsThisClickedEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QWhatsThisClickedEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QWhatsThisClickedEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QWhatsThisClickedEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWhatsThisClickedEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWhatsThisClickedEvent_SetAccepted
func miqt_exec_callback_QWhatsThisClickedEvent_SetAccepted(self *C.QWhatsThisClickedEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QWhatsThisClickedEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QWhatsThisClickedEvent) Delete() {
	C.QWhatsThisClickedEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QWhatsThisClickedEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QWhatsThisClickedEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QActionEvent struct {
	h          *C.QActionEvent
	isSubclass bool
	*QEvent
}

func (this *QActionEvent) cPointer() *C.QActionEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QActionEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQActionEvent constructs the type using only CGO pointers.
func newQActionEvent(h *C.QActionEvent, h_QEvent *C.QEvent) *QActionEvent {
	if h == nil {
		return nil
	}
	return &QActionEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQActionEvent constructs the type using only unsafe pointers.
func UnsafeNewQActionEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QActionEvent {
	if h == nil {
		return nil
	}

	return &QActionEvent{h: (*C.QActionEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQActionEvent constructs a new QActionEvent object.
func NewQActionEvent(typeVal int, action *QAction) *QActionEvent {
	var outptr_QActionEvent *C.QActionEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QActionEvent_new((C.int)(typeVal), action.cPointer(), &outptr_QActionEvent, &outptr_QEvent)
	ret := newQActionEvent(outptr_QActionEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQActionEvent2 constructs a new QActionEvent object.
func NewQActionEvent2(typeVal int, action *QAction, before *QAction) *QActionEvent {
	var outptr_QActionEvent *C.QActionEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QActionEvent_new2((C.int)(typeVal), action.cPointer(), before.cPointer(), &outptr_QActionEvent, &outptr_QEvent)
	ret := newQActionEvent(outptr_QActionEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QActionEvent) Clone() *QActionEvent {
	return UnsafeNewQActionEvent(unsafe.Pointer(C.QActionEvent_Clone(this.h)), nil)
}

func (this *QActionEvent) Action() *QAction {
	return UnsafeNewQAction(unsafe.Pointer(C.QActionEvent_Action(this.h)), nil)
}

func (this *QActionEvent) Before() *QAction {
	return UnsafeNewQAction(unsafe.Pointer(C.QActionEvent_Before(this.h)), nil)
}

func (this *QActionEvent) callVirtualBase_Clone() *QActionEvent {

	return UnsafeNewQActionEvent(unsafe.Pointer(C.QActionEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QActionEvent) OnClone(slot func(super func() *QActionEvent) *QActionEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QActionEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QActionEvent_Clone
func miqt_exec_callback_QActionEvent_Clone(self *C.QActionEvent, cb C.intptr_t) *C.QActionEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QActionEvent) *QActionEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QActionEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QActionEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QActionEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QActionEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QActionEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QActionEvent_SetAccepted
func miqt_exec_callback_QActionEvent_SetAccepted(self *C.QActionEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QActionEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QActionEvent) Delete() {
	C.QActionEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QActionEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QActionEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QFileOpenEvent struct {
	h          *C.QFileOpenEvent
	isSubclass bool
	*QEvent
}

func (this *QFileOpenEvent) cPointer() *C.QFileOpenEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QFileOpenEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQFileOpenEvent constructs the type using only CGO pointers.
func newQFileOpenEvent(h *C.QFileOpenEvent, h_QEvent *C.QEvent) *QFileOpenEvent {
	if h == nil {
		return nil
	}
	return &QFileOpenEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQFileOpenEvent constructs the type using only unsafe pointers.
func UnsafeNewQFileOpenEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QFileOpenEvent {
	if h == nil {
		return nil
	}

	return &QFileOpenEvent{h: (*C.QFileOpenEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQFileOpenEvent constructs a new QFileOpenEvent object.
func NewQFileOpenEvent(file string) *QFileOpenEvent {
	file_ms := C.struct_miqt_string{}
	file_ms.data = C.CString(file)
	file_ms.len = C.size_t(len(file))
	defer C.free(unsafe.Pointer(file_ms.data))
	var outptr_QFileOpenEvent *C.QFileOpenEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QFileOpenEvent_new(file_ms, &outptr_QFileOpenEvent, &outptr_QEvent)
	ret := newQFileOpenEvent(outptr_QFileOpenEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQFileOpenEvent2 constructs a new QFileOpenEvent object.
func NewQFileOpenEvent2(url *QUrl) *QFileOpenEvent {
	var outptr_QFileOpenEvent *C.QFileOpenEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QFileOpenEvent_new2(url.cPointer(), &outptr_QFileOpenEvent, &outptr_QEvent)
	ret := newQFileOpenEvent(outptr_QFileOpenEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QFileOpenEvent) Clone() *QFileOpenEvent {
	return UnsafeNewQFileOpenEvent(unsafe.Pointer(C.QFileOpenEvent_Clone(this.h)), nil)
}

func (this *QFileOpenEvent) File() string {
	var _ms C.struct_miqt_string = C.QFileOpenEvent_File(this.h)
	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
	C.free(unsafe.Pointer(_ms.data))
	return _ret
}

func (this *QFileOpenEvent) Url() *QUrl {
	_ret := C.QFileOpenEvent_Url(this.h)
	_goptr := newQUrl(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QFileOpenEvent) OpenFile(file *QFile, flags QIODeviceBase__OpenModeFlag) bool {
	return (bool)(C.QFileOpenEvent_OpenFile(this.h, file.cPointer(), (C.int)(flags)))
}

func (this *QFileOpenEvent) callVirtualBase_Clone() *QFileOpenEvent {

	return UnsafeNewQFileOpenEvent(unsafe.Pointer(C.QFileOpenEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QFileOpenEvent) OnClone(slot func(super func() *QFileOpenEvent) *QFileOpenEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QFileOpenEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QFileOpenEvent_Clone
func miqt_exec_callback_QFileOpenEvent_Clone(self *C.QFileOpenEvent, cb C.intptr_t) *C.QFileOpenEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QFileOpenEvent) *QFileOpenEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QFileOpenEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QFileOpenEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QFileOpenEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QFileOpenEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QFileOpenEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QFileOpenEvent_SetAccepted
func miqt_exec_callback_QFileOpenEvent_SetAccepted(self *C.QFileOpenEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QFileOpenEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QFileOpenEvent) Delete() {
	C.QFileOpenEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QFileOpenEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QFileOpenEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QToolBarChangeEvent struct {
	h          *C.QToolBarChangeEvent
	isSubclass bool
	*QEvent
}

func (this *QToolBarChangeEvent) cPointer() *C.QToolBarChangeEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QToolBarChangeEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQToolBarChangeEvent constructs the type using only CGO pointers.
func newQToolBarChangeEvent(h *C.QToolBarChangeEvent, h_QEvent *C.QEvent) *QToolBarChangeEvent {
	if h == nil {
		return nil
	}
	return &QToolBarChangeEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQToolBarChangeEvent constructs the type using only unsafe pointers.
func UnsafeNewQToolBarChangeEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QToolBarChangeEvent {
	if h == nil {
		return nil
	}

	return &QToolBarChangeEvent{h: (*C.QToolBarChangeEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQToolBarChangeEvent constructs a new QToolBarChangeEvent object.
func NewQToolBarChangeEvent(t bool) *QToolBarChangeEvent {
	var outptr_QToolBarChangeEvent *C.QToolBarChangeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QToolBarChangeEvent_new((C.bool)(t), &outptr_QToolBarChangeEvent, &outptr_QEvent)
	ret := newQToolBarChangeEvent(outptr_QToolBarChangeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QToolBarChangeEvent) Clone() *QToolBarChangeEvent {
	return UnsafeNewQToolBarChangeEvent(unsafe.Pointer(C.QToolBarChangeEvent_Clone(this.h)), nil)
}

func (this *QToolBarChangeEvent) Toggle() bool {
	return (bool)(C.QToolBarChangeEvent_Toggle(this.h))
}

func (this *QToolBarChangeEvent) callVirtualBase_Clone() *QToolBarChangeEvent {

	return UnsafeNewQToolBarChangeEvent(unsafe.Pointer(C.QToolBarChangeEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QToolBarChangeEvent) OnClone(slot func(super func() *QToolBarChangeEvent) *QToolBarChangeEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QToolBarChangeEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QToolBarChangeEvent_Clone
func miqt_exec_callback_QToolBarChangeEvent_Clone(self *C.QToolBarChangeEvent, cb C.intptr_t) *C.QToolBarChangeEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QToolBarChangeEvent) *QToolBarChangeEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QToolBarChangeEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QToolBarChangeEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QToolBarChangeEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QToolBarChangeEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QToolBarChangeEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QToolBarChangeEvent_SetAccepted
func miqt_exec_callback_QToolBarChangeEvent_SetAccepted(self *C.QToolBarChangeEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QToolBarChangeEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QToolBarChangeEvent) Delete() {
	C.QToolBarChangeEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QToolBarChangeEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QToolBarChangeEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QShortcutEvent struct {
	h          *C.QShortcutEvent
	isSubclass bool
	*QEvent
}

func (this *QShortcutEvent) cPointer() *C.QShortcutEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QShortcutEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQShortcutEvent constructs the type using only CGO pointers.
func newQShortcutEvent(h *C.QShortcutEvent, h_QEvent *C.QEvent) *QShortcutEvent {
	if h == nil {
		return nil
	}
	return &QShortcutEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQShortcutEvent constructs the type using only unsafe pointers.
func UnsafeNewQShortcutEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QShortcutEvent {
	if h == nil {
		return nil
	}

	return &QShortcutEvent{h: (*C.QShortcutEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQShortcutEvent constructs a new QShortcutEvent object.
func NewQShortcutEvent(key *QKeySequence, id int) *QShortcutEvent {
	var outptr_QShortcutEvent *C.QShortcutEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QShortcutEvent_new(key.cPointer(), (C.int)(id), &outptr_QShortcutEvent, &outptr_QEvent)
	ret := newQShortcutEvent(outptr_QShortcutEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQShortcutEvent2 constructs a new QShortcutEvent object.
func NewQShortcutEvent2(key *QKeySequence, id int, ambiguous bool) *QShortcutEvent {
	var outptr_QShortcutEvent *C.QShortcutEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QShortcutEvent_new2(key.cPointer(), (C.int)(id), (C.bool)(ambiguous), &outptr_QShortcutEvent, &outptr_QEvent)
	ret := newQShortcutEvent(outptr_QShortcutEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QShortcutEvent) Clone() *QShortcutEvent {
	return UnsafeNewQShortcutEvent(unsafe.Pointer(C.QShortcutEvent_Clone(this.h)), nil)
}

func (this *QShortcutEvent) Key() *QKeySequence {
	return UnsafeNewQKeySequence(unsafe.Pointer(C.QShortcutEvent_Key(this.h)))
}

func (this *QShortcutEvent) ShortcutId() int {
	return (int)(C.QShortcutEvent_ShortcutId(this.h))
}

func (this *QShortcutEvent) IsAmbiguous() bool {
	return (bool)(C.QShortcutEvent_IsAmbiguous(this.h))
}

func (this *QShortcutEvent) callVirtualBase_Clone() *QShortcutEvent {

	return UnsafeNewQShortcutEvent(unsafe.Pointer(C.QShortcutEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QShortcutEvent) OnClone(slot func(super func() *QShortcutEvent) *QShortcutEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QShortcutEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QShortcutEvent_Clone
func miqt_exec_callback_QShortcutEvent_Clone(self *C.QShortcutEvent, cb C.intptr_t) *C.QShortcutEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QShortcutEvent) *QShortcutEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QShortcutEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QShortcutEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QShortcutEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QShortcutEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QShortcutEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QShortcutEvent_SetAccepted
func miqt_exec_callback_QShortcutEvent_SetAccepted(self *C.QShortcutEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QShortcutEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QShortcutEvent) Delete() {
	C.QShortcutEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QShortcutEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QShortcutEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QWindowStateChangeEvent struct {
	h          *C.QWindowStateChangeEvent
	isSubclass bool
	*QEvent
}

func (this *QWindowStateChangeEvent) cPointer() *C.QWindowStateChangeEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QWindowStateChangeEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQWindowStateChangeEvent constructs the type using only CGO pointers.
func newQWindowStateChangeEvent(h *C.QWindowStateChangeEvent, h_QEvent *C.QEvent) *QWindowStateChangeEvent {
	if h == nil {
		return nil
	}
	return &QWindowStateChangeEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQWindowStateChangeEvent constructs the type using only unsafe pointers.
func UnsafeNewQWindowStateChangeEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QWindowStateChangeEvent {
	if h == nil {
		return nil
	}

	return &QWindowStateChangeEvent{h: (*C.QWindowStateChangeEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQWindowStateChangeEvent constructs a new QWindowStateChangeEvent object.
func NewQWindowStateChangeEvent(oldState WindowState) *QWindowStateChangeEvent {
	var outptr_QWindowStateChangeEvent *C.QWindowStateChangeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QWindowStateChangeEvent_new((C.int)(oldState), &outptr_QWindowStateChangeEvent, &outptr_QEvent)
	ret := newQWindowStateChangeEvent(outptr_QWindowStateChangeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQWindowStateChangeEvent2 constructs a new QWindowStateChangeEvent object.
func NewQWindowStateChangeEvent2(oldState WindowState, isOverride bool) *QWindowStateChangeEvent {
	var outptr_QWindowStateChangeEvent *C.QWindowStateChangeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QWindowStateChangeEvent_new2((C.int)(oldState), (C.bool)(isOverride), &outptr_QWindowStateChangeEvent, &outptr_QEvent)
	ret := newQWindowStateChangeEvent(outptr_QWindowStateChangeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QWindowStateChangeEvent) Clone() *QWindowStateChangeEvent {
	return UnsafeNewQWindowStateChangeEvent(unsafe.Pointer(C.QWindowStateChangeEvent_Clone(this.h)), nil)
}

func (this *QWindowStateChangeEvent) OldState() WindowState {
	return (WindowState)(C.QWindowStateChangeEvent_OldState(this.h))
}

func (this *QWindowStateChangeEvent) IsOverride() bool {
	return (bool)(C.QWindowStateChangeEvent_IsOverride(this.h))
}

func (this *QWindowStateChangeEvent) callVirtualBase_Clone() *QWindowStateChangeEvent {

	return UnsafeNewQWindowStateChangeEvent(unsafe.Pointer(C.QWindowStateChangeEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QWindowStateChangeEvent) OnClone(slot func(super func() *QWindowStateChangeEvent) *QWindowStateChangeEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWindowStateChangeEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWindowStateChangeEvent_Clone
func miqt_exec_callback_QWindowStateChangeEvent_Clone(self *C.QWindowStateChangeEvent, cb C.intptr_t) *C.QWindowStateChangeEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QWindowStateChangeEvent) *QWindowStateChangeEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QWindowStateChangeEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QWindowStateChangeEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QWindowStateChangeEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QWindowStateChangeEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QWindowStateChangeEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QWindowStateChangeEvent_SetAccepted
func miqt_exec_callback_QWindowStateChangeEvent_SetAccepted(self *C.QWindowStateChangeEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QWindowStateChangeEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QWindowStateChangeEvent) Delete() {
	C.QWindowStateChangeEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QWindowStateChangeEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QWindowStateChangeEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QTouchEvent struct {
	h          *C.QTouchEvent
	isSubclass bool
	*QPointerEvent
}

func (this *QTouchEvent) cPointer() *C.QTouchEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QTouchEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQTouchEvent constructs the type using only CGO pointers.
func newQTouchEvent(h *C.QTouchEvent, h_QPointerEvent *C.QPointerEvent, h_QInputEvent *C.QInputEvent, h_QEvent *C.QEvent) *QTouchEvent {
	if h == nil {
		return nil
	}
	return &QTouchEvent{h: h,
		QPointerEvent: newQPointerEvent(h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// UnsafeNewQTouchEvent constructs the type using only unsafe pointers.
func UnsafeNewQTouchEvent(h unsafe.Pointer, h_QPointerEvent unsafe.Pointer, h_QInputEvent unsafe.Pointer, h_QEvent unsafe.Pointer) *QTouchEvent {
	if h == nil {
		return nil
	}

	return &QTouchEvent{h: (*C.QTouchEvent)(h),
		QPointerEvent: UnsafeNewQPointerEvent(h_QPointerEvent, h_QInputEvent, h_QEvent)}
}

// NewQTouchEvent constructs a new QTouchEvent object.
func NewQTouchEvent(eventType QEvent__Type) *QTouchEvent {
	var outptr_QTouchEvent *C.QTouchEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTouchEvent_new((C.int)(eventType), &outptr_QTouchEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTouchEvent(outptr_QTouchEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQTouchEvent2 constructs a new QTouchEvent object.
func NewQTouchEvent2(eventType QEvent__Type, device *QPointingDevice, modifiers KeyboardModifier, touchPointStates QEventPoint__State) *QTouchEvent {
	var outptr_QTouchEvent *C.QTouchEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTouchEvent_new2((C.int)(eventType), device.cPointer(), (C.int)(modifiers), (C.uint8_t)(touchPointStates), &outptr_QTouchEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTouchEvent(outptr_QTouchEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQTouchEvent3 constructs a new QTouchEvent object.
func NewQTouchEvent3(eventType QEvent__Type, device *QPointingDevice) *QTouchEvent {
	var outptr_QTouchEvent *C.QTouchEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTouchEvent_new3((C.int)(eventType), device.cPointer(), &outptr_QTouchEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTouchEvent(outptr_QTouchEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQTouchEvent4 constructs a new QTouchEvent object.
func NewQTouchEvent4(eventType QEvent__Type, device *QPointingDevice, modifiers KeyboardModifier) *QTouchEvent {
	var outptr_QTouchEvent *C.QTouchEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTouchEvent_new4((C.int)(eventType), device.cPointer(), (C.int)(modifiers), &outptr_QTouchEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTouchEvent(outptr_QTouchEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQTouchEvent5 constructs a new QTouchEvent object.
func NewQTouchEvent5(eventType QEvent__Type, device *QPointingDevice, modifiers KeyboardModifier, touchPoints []QEventPoint) *QTouchEvent {
	touchPoints_CArray := (*[0xffff]*C.QEventPoint)(C.malloc(C.size_t(8 * len(touchPoints))))
	defer C.free(unsafe.Pointer(touchPoints_CArray))
	for i := range touchPoints {
		touchPoints_CArray[i] = touchPoints[i].cPointer()
	}
	touchPoints_ma := C.struct_miqt_array{len: C.size_t(len(touchPoints)), data: unsafe.Pointer(touchPoints_CArray)}
	var outptr_QTouchEvent *C.QTouchEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTouchEvent_new5((C.int)(eventType), device.cPointer(), (C.int)(modifiers), touchPoints_ma, &outptr_QTouchEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTouchEvent(outptr_QTouchEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

// NewQTouchEvent6 constructs a new QTouchEvent object.
func NewQTouchEvent6(eventType QEvent__Type, device *QPointingDevice, modifiers KeyboardModifier, touchPointStates QEventPoint__State, touchPoints []QEventPoint) *QTouchEvent {
	touchPoints_CArray := (*[0xffff]*C.QEventPoint)(C.malloc(C.size_t(8 * len(touchPoints))))
	defer C.free(unsafe.Pointer(touchPoints_CArray))
	for i := range touchPoints {
		touchPoints_CArray[i] = touchPoints[i].cPointer()
	}
	touchPoints_ma := C.struct_miqt_array{len: C.size_t(len(touchPoints)), data: unsafe.Pointer(touchPoints_CArray)}
	var outptr_QTouchEvent *C.QTouchEvent = nil
	var outptr_QPointerEvent *C.QPointerEvent = nil
	var outptr_QInputEvent *C.QInputEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QTouchEvent_new6((C.int)(eventType), device.cPointer(), (C.int)(modifiers), (C.uint8_t)(touchPointStates), touchPoints_ma, &outptr_QTouchEvent, &outptr_QPointerEvent, &outptr_QInputEvent, &outptr_QEvent)
	ret := newQTouchEvent(outptr_QTouchEvent, outptr_QPointerEvent, outptr_QInputEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QTouchEvent) Clone() *QTouchEvent {
	return UnsafeNewQTouchEvent(unsafe.Pointer(C.QTouchEvent_Clone(this.h)), nil, nil, nil)
}

func (this *QTouchEvent) Target() *QObject {
	return UnsafeNewQObject(unsafe.Pointer(C.QTouchEvent_Target(this.h)))
}

func (this *QTouchEvent) TouchPointStates() QEventPoint__State {
	return (QEventPoint__State)(C.QTouchEvent_TouchPointStates(this.h))
}

func (this *QTouchEvent) TouchPoints() []QEventPoint {
	var _ma C.struct_miqt_array = C.QTouchEvent_TouchPoints(this.h)
	_ret := make([]QEventPoint, int(_ma.len))
	_outCast := (*[0xffff]*C.QEventPoint)(unsafe.Pointer(_ma.data)) // hey ya
	for i := 0; i < int(_ma.len); i++ {
		_lv_ret := _outCast[i]
		_lv_goptr := newQEventPoint(_lv_ret)
		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
		_ret[i] = *_lv_goptr
	}
	return _ret
}

func (this *QTouchEvent) IsBeginEvent() bool {
	return (bool)(C.QTouchEvent_IsBeginEvent(this.h))
}

func (this *QTouchEvent) IsUpdateEvent() bool {
	return (bool)(C.QTouchEvent_IsUpdateEvent(this.h))
}

func (this *QTouchEvent) IsEndEvent() bool {
	return (bool)(C.QTouchEvent_IsEndEvent(this.h))
}

func (this *QTouchEvent) callVirtualBase_Clone() *QTouchEvent {

	return UnsafeNewQTouchEvent(unsafe.Pointer(C.QTouchEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil, nil, nil)
}
func (this *QTouchEvent) OnClone(slot func(super func() *QTouchEvent) *QTouchEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTouchEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTouchEvent_Clone
func miqt_exec_callback_QTouchEvent_Clone(self *C.QTouchEvent, cb C.intptr_t) *C.QTouchEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QTouchEvent) *QTouchEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTouchEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QTouchEvent) callVirtualBase_IsBeginEvent() bool {

	return (bool)(C.QTouchEvent_virtualbase_IsBeginEvent(unsafe.Pointer(this.h)))

}
func (this *QTouchEvent) OnIsBeginEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTouchEvent_override_virtual_IsBeginEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTouchEvent_IsBeginEvent
func miqt_exec_callback_QTouchEvent_IsBeginEvent(self *C.QTouchEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTouchEvent{h: self}).callVirtualBase_IsBeginEvent)

	return (C.bool)(virtualReturn)

}

func (this *QTouchEvent) callVirtualBase_IsUpdateEvent() bool {

	return (bool)(C.QTouchEvent_virtualbase_IsUpdateEvent(unsafe.Pointer(this.h)))

}
func (this *QTouchEvent) OnIsUpdateEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTouchEvent_override_virtual_IsUpdateEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTouchEvent_IsUpdateEvent
func miqt_exec_callback_QTouchEvent_IsUpdateEvent(self *C.QTouchEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTouchEvent{h: self}).callVirtualBase_IsUpdateEvent)

	return (C.bool)(virtualReturn)

}

func (this *QTouchEvent) callVirtualBase_IsEndEvent() bool {

	return (bool)(C.QTouchEvent_virtualbase_IsEndEvent(unsafe.Pointer(this.h)))

}
func (this *QTouchEvent) OnIsEndEvent(slot func(super func() bool) bool) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTouchEvent_override_virtual_IsEndEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTouchEvent_IsEndEvent
func miqt_exec_callback_QTouchEvent_IsEndEvent(self *C.QTouchEvent, cb C.intptr_t) C.bool {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QTouchEvent{h: self}).callVirtualBase_IsEndEvent)

	return (C.bool)(virtualReturn)

}

func (this *QTouchEvent) callVirtualBase_SetTimestamp(timestamp uint64) {

	C.QTouchEvent_virtualbase_SetTimestamp(unsafe.Pointer(this.h), (C.ulonglong)(timestamp))

}
func (this *QTouchEvent) OnSetTimestamp(slot func(super func(timestamp uint64), timestamp uint64)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTouchEvent_override_virtual_SetTimestamp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTouchEvent_SetTimestamp
func miqt_exec_callback_QTouchEvent_SetTimestamp(self *C.QTouchEvent, cb C.intptr_t, timestamp C.ulonglong) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(timestamp uint64), timestamp uint64))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (uint64)(timestamp)

	gofunc((&QTouchEvent{h: self}).callVirtualBase_SetTimestamp, slotval1)

}

func (this *QTouchEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QTouchEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QTouchEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QTouchEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QTouchEvent_SetAccepted
func miqt_exec_callback_QTouchEvent_SetAccepted(self *C.QTouchEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QTouchEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QTouchEvent) Delete() {
	C.QTouchEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QTouchEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QTouchEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QScrollPrepareEvent struct {
	h          *C.QScrollPrepareEvent
	isSubclass bool
	*QEvent
}

func (this *QScrollPrepareEvent) cPointer() *C.QScrollPrepareEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QScrollPrepareEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQScrollPrepareEvent constructs the type using only CGO pointers.
func newQScrollPrepareEvent(h *C.QScrollPrepareEvent, h_QEvent *C.QEvent) *QScrollPrepareEvent {
	if h == nil {
		return nil
	}
	return &QScrollPrepareEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQScrollPrepareEvent constructs the type using only unsafe pointers.
func UnsafeNewQScrollPrepareEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QScrollPrepareEvent {
	if h == nil {
		return nil
	}

	return &QScrollPrepareEvent{h: (*C.QScrollPrepareEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQScrollPrepareEvent constructs a new QScrollPrepareEvent object.
func NewQScrollPrepareEvent(startPos *QPointF) *QScrollPrepareEvent {
	var outptr_QScrollPrepareEvent *C.QScrollPrepareEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QScrollPrepareEvent_new(startPos.cPointer(), &outptr_QScrollPrepareEvent, &outptr_QEvent)
	ret := newQScrollPrepareEvent(outptr_QScrollPrepareEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QScrollPrepareEvent) Clone() *QScrollPrepareEvent {
	return UnsafeNewQScrollPrepareEvent(unsafe.Pointer(C.QScrollPrepareEvent_Clone(this.h)), nil)
}

func (this *QScrollPrepareEvent) StartPos() *QPointF {
	_ret := C.QScrollPrepareEvent_StartPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QScrollPrepareEvent) ViewportSize() *QSizeF {
	_ret := C.QScrollPrepareEvent_ViewportSize(this.h)
	_goptr := newQSizeF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QScrollPrepareEvent) ContentPosRange() *QRectF {
	_ret := C.QScrollPrepareEvent_ContentPosRange(this.h)
	_goptr := newQRectF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QScrollPrepareEvent) ContentPos() *QPointF {
	_ret := C.QScrollPrepareEvent_ContentPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QScrollPrepareEvent) SetViewportSize(size *QSizeF) {
	C.QScrollPrepareEvent_SetViewportSize(this.h, size.cPointer())
}

func (this *QScrollPrepareEvent) SetContentPosRange(rect *QRectF) {
	C.QScrollPrepareEvent_SetContentPosRange(this.h, rect.cPointer())
}

func (this *QScrollPrepareEvent) SetContentPos(pos *QPointF) {
	C.QScrollPrepareEvent_SetContentPos(this.h, pos.cPointer())
}

func (this *QScrollPrepareEvent) callVirtualBase_Clone() *QScrollPrepareEvent {

	return UnsafeNewQScrollPrepareEvent(unsafe.Pointer(C.QScrollPrepareEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QScrollPrepareEvent) OnClone(slot func(super func() *QScrollPrepareEvent) *QScrollPrepareEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QScrollPrepareEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QScrollPrepareEvent_Clone
func miqt_exec_callback_QScrollPrepareEvent_Clone(self *C.QScrollPrepareEvent, cb C.intptr_t) *C.QScrollPrepareEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QScrollPrepareEvent) *QScrollPrepareEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QScrollPrepareEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QScrollPrepareEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QScrollPrepareEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QScrollPrepareEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QScrollPrepareEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QScrollPrepareEvent_SetAccepted
func miqt_exec_callback_QScrollPrepareEvent_SetAccepted(self *C.QScrollPrepareEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QScrollPrepareEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QScrollPrepareEvent) Delete() {
	C.QScrollPrepareEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QScrollPrepareEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QScrollPrepareEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QScrollEvent struct {
	h          *C.QScrollEvent
	isSubclass bool
	*QEvent
}

func (this *QScrollEvent) cPointer() *C.QScrollEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QScrollEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQScrollEvent constructs the type using only CGO pointers.
func newQScrollEvent(h *C.QScrollEvent, h_QEvent *C.QEvent) *QScrollEvent {
	if h == nil {
		return nil
	}
	return &QScrollEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQScrollEvent constructs the type using only unsafe pointers.
func UnsafeNewQScrollEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QScrollEvent {
	if h == nil {
		return nil
	}

	return &QScrollEvent{h: (*C.QScrollEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQScrollEvent constructs a new QScrollEvent object.
func NewQScrollEvent(contentPos *QPointF, overshoot *QPointF, scrollState QScrollEvent__ScrollState) *QScrollEvent {
	var outptr_QScrollEvent *C.QScrollEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QScrollEvent_new(contentPos.cPointer(), overshoot.cPointer(), (C.int)(scrollState), &outptr_QScrollEvent, &outptr_QEvent)
	ret := newQScrollEvent(outptr_QScrollEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QScrollEvent) Clone() *QScrollEvent {
	return UnsafeNewQScrollEvent(unsafe.Pointer(C.QScrollEvent_Clone(this.h)), nil)
}

func (this *QScrollEvent) ContentPos() *QPointF {
	_ret := C.QScrollEvent_ContentPos(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QScrollEvent) OvershootDistance() *QPointF {
	_ret := C.QScrollEvent_OvershootDistance(this.h)
	_goptr := newQPointF(_ret)
	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
	return _goptr
}

func (this *QScrollEvent) ScrollState() QScrollEvent__ScrollState {
	return (QScrollEvent__ScrollState)(C.QScrollEvent_ScrollState(this.h))
}

func (this *QScrollEvent) callVirtualBase_Clone() *QScrollEvent {

	return UnsafeNewQScrollEvent(unsafe.Pointer(C.QScrollEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QScrollEvent) OnClone(slot func(super func() *QScrollEvent) *QScrollEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QScrollEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QScrollEvent_Clone
func miqt_exec_callback_QScrollEvent_Clone(self *C.QScrollEvent, cb C.intptr_t) *C.QScrollEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QScrollEvent) *QScrollEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QScrollEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QScrollEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QScrollEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QScrollEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QScrollEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QScrollEvent_SetAccepted
func miqt_exec_callback_QScrollEvent_SetAccepted(self *C.QScrollEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QScrollEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QScrollEvent) Delete() {
	C.QScrollEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QScrollEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QScrollEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QScreenOrientationChangeEvent struct {
	h          *C.QScreenOrientationChangeEvent
	isSubclass bool
	*QEvent
}

func (this *QScreenOrientationChangeEvent) cPointer() *C.QScreenOrientationChangeEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QScreenOrientationChangeEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQScreenOrientationChangeEvent constructs the type using only CGO pointers.
func newQScreenOrientationChangeEvent(h *C.QScreenOrientationChangeEvent, h_QEvent *C.QEvent) *QScreenOrientationChangeEvent {
	if h == nil {
		return nil
	}
	return &QScreenOrientationChangeEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQScreenOrientationChangeEvent constructs the type using only unsafe pointers.
func UnsafeNewQScreenOrientationChangeEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QScreenOrientationChangeEvent {
	if h == nil {
		return nil
	}

	return &QScreenOrientationChangeEvent{h: (*C.QScreenOrientationChangeEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQScreenOrientationChangeEvent constructs a new QScreenOrientationChangeEvent object.
func NewQScreenOrientationChangeEvent(screen *QScreen, orientation ScreenOrientation) *QScreenOrientationChangeEvent {
	var outptr_QScreenOrientationChangeEvent *C.QScreenOrientationChangeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QScreenOrientationChangeEvent_new(screen.cPointer(), (C.int)(orientation), &outptr_QScreenOrientationChangeEvent, &outptr_QEvent)
	ret := newQScreenOrientationChangeEvent(outptr_QScreenOrientationChangeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QScreenOrientationChangeEvent) Clone() *QScreenOrientationChangeEvent {
	return UnsafeNewQScreenOrientationChangeEvent(unsafe.Pointer(C.QScreenOrientationChangeEvent_Clone(this.h)), nil)
}

func (this *QScreenOrientationChangeEvent) Screen() *QScreen {
	return UnsafeNewQScreen(unsafe.Pointer(C.QScreenOrientationChangeEvent_Screen(this.h)), nil)
}

func (this *QScreenOrientationChangeEvent) Orientation() ScreenOrientation {
	return (ScreenOrientation)(C.QScreenOrientationChangeEvent_Orientation(this.h))
}

func (this *QScreenOrientationChangeEvent) callVirtualBase_Clone() *QScreenOrientationChangeEvent {

	return UnsafeNewQScreenOrientationChangeEvent(unsafe.Pointer(C.QScreenOrientationChangeEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QScreenOrientationChangeEvent) OnClone(slot func(super func() *QScreenOrientationChangeEvent) *QScreenOrientationChangeEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QScreenOrientationChangeEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QScreenOrientationChangeEvent_Clone
func miqt_exec_callback_QScreenOrientationChangeEvent_Clone(self *C.QScreenOrientationChangeEvent, cb C.intptr_t) *C.QScreenOrientationChangeEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QScreenOrientationChangeEvent) *QScreenOrientationChangeEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QScreenOrientationChangeEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QScreenOrientationChangeEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QScreenOrientationChangeEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QScreenOrientationChangeEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QScreenOrientationChangeEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QScreenOrientationChangeEvent_SetAccepted
func miqt_exec_callback_QScreenOrientationChangeEvent_SetAccepted(self *C.QScreenOrientationChangeEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QScreenOrientationChangeEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QScreenOrientationChangeEvent) Delete() {
	C.QScreenOrientationChangeEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QScreenOrientationChangeEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QScreenOrientationChangeEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QApplicationStateChangeEvent struct {
	h          *C.QApplicationStateChangeEvent
	isSubclass bool
	*QEvent
}

func (this *QApplicationStateChangeEvent) cPointer() *C.QApplicationStateChangeEvent {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QApplicationStateChangeEvent) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQApplicationStateChangeEvent constructs the type using only CGO pointers.
func newQApplicationStateChangeEvent(h *C.QApplicationStateChangeEvent, h_QEvent *C.QEvent) *QApplicationStateChangeEvent {
	if h == nil {
		return nil
	}
	return &QApplicationStateChangeEvent{h: h,
		QEvent: newQEvent(h_QEvent)}
}

// UnsafeNewQApplicationStateChangeEvent constructs the type using only unsafe pointers.
func UnsafeNewQApplicationStateChangeEvent(h unsafe.Pointer, h_QEvent unsafe.Pointer) *QApplicationStateChangeEvent {
	if h == nil {
		return nil
	}

	return &QApplicationStateChangeEvent{h: (*C.QApplicationStateChangeEvent)(h),
		QEvent: UnsafeNewQEvent(h_QEvent)}
}

// NewQApplicationStateChangeEvent constructs a new QApplicationStateChangeEvent object.
func NewQApplicationStateChangeEvent(state ApplicationState) *QApplicationStateChangeEvent {
	var outptr_QApplicationStateChangeEvent *C.QApplicationStateChangeEvent = nil
	var outptr_QEvent *C.QEvent = nil

	C.QApplicationStateChangeEvent_new((C.int)(state), &outptr_QApplicationStateChangeEvent, &outptr_QEvent)
	ret := newQApplicationStateChangeEvent(outptr_QApplicationStateChangeEvent, outptr_QEvent)
	ret.isSubclass = true
	return ret
}

func (this *QApplicationStateChangeEvent) Clone() *QApplicationStateChangeEvent {
	return UnsafeNewQApplicationStateChangeEvent(unsafe.Pointer(C.QApplicationStateChangeEvent_Clone(this.h)), nil)
}

func (this *QApplicationStateChangeEvent) ApplicationState() ApplicationState {
	return (ApplicationState)(C.QApplicationStateChangeEvent_ApplicationState(this.h))
}

func (this *QApplicationStateChangeEvent) callVirtualBase_Clone() *QApplicationStateChangeEvent {

	return UnsafeNewQApplicationStateChangeEvent(unsafe.Pointer(C.QApplicationStateChangeEvent_virtualbase_Clone(unsafe.Pointer(this.h))), nil)
}
func (this *QApplicationStateChangeEvent) OnClone(slot func(super func() *QApplicationStateChangeEvent) *QApplicationStateChangeEvent) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QApplicationStateChangeEvent_override_virtual_Clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QApplicationStateChangeEvent_Clone
func miqt_exec_callback_QApplicationStateChangeEvent_Clone(self *C.QApplicationStateChangeEvent, cb C.intptr_t) *C.QApplicationStateChangeEvent {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QApplicationStateChangeEvent) *QApplicationStateChangeEvent)
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	virtualReturn := gofunc((&QApplicationStateChangeEvent{h: self}).callVirtualBase_Clone)

	return virtualReturn.cPointer()

}

func (this *QApplicationStateChangeEvent) callVirtualBase_SetAccepted(accepted bool) {

	C.QApplicationStateChangeEvent_virtualbase_SetAccepted(unsafe.Pointer(this.h), (C.bool)(accepted))

}
func (this *QApplicationStateChangeEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) {
	if !this.isSubclass {
		panic("miqt: can only override virtual methods for directly constructed types")
	}
	C.QApplicationStateChangeEvent_override_virtual_SetAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}

//export miqt_exec_callback_QApplicationStateChangeEvent_SetAccepted
func miqt_exec_callback_QApplicationStateChangeEvent_SetAccepted(self *C.QApplicationStateChangeEvent, cb C.intptr_t, accepted C.bool) {
	gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool))
	if !ok {
		panic("miqt: callback of non-callback type (heap corruption?)")
	}

	// Convert all CABI parameters to Go parameters
	slotval1 := (bool)(accepted)

	gofunc((&QApplicationStateChangeEvent{h: self}).callVirtualBase_SetAccepted, slotval1)

}

// Delete this object from C++ memory.
func (this *QApplicationStateChangeEvent) Delete() {
	C.QApplicationStateChangeEvent_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QApplicationStateChangeEvent) GoGC() {
	runtime.SetFinalizer(this, func(this *QApplicationStateChangeEvent) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}

type QInputMethodEvent__Attribute struct {
	h          *C.QInputMethodEvent__Attribute
	isSubclass bool
}

func (this *QInputMethodEvent__Attribute) cPointer() *C.QInputMethodEvent__Attribute {
	if this == nil {
		return nil
	}
	return this.h
}

func (this *QInputMethodEvent__Attribute) UnsafePointer() unsafe.Pointer {
	if this == nil {
		return nil
	}
	return unsafe.Pointer(this.h)
}

// newQInputMethodEvent__Attribute constructs the type using only CGO pointers.
func newQInputMethodEvent__Attribute(h *C.QInputMethodEvent__Attribute) *QInputMethodEvent__Attribute {
	if h == nil {
		return nil
	}
	return &QInputMethodEvent__Attribute{h: h}
}

// UnsafeNewQInputMethodEvent__Attribute constructs the type using only unsafe pointers.
func UnsafeNewQInputMethodEvent__Attribute(h unsafe.Pointer) *QInputMethodEvent__Attribute {
	if h == nil {
		return nil
	}

	return &QInputMethodEvent__Attribute{h: (*C.QInputMethodEvent__Attribute)(h)}
}

// NewQInputMethodEvent__Attribute constructs a new QInputMethodEvent::Attribute object.
func NewQInputMethodEvent__Attribute(typ QInputMethodEvent__AttributeType, s int, l int, val QVariant) *QInputMethodEvent__Attribute {
	var outptr_QInputMethodEvent__Attribute *C.QInputMethodEvent__Attribute = nil

	C.QInputMethodEvent__Attribute_new((C.int)(typ), (C.int)(s), (C.int)(l), val.cPointer(), &outptr_QInputMethodEvent__Attribute)
	ret := newQInputMethodEvent__Attribute(outptr_QInputMethodEvent__Attribute)
	ret.isSubclass = true
	return ret
}

// NewQInputMethodEvent__Attribute2 constructs a new QInputMethodEvent::Attribute object.
func NewQInputMethodEvent__Attribute2(typ QInputMethodEvent__AttributeType, s int, l int) *QInputMethodEvent__Attribute {
	var outptr_QInputMethodEvent__Attribute *C.QInputMethodEvent__Attribute = nil

	C.QInputMethodEvent__Attribute_new2((C.int)(typ), (C.int)(s), (C.int)(l), &outptr_QInputMethodEvent__Attribute)
	ret := newQInputMethodEvent__Attribute(outptr_QInputMethodEvent__Attribute)
	ret.isSubclass = true
	return ret
}

// NewQInputMethodEvent__Attribute3 constructs a new QInputMethodEvent::Attribute object.
func NewQInputMethodEvent__Attribute3(param1 *QInputMethodEvent__Attribute) *QInputMethodEvent__Attribute {
	var outptr_QInputMethodEvent__Attribute *C.QInputMethodEvent__Attribute = nil

	C.QInputMethodEvent__Attribute_new3(param1.cPointer(), &outptr_QInputMethodEvent__Attribute)
	ret := newQInputMethodEvent__Attribute(outptr_QInputMethodEvent__Attribute)
	ret.isSubclass = true
	return ret
}

func (this *QInputMethodEvent__Attribute) OperatorAssign(param1 *QInputMethodEvent__Attribute) {
	C.QInputMethodEvent__Attribute_OperatorAssign(this.h, param1.cPointer())
}

// Delete this object from C++ memory.
func (this *QInputMethodEvent__Attribute) Delete() {
	C.QInputMethodEvent__Attribute_Delete(this.h, C.bool(this.isSubclass))
}

// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QInputMethodEvent__Attribute) GoGC() {
	runtime.SetFinalizer(this, func(this *QInputMethodEvent__Attribute) {
		this.Delete()
		runtime.KeepAlive(this.h)
	})
}