cutego/quick/quick.go

// +build !minimal

package quick

//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "quick.h"
import "C"
import (
	"fmt"
	"github.com/therecipe/qt"
	"github.com/therecipe/qt/core"
	"github.com/therecipe/qt/gui"
	"github.com/therecipe/qt/qml"
	"github.com/therecipe/qt/widgets"
	"runtime"
	"strings"
	"unsafe"
)

func cGoUnpackString(s C.struct_QtQuick_PackedString) string {
	if len := int(s.len); len == -1 {
		return C.GoString(s.data)
	}
	return C.GoStringN(s.data, C.int(s.len))
}

type QQuickAsyncImageProvider struct {
	QQuickImageProvider
}

type QQuickAsyncImageProvider_ITF interface {
	QQuickImageProvider_ITF
	QQuickAsyncImageProvider_PTR() *QQuickAsyncImageProvider
}

func (ptr *QQuickAsyncImageProvider) QQuickAsyncImageProvider_PTR() *QQuickAsyncImageProvider {
	return ptr
}

func (ptr *QQuickAsyncImageProvider) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickImageProvider_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickAsyncImageProvider) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QQuickImageProvider_PTR().SetPointer(p)
	}
}

func PointerFromQQuickAsyncImageProvider(ptr QQuickAsyncImageProvider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickAsyncImageProvider_PTR().Pointer()
	}
	return nil
}

func NewQQuickAsyncImageProviderFromPointer(ptr unsafe.Pointer) *QQuickAsyncImageProvider {
	var n = new(QQuickAsyncImageProvider)
	n.SetPointer(ptr)
	return n
}
func NewQQuickAsyncImageProvider() *QQuickAsyncImageProvider {
	return NewQQuickAsyncImageProviderFromPointer(C.QQuickAsyncImageProvider_NewQQuickAsyncImageProvider())
}

//export callbackQQuickAsyncImageProvider_RequestImageResponse
func callbackQQuickAsyncImageProvider_RequestImageResponse(ptr unsafe.Pointer, id C.struct_QtQuick_PackedString, requestedSize unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "requestImageResponse"); signal != nil {
		return PointerFromQQuickImageResponse(signal.(func(string, *core.QSize) *QQuickImageResponse)(cGoUnpackString(id), core.NewQSizeFromPointer(requestedSize)))
	}

	return PointerFromQQuickImageResponse(NewQQuickImageResponse())
}

func (ptr *QQuickAsyncImageProvider) ConnectRequestImageResponse(f func(id string, requestedSize *core.QSize) *QQuickImageResponse) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestImageResponse"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestImageResponse", func(id string, requestedSize *core.QSize) *QQuickImageResponse {
				signal.(func(string, *core.QSize) *QQuickImageResponse)(id, requestedSize)
				return f(id, requestedSize)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestImageResponse", f)
		}
	}
}

func (ptr *QQuickAsyncImageProvider) DisconnectRequestImageResponse() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestImageResponse")
	}
}

func (ptr *QQuickAsyncImageProvider) RequestImageResponse(id string, requestedSize core.QSize_ITF) *QQuickImageResponse {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = NewQQuickImageResponseFromPointer(C.QQuickAsyncImageProvider_RequestImageResponse(ptr.Pointer(), idC, core.PointerFromQSize(requestedSize)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQQuickAsyncImageProvider_DestroyQQuickAsyncImageProvider
func callbackQQuickAsyncImageProvider_DestroyQQuickAsyncImageProvider(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickAsyncImageProvider"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickAsyncImageProviderFromPointer(ptr).DestroyQQuickAsyncImageProviderDefault()
	}
}

func (ptr *QQuickAsyncImageProvider) ConnectDestroyQQuickAsyncImageProvider(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickAsyncImageProvider"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickAsyncImageProvider", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickAsyncImageProvider", f)
		}
	}
}

func (ptr *QQuickAsyncImageProvider) DisconnectDestroyQQuickAsyncImageProvider() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickAsyncImageProvider")
	}
}

func (ptr *QQuickAsyncImageProvider) DestroyQQuickAsyncImageProvider() {
	if ptr.Pointer() != nil {
		C.QQuickAsyncImageProvider_DestroyQQuickAsyncImageProvider(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickAsyncImageProvider) DestroyQQuickAsyncImageProviderDefault() {
	if ptr.Pointer() != nil {
		C.QQuickAsyncImageProvider_DestroyQQuickAsyncImageProviderDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

type QQuickFramebufferObject struct {
	QQuickItem
}

type QQuickFramebufferObject_ITF interface {
	QQuickItem_ITF
	QQuickFramebufferObject_PTR() *QQuickFramebufferObject
}

func (ptr *QQuickFramebufferObject) QQuickFramebufferObject_PTR() *QQuickFramebufferObject {
	return ptr
}

func (ptr *QQuickFramebufferObject) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickFramebufferObject) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QQuickItem_PTR().SetPointer(p)
	}
}

func PointerFromQQuickFramebufferObject(ptr QQuickFramebufferObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickFramebufferObject_PTR().Pointer()
	}
	return nil
}

func NewQQuickFramebufferObjectFromPointer(ptr unsafe.Pointer) *QQuickFramebufferObject {
	var n = new(QQuickFramebufferObject)
	n.SetPointer(ptr)
	return n
}

func (ptr *QQuickFramebufferObject) DestroyQQuickFramebufferObject() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickFramebufferObject_MirrorVerticallyChanged
func callbackQQuickFramebufferObject_MirrorVerticallyChanged(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mirrorVerticallyChanged"); signal != nil {
		signal.(func(bool))(int8(vbo) != 0)
	}

}

func (ptr *QQuickFramebufferObject) ConnectMirrorVerticallyChanged(f func(vbo bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mirrorVerticallyChanged") {
			C.QQuickFramebufferObject_ConnectMirrorVerticallyChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mirrorVerticallyChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mirrorVerticallyChanged", func(vbo bool) {
				signal.(func(bool))(vbo)
				f(vbo)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mirrorVerticallyChanged", f)
		}
	}
}

func (ptr *QQuickFramebufferObject) DisconnectMirrorVerticallyChanged() {
	if ptr.Pointer() != nil {
		C.QQuickFramebufferObject_DisconnectMirrorVerticallyChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mirrorVerticallyChanged")
	}
}

func (ptr *QQuickFramebufferObject) MirrorVerticallyChanged(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickFramebufferObject_MirrorVerticallyChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickFramebufferObject) SetMirrorVertically(enable bool) {
	if ptr.Pointer() != nil {
		C.QQuickFramebufferObject_SetMirrorVertically(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QQuickFramebufferObject) SetTextureFollowsItemSize(follows bool) {
	if ptr.Pointer() != nil {
		C.QQuickFramebufferObject_SetTextureFollowsItemSize(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(follows))))
	}
}

//export callbackQQuickFramebufferObject_TextureFollowsItemSizeChanged
func callbackQQuickFramebufferObject_TextureFollowsItemSizeChanged(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureFollowsItemSizeChanged"); signal != nil {
		signal.(func(bool))(int8(vbo) != 0)
	}

}

func (ptr *QQuickFramebufferObject) ConnectTextureFollowsItemSizeChanged(f func(vbo bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "textureFollowsItemSizeChanged") {
			C.QQuickFramebufferObject_ConnectTextureFollowsItemSizeChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureFollowsItemSizeChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureFollowsItemSizeChanged", func(vbo bool) {
				signal.(func(bool))(vbo)
				f(vbo)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureFollowsItemSizeChanged", f)
		}
	}
}

func (ptr *QQuickFramebufferObject) DisconnectTextureFollowsItemSizeChanged() {
	if ptr.Pointer() != nil {
		C.QQuickFramebufferObject_DisconnectTextureFollowsItemSizeChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureFollowsItemSizeChanged")
	}
}

func (ptr *QQuickFramebufferObject) TextureFollowsItemSizeChanged(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickFramebufferObject_TextureFollowsItemSizeChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickFramebufferObject) MirrorVertically() bool {
	if ptr.Pointer() != nil {
		return C.QQuickFramebufferObject_MirrorVertically(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickFramebufferObject) TextureFollowsItemSize() bool {
	if ptr.Pointer() != nil {
		return C.QQuickFramebufferObject_TextureFollowsItemSize(ptr.Pointer()) != 0
	}
	return false
}

type QQuickImageProvider struct {
	qml.QQmlImageProviderBase
}

type QQuickImageProvider_ITF interface {
	qml.QQmlImageProviderBase_ITF
	QQuickImageProvider_PTR() *QQuickImageProvider
}

func (ptr *QQuickImageProvider) QQuickImageProvider_PTR() *QQuickImageProvider {
	return ptr
}

func (ptr *QQuickImageProvider) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QQmlImageProviderBase_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickImageProvider) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QQmlImageProviderBase_PTR().SetPointer(p)
	}
}

func PointerFromQQuickImageProvider(ptr QQuickImageProvider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickImageProvider_PTR().Pointer()
	}
	return nil
}

func NewQQuickImageProviderFromPointer(ptr unsafe.Pointer) *QQuickImageProvider {
	var n = new(QQuickImageProvider)
	n.SetPointer(ptr)
	return n
}

//export callbackQQuickImageProvider_RequestImage
func callbackQQuickImageProvider_RequestImage(ptr unsafe.Pointer, id C.struct_QtQuick_PackedString, size unsafe.Pointer, requestedSize unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "requestImage"); signal != nil {
		return gui.PointerFromQImage(signal.(func(string, *core.QSize, *core.QSize) *gui.QImage)(cGoUnpackString(id), core.NewQSizeFromPointer(size), core.NewQSizeFromPointer(requestedSize)))
	}

	return gui.PointerFromQImage(NewQQuickImageProviderFromPointer(ptr).RequestImageDefault(cGoUnpackString(id), core.NewQSizeFromPointer(size), core.NewQSizeFromPointer(requestedSize)))
}

func (ptr *QQuickImageProvider) ConnectRequestImage(f func(id string, size *core.QSize, requestedSize *core.QSize) *gui.QImage) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestImage"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestImage", func(id string, size *core.QSize, requestedSize *core.QSize) *gui.QImage {
				signal.(func(string, *core.QSize, *core.QSize) *gui.QImage)(id, size, requestedSize)
				return f(id, size, requestedSize)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestImage", f)
		}
	}
}

func (ptr *QQuickImageProvider) DisconnectRequestImage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestImage")
	}
}

func (ptr *QQuickImageProvider) RequestImage(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *gui.QImage {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = gui.NewQImageFromPointer(C.QQuickImageProvider_RequestImage(ptr.Pointer(), idC, core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageProvider) RequestImageDefault(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *gui.QImage {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = gui.NewQImageFromPointer(C.QQuickImageProvider_RequestImageDefault(ptr.Pointer(), idC, core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

//export callbackQQuickImageProvider_RequestPixmap
func callbackQQuickImageProvider_RequestPixmap(ptr unsafe.Pointer, id C.struct_QtQuick_PackedString, size unsafe.Pointer, requestedSize unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "requestPixmap"); signal != nil {
		return gui.PointerFromQPixmap(signal.(func(string, *core.QSize, *core.QSize) *gui.QPixmap)(cGoUnpackString(id), core.NewQSizeFromPointer(size), core.NewQSizeFromPointer(requestedSize)))
	}

	return gui.PointerFromQPixmap(NewQQuickImageProviderFromPointer(ptr).RequestPixmapDefault(cGoUnpackString(id), core.NewQSizeFromPointer(size), core.NewQSizeFromPointer(requestedSize)))
}

func (ptr *QQuickImageProvider) ConnectRequestPixmap(f func(id string, size *core.QSize, requestedSize *core.QSize) *gui.QPixmap) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestPixmap"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestPixmap", func(id string, size *core.QSize, requestedSize *core.QSize) *gui.QPixmap {
				signal.(func(string, *core.QSize, *core.QSize) *gui.QPixmap)(id, size, requestedSize)
				return f(id, size, requestedSize)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestPixmap", f)
		}
	}
}

func (ptr *QQuickImageProvider) DisconnectRequestPixmap() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestPixmap")
	}
}

func (ptr *QQuickImageProvider) RequestPixmap(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = gui.NewQPixmapFromPointer(C.QQuickImageProvider_RequestPixmap(ptr.Pointer(), idC, core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageProvider) RequestPixmapDefault(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = gui.NewQPixmapFromPointer(C.QQuickImageProvider_RequestPixmapDefault(ptr.Pointer(), idC, core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func NewQQuickImageProvider(ty qml.QQmlImageProviderBase__ImageType, flags qml.QQmlImageProviderBase__Flag) *QQuickImageProvider {
	return NewQQuickImageProviderFromPointer(C.QQuickImageProvider_NewQQuickImageProvider(C.longlong(ty), C.longlong(flags)))
}

//export callbackQQuickImageProvider_RequestTexture
func callbackQQuickImageProvider_RequestTexture(ptr unsafe.Pointer, id C.struct_QtQuick_PackedString, size unsafe.Pointer, requestedSize unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "requestTexture"); signal != nil {
		return PointerFromQQuickTextureFactory(signal.(func(string, *core.QSize, *core.QSize) *QQuickTextureFactory)(cGoUnpackString(id), core.NewQSizeFromPointer(size), core.NewQSizeFromPointer(requestedSize)))
	}

	return PointerFromQQuickTextureFactory(NewQQuickImageProviderFromPointer(ptr).RequestTextureDefault(cGoUnpackString(id), core.NewQSizeFromPointer(size), core.NewQSizeFromPointer(requestedSize)))
}

func (ptr *QQuickImageProvider) ConnectRequestTexture(f func(id string, size *core.QSize, requestedSize *core.QSize) *QQuickTextureFactory) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestTexture", func(id string, size *core.QSize, requestedSize *core.QSize) *QQuickTextureFactory {
				signal.(func(string, *core.QSize, *core.QSize) *QQuickTextureFactory)(id, size, requestedSize)
				return f(id, size, requestedSize)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestTexture", f)
		}
	}
}

func (ptr *QQuickImageProvider) DisconnectRequestTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestTexture")
	}
}

func (ptr *QQuickImageProvider) RequestTexture(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *QQuickTextureFactory {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = NewQQuickTextureFactoryFromPointer(C.QQuickImageProvider_RequestTexture(ptr.Pointer(), idC, core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageProvider) RequestTextureDefault(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *QQuickTextureFactory {
	if ptr.Pointer() != nil {
		var idC *C.char
		if id != "" {
			idC = C.CString(id)
			defer C.free(unsafe.Pointer(idC))
		}
		var tmpValue = NewQQuickTextureFactoryFromPointer(C.QQuickImageProvider_RequestTextureDefault(ptr.Pointer(), idC, core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQQuickImageProvider_DestroyQQuickImageProvider
func callbackQQuickImageProvider_DestroyQQuickImageProvider(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickImageProvider"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickImageProviderFromPointer(ptr).DestroyQQuickImageProviderDefault()
	}
}

func (ptr *QQuickImageProvider) ConnectDestroyQQuickImageProvider(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageProvider"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageProvider", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageProvider", f)
		}
	}
}

func (ptr *QQuickImageProvider) DisconnectDestroyQQuickImageProvider() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageProvider")
	}
}

func (ptr *QQuickImageProvider) DestroyQQuickImageProvider() {
	if ptr.Pointer() != nil {
		C.QQuickImageProvider_DestroyQQuickImageProvider(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickImageProvider) DestroyQQuickImageProviderDefault() {
	if ptr.Pointer() != nil {
		C.QQuickImageProvider_DestroyQQuickImageProviderDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickImageProvider_Flags
func callbackQQuickImageProvider_Flags(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "flags"); signal != nil {
		return C.longlong(signal.(func() qml.QQmlImageProviderBase__Flag)())
	}

	return C.longlong(NewQQuickImageProviderFromPointer(ptr).FlagsDefault())
}

func (ptr *QQuickImageProvider) ConnectFlags(f func() qml.QQmlImageProviderBase__Flag) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flags"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", func() qml.QQmlImageProviderBase__Flag {
				signal.(func() qml.QQmlImageProviderBase__Flag)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", f)
		}
	}
}

func (ptr *QQuickImageProvider) DisconnectFlags() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flags")
	}
}

func (ptr *QQuickImageProvider) Flags() qml.QQmlImageProviderBase__Flag {
	if ptr.Pointer() != nil {
		return qml.QQmlImageProviderBase__Flag(C.QQuickImageProvider_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickImageProvider) FlagsDefault() qml.QQmlImageProviderBase__Flag {
	if ptr.Pointer() != nil {
		return qml.QQmlImageProviderBase__Flag(C.QQuickImageProvider_FlagsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQQuickImageProvider_ImageType
func callbackQQuickImageProvider_ImageType(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "imageType"); signal != nil {
		return C.longlong(signal.(func() qml.QQmlImageProviderBase__ImageType)())
	}

	return C.longlong(NewQQuickImageProviderFromPointer(ptr).ImageTypeDefault())
}

func (ptr *QQuickImageProvider) ConnectImageType(f func() qml.QQmlImageProviderBase__ImageType) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageType"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageType", func() qml.QQmlImageProviderBase__ImageType {
				signal.(func() qml.QQmlImageProviderBase__ImageType)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageType", f)
		}
	}
}

func (ptr *QQuickImageProvider) DisconnectImageType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageType")
	}
}

func (ptr *QQuickImageProvider) ImageType() qml.QQmlImageProviderBase__ImageType {
	if ptr.Pointer() != nil {
		return qml.QQmlImageProviderBase__ImageType(C.QQuickImageProvider_ImageType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickImageProvider) ImageTypeDefault() qml.QQmlImageProviderBase__ImageType {
	if ptr.Pointer() != nil {
		return qml.QQmlImageProviderBase__ImageType(C.QQuickImageProvider_ImageTypeDefault(ptr.Pointer()))
	}
	return 0
}

type QQuickImageResponse struct {
	core.QObject
}

type QQuickImageResponse_ITF interface {
	core.QObject_ITF
	QQuickImageResponse_PTR() *QQuickImageResponse
}

func (ptr *QQuickImageResponse) QQuickImageResponse_PTR() *QQuickImageResponse {
	return ptr
}

func (ptr *QQuickImageResponse) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickImageResponse) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQQuickImageResponse(ptr QQuickImageResponse_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickImageResponse_PTR().Pointer()
	}
	return nil
}

func NewQQuickImageResponseFromPointer(ptr unsafe.Pointer) *QQuickImageResponse {
	var n = new(QQuickImageResponse)
	n.SetPointer(ptr)
	return n
}
func NewQQuickImageResponse() *QQuickImageResponse {
	var tmpValue = NewQQuickImageResponseFromPointer(C.QQuickImageResponse_NewQQuickImageResponse())
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQQuickImageResponse_Cancel
func callbackQQuickImageResponse_Cancel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "cancel"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickImageResponseFromPointer(ptr).CancelDefault()
	}
}

func (ptr *QQuickImageResponse) ConnectCancel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancel"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancel", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancel", f)
		}
	}
}

func (ptr *QQuickImageResponse) DisconnectCancel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cancel")
	}
}

func (ptr *QQuickImageResponse) Cancel() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_Cancel(ptr.Pointer())
	}
}

func (ptr *QQuickImageResponse) CancelDefault() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_CancelDefault(ptr.Pointer())
	}
}

//export callbackQQuickImageResponse_Finished
func callbackQQuickImageResponse_Finished(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "finished"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickImageResponse) ConnectFinished(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
			C.QQuickImageResponse_ConnectFinished(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
		}
	}
}

func (ptr *QQuickImageResponse) DisconnectFinished() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "finished")
	}
}

func (ptr *QQuickImageResponse) Finished() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_Finished(ptr.Pointer())
	}
}

//export callbackQQuickImageResponse_DestroyQQuickImageResponse
func callbackQQuickImageResponse_DestroyQQuickImageResponse(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickImageResponse"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickImageResponseFromPointer(ptr).DestroyQQuickImageResponseDefault()
	}
}

func (ptr *QQuickImageResponse) ConnectDestroyQQuickImageResponse(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageResponse"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageResponse", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageResponse", f)
		}
	}
}

func (ptr *QQuickImageResponse) DisconnectDestroyQQuickImageResponse() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickImageResponse")
	}
}

func (ptr *QQuickImageResponse) DestroyQQuickImageResponse() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_DestroyQQuickImageResponse(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickImageResponse) DestroyQQuickImageResponseDefault() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_DestroyQQuickImageResponseDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickImageResponse_TextureFactory
func callbackQQuickImageResponse_TextureFactory(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureFactory"); signal != nil {
		return PointerFromQQuickTextureFactory(signal.(func() *QQuickTextureFactory)())
	}

	return PointerFromQQuickTextureFactory(NewQQuickTextureFactory())
}

func (ptr *QQuickImageResponse) ConnectTextureFactory(f func() *QQuickTextureFactory) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureFactory"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureFactory", func() *QQuickTextureFactory {
				signal.(func() *QQuickTextureFactory)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureFactory", f)
		}
	}
}

func (ptr *QQuickImageResponse) DisconnectTextureFactory() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureFactory")
	}
}

func (ptr *QQuickImageResponse) TextureFactory() *QQuickTextureFactory {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickTextureFactoryFromPointer(C.QQuickImageResponse_TextureFactory(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQQuickImageResponse_ErrorString
func callbackQQuickImageResponse_ErrorString(ptr unsafe.Pointer) *C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "errorString"); signal != nil {
		return C.CString(signal.(func() string)())
	}

	return C.CString(NewQQuickImageResponseFromPointer(ptr).ErrorStringDefault())
}

func (ptr *QQuickImageResponse) ConnectErrorString(f func() string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorString"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", func() string {
				signal.(func() string)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", f)
		}
	}
}

func (ptr *QQuickImageResponse) DisconnectErrorString() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "errorString")
	}
}

func (ptr *QQuickImageResponse) ErrorString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QQuickImageResponse_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QQuickImageResponse) ErrorStringDefault() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QQuickImageResponse_ErrorStringDefault(ptr.Pointer()))
	}
	return ""
}

func (ptr *QQuickImageResponse) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickImageResponse___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageResponse) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickImageResponse) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickImageResponse___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickImageResponse) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickImageResponse___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageResponse) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickImageResponse) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickImageResponse___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickImageResponse) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickImageResponse___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageResponse) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickImageResponse) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickImageResponse___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickImageResponse) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickImageResponse___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageResponse) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickImageResponse) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickImageResponse___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickImageResponse) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickImageResponse___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickImageResponse) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickImageResponse) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickImageResponse___children_newList(ptr.Pointer()))
}

//export callbackQQuickImageResponse_Event
func callbackQQuickImageResponse_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickImageResponseFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QQuickImageResponse) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickImageResponse_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQQuickImageResponse_EventFilter
func callbackQQuickImageResponse_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickImageResponseFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickImageResponse) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickImageResponse_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickImageResponse_ChildEvent
func callbackQQuickImageResponse_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickImageResponseFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickImageResponse) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickImageResponse_ConnectNotify
func callbackQQuickImageResponse_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickImageResponseFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickImageResponse) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickImageResponse_CustomEvent
func callbackQQuickImageResponse_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickImageResponseFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickImageResponse) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickImageResponse_DeleteLater
func callbackQQuickImageResponse_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickImageResponseFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickImageResponse) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickImageResponse_Destroyed
func callbackQQuickImageResponse_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickImageResponse_DisconnectNotify
func callbackQQuickImageResponse_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickImageResponseFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickImageResponse) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickImageResponse_ObjectNameChanged
func callbackQQuickImageResponse_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickImageResponse_TimerEvent
func callbackQQuickImageResponse_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickImageResponseFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickImageResponse) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickImageResponse_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickImageResponse_MetaObject
func callbackQQuickImageResponse_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickImageResponseFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickImageResponse) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickImageResponse_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickItem struct {
	core.QObject
	qml.QQmlParserStatus
}

type QQuickItem_ITF interface {
	core.QObject_ITF
	qml.QQmlParserStatus_ITF
	QQuickItem_PTR() *QQuickItem
}

func (ptr *QQuickItem) QQuickItem_PTR() *QQuickItem {
	return ptr
}

func (ptr *QQuickItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
		ptr.QQmlParserStatus_PTR().SetPointer(p)
	}
}

func PointerFromQQuickItem(ptr QQuickItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickItem_PTR().Pointer()
	}
	return nil
}

func NewQQuickItemFromPointer(ptr unsafe.Pointer) *QQuickItem {
	var n = new(QQuickItem)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QQuickItem__Flag
//QQuickItem::Flag
type QQuickItem__Flag int64

const (
	QQuickItem__ItemClipsChildrenToShape QQuickItem__Flag = QQuickItem__Flag(0x01)
	QQuickItem__ItemAcceptsInputMethod   QQuickItem__Flag = QQuickItem__Flag(0x02)
	QQuickItem__ItemIsFocusScope         QQuickItem__Flag = QQuickItem__Flag(0x04)
	QQuickItem__ItemHasContents          QQuickItem__Flag = QQuickItem__Flag(0x08)
	QQuickItem__ItemAcceptsDrops         QQuickItem__Flag = QQuickItem__Flag(0x10)
)

//go:generate stringer -type=QQuickItem__ItemChange
//QQuickItem::ItemChange
type QQuickItem__ItemChange int64

const (
	QQuickItem__ItemChildAddedChange           QQuickItem__ItemChange = QQuickItem__ItemChange(0)
	QQuickItem__ItemChildRemovedChange         QQuickItem__ItemChange = QQuickItem__ItemChange(1)
	QQuickItem__ItemSceneChange                QQuickItem__ItemChange = QQuickItem__ItemChange(2)
	QQuickItem__ItemVisibleHasChanged          QQuickItem__ItemChange = QQuickItem__ItemChange(3)
	QQuickItem__ItemParentHasChanged           QQuickItem__ItemChange = QQuickItem__ItemChange(4)
	QQuickItem__ItemOpacityHasChanged          QQuickItem__ItemChange = QQuickItem__ItemChange(5)
	QQuickItem__ItemActiveFocusHasChanged      QQuickItem__ItemChange = QQuickItem__ItemChange(6)
	QQuickItem__ItemRotationHasChanged         QQuickItem__ItemChange = QQuickItem__ItemChange(7)
	QQuickItem__ItemAntialiasingHasChanged     QQuickItem__ItemChange = QQuickItem__ItemChange(8)
	QQuickItem__ItemDevicePixelRatioHasChanged QQuickItem__ItemChange = QQuickItem__ItemChange(9)
)

//go:generate stringer -type=QQuickItem__TransformOrigin
//QQuickItem::TransformOrigin
type QQuickItem__TransformOrigin int64

const (
	QQuickItem__TopLeft     QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(0)
	QQuickItem__Top         QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(1)
	QQuickItem__TopRight    QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(2)
	QQuickItem__Left        QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(3)
	QQuickItem__Center      QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(4)
	QQuickItem__Right       QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(5)
	QQuickItem__BottomLeft  QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(6)
	QQuickItem__Bottom      QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(7)
	QQuickItem__BottomRight QQuickItem__TransformOrigin = QQuickItem__TransformOrigin(8)
)

func (ptr *QQuickItem) NextItemInFocusChain(forward bool) *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickItem_NextItemInFocusChain(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(forward)))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQQuickItem(parent QQuickItem_ITF) *QQuickItem {
	var tmpValue = NewQQuickItemFromPointer(C.QQuickItem_NewQQuickItem(PointerFromQQuickItem(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QQuickItem) ChildrenRect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QQuickItem_ChildrenRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQQuickItem_ChildMouseEventFilter
func callbackQQuickItem_ChildMouseEventFilter(ptr unsafe.Pointer, item unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childMouseEventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*QQuickItem, *core.QEvent) bool)(NewQQuickItemFromPointer(item), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemFromPointer(ptr).ChildMouseEventFilterDefault(NewQQuickItemFromPointer(item), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickItem) ConnectChildMouseEventFilter(f func(item *QQuickItem, event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "childMouseEventFilter"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "childMouseEventFilter", func(item *QQuickItem, event *core.QEvent) bool {
				signal.(func(*QQuickItem, *core.QEvent) bool)(item, event)
				return f(item, event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "childMouseEventFilter", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectChildMouseEventFilter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "childMouseEventFilter")
	}
}

func (ptr *QQuickItem) ChildMouseEventFilter(item QQuickItem_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_ChildMouseEventFilter(ptr.Pointer(), PointerFromQQuickItem(item), core.PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QQuickItem) ChildMouseEventFilterDefault(item QQuickItem_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_ChildMouseEventFilterDefault(ptr.Pointer(), PointerFromQQuickItem(item), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickItem_Event
func callbackQQuickItem_Event(ptr unsafe.Pointer, ev unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(ev)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemFromPointer(ptr).EventDefault(core.NewQEventFromPointer(ev)))))
}

func (ptr *QQuickItem) ConnectEvent(f func(ev *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "event"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "event", func(ev *core.QEvent) bool {
				signal.(func(*core.QEvent) bool)(ev)
				return f(ev)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "event", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "event")
	}
}

func (ptr *QQuickItem) Event(ev core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_Event(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
	}
	return false
}

func (ptr *QQuickItem) EventDefault(ev core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_EventDefault(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
	}
	return false
}

//export callbackQQuickItem_ClassBegin
func callbackQQuickItem_ClassBegin(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "classBegin"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).ClassBeginDefault()
	}
}

func (ptr *QQuickItem) ConnectClassBegin(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "classBegin"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "classBegin", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "classBegin", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectClassBegin() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "classBegin")
	}
}

func (ptr *QQuickItem) ClassBegin() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ClassBegin(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ClassBeginDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ClassBeginDefault(ptr.Pointer())
	}
}

//export callbackQQuickItem_ComponentComplete
func callbackQQuickItem_ComponentComplete(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "componentComplete"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).ComponentCompleteDefault()
	}
}

func (ptr *QQuickItem) ConnectComponentComplete(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "componentComplete"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "componentComplete", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "componentComplete", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectComponentComplete() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "componentComplete")
	}
}

func (ptr *QQuickItem) ComponentComplete() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ComponentComplete(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ComponentCompleteDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ComponentCompleteDefault(ptr.Pointer())
	}
}

//export callbackQQuickItem_DragEnterEvent
func callbackQQuickItem_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dragEnterEvent"); signal != nil {
		signal.(func(*gui.QDragEnterEvent))(gui.NewQDragEnterEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).DragEnterEventDefault(gui.NewQDragEnterEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectDragEnterEvent(f func(event *gui.QDragEnterEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dragEnterEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dragEnterEvent", func(event *gui.QDragEnterEvent) {
				signal.(func(*gui.QDragEnterEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dragEnterEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectDragEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "dragEnterEvent")
	}
}

func (ptr *QQuickItem) DragEnterEvent(event gui.QDragEnterEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DragEnterEvent(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
	}
}

func (ptr *QQuickItem) DragEnterEventDefault(event gui.QDragEnterEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DragEnterEventDefault(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
	}
}

//export callbackQQuickItem_DragLeaveEvent
func callbackQQuickItem_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dragLeaveEvent"); signal != nil {
		signal.(func(*gui.QDragLeaveEvent))(gui.NewQDragLeaveEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).DragLeaveEventDefault(gui.NewQDragLeaveEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectDragLeaveEvent(f func(event *gui.QDragLeaveEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dragLeaveEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dragLeaveEvent", func(event *gui.QDragLeaveEvent) {
				signal.(func(*gui.QDragLeaveEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dragLeaveEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectDragLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "dragLeaveEvent")
	}
}

func (ptr *QQuickItem) DragLeaveEvent(event gui.QDragLeaveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DragLeaveEvent(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
	}
}

func (ptr *QQuickItem) DragLeaveEventDefault(event gui.QDragLeaveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DragLeaveEventDefault(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
	}
}

//export callbackQQuickItem_DragMoveEvent
func callbackQQuickItem_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dragMoveEvent"); signal != nil {
		signal.(func(*gui.QDragMoveEvent))(gui.NewQDragMoveEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).DragMoveEventDefault(gui.NewQDragMoveEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectDragMoveEvent(f func(event *gui.QDragMoveEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dragMoveEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dragMoveEvent", func(event *gui.QDragMoveEvent) {
				signal.(func(*gui.QDragMoveEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dragMoveEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectDragMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "dragMoveEvent")
	}
}

func (ptr *QQuickItem) DragMoveEvent(event gui.QDragMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DragMoveEvent(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
	}
}

func (ptr *QQuickItem) DragMoveEventDefault(event gui.QDragMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DragMoveEventDefault(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
	}
}

//export callbackQQuickItem_DropEvent
func callbackQQuickItem_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dropEvent"); signal != nil {
		signal.(func(*gui.QDropEvent))(gui.NewQDropEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).DropEventDefault(gui.NewQDropEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectDropEvent(f func(event *gui.QDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dropEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dropEvent", func(event *gui.QDropEvent) {
				signal.(func(*gui.QDropEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dropEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectDropEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "dropEvent")
	}
}

func (ptr *QQuickItem) DropEvent(event gui.QDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DropEvent(ptr.Pointer(), gui.PointerFromQDropEvent(event))
	}
}

func (ptr *QQuickItem) DropEventDefault(event gui.QDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DropEventDefault(ptr.Pointer(), gui.PointerFromQDropEvent(event))
	}
}

//export callbackQQuickItem_FocusInEvent
func callbackQQuickItem_FocusInEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusInEvent"); signal != nil {
		signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectFocusInEvent(f func(event *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusInEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusInEvent", func(event *gui.QFocusEvent) {
				signal.(func(*gui.QFocusEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusInEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectFocusInEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusInEvent")
	}
}

func (ptr *QQuickItem) FocusInEvent(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QQuickItem) FocusInEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

//export callbackQQuickItem_FocusOutEvent
func callbackQQuickItem_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusOutEvent"); signal != nil {
		signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectFocusOutEvent(f func(event *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusOutEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusOutEvent", func(event *gui.QFocusEvent) {
				signal.(func(*gui.QFocusEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusOutEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectFocusOutEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusOutEvent")
	}
}

func (ptr *QQuickItem) FocusOutEvent(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QQuickItem) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QQuickItem) ForceActiveFocus() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ForceActiveFocus(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ForceActiveFocus2(reason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QQuickItem_ForceActiveFocus2(ptr.Pointer(), C.longlong(reason))
	}
}

//export callbackQQuickItem_GeometryChanged
func callbackQQuickItem_GeometryChanged(ptr unsafe.Pointer, newGeometry unsafe.Pointer, oldGeometry unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "geometryChanged"); signal != nil {
		signal.(func(*core.QRectF, *core.QRectF))(core.NewQRectFFromPointer(newGeometry), core.NewQRectFFromPointer(oldGeometry))
	} else {
		NewQQuickItemFromPointer(ptr).GeometryChangedDefault(core.NewQRectFFromPointer(newGeometry), core.NewQRectFFromPointer(oldGeometry))
	}
}

func (ptr *QQuickItem) ConnectGeometryChanged(f func(newGeometry *core.QRectF, oldGeometry *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "geometryChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "geometryChanged", func(newGeometry *core.QRectF, oldGeometry *core.QRectF) {
				signal.(func(*core.QRectF, *core.QRectF))(newGeometry, oldGeometry)
				f(newGeometry, oldGeometry)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "geometryChanged", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectGeometryChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "geometryChanged")
	}
}

func (ptr *QQuickItem) GeometryChanged(newGeometry core.QRectF_ITF, oldGeometry core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_GeometryChanged(ptr.Pointer(), core.PointerFromQRectF(newGeometry), core.PointerFromQRectF(oldGeometry))
	}
}

func (ptr *QQuickItem) GeometryChangedDefault(newGeometry core.QRectF_ITF, oldGeometry core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_GeometryChangedDefault(ptr.Pointer(), core.PointerFromQRectF(newGeometry), core.PointerFromQRectF(oldGeometry))
	}
}

func (ptr *QQuickItem) GrabMouse() {
	if ptr.Pointer() != nil {
		C.QQuickItem_GrabMouse(ptr.Pointer())
	}
}

func (ptr *QQuickItem) GrabTouchPoints(ids []int) {
	if ptr.Pointer() != nil {
		C.QQuickItem_GrabTouchPoints(ptr.Pointer(), func() unsafe.Pointer {
			var tmpList = NewQQuickItemFromPointer(NewQQuickItemFromPointer(nil).__grabTouchPoints_ids_newList())
			for _, v := range ids {
				tmpList.__grabTouchPoints_ids_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQQuickItem_HoverEnterEvent
func callbackQQuickItem_HoverEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hoverEnterEvent"); signal != nil {
		signal.(func(*gui.QHoverEvent))(gui.NewQHoverEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).HoverEnterEventDefault(gui.NewQHoverEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectHoverEnterEvent(f func(event *gui.QHoverEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hoverEnterEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hoverEnterEvent", func(event *gui.QHoverEvent) {
				signal.(func(*gui.QHoverEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hoverEnterEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectHoverEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hoverEnterEvent")
	}
}

func (ptr *QQuickItem) HoverEnterEvent(event gui.QHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_HoverEnterEvent(ptr.Pointer(), gui.PointerFromQHoverEvent(event))
	}
}

func (ptr *QQuickItem) HoverEnterEventDefault(event gui.QHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_HoverEnterEventDefault(ptr.Pointer(), gui.PointerFromQHoverEvent(event))
	}
}

//export callbackQQuickItem_HoverLeaveEvent
func callbackQQuickItem_HoverLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hoverLeaveEvent"); signal != nil {
		signal.(func(*gui.QHoverEvent))(gui.NewQHoverEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).HoverLeaveEventDefault(gui.NewQHoverEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectHoverLeaveEvent(f func(event *gui.QHoverEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hoverLeaveEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hoverLeaveEvent", func(event *gui.QHoverEvent) {
				signal.(func(*gui.QHoverEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hoverLeaveEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectHoverLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hoverLeaveEvent")
	}
}

func (ptr *QQuickItem) HoverLeaveEvent(event gui.QHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_HoverLeaveEvent(ptr.Pointer(), gui.PointerFromQHoverEvent(event))
	}
}

func (ptr *QQuickItem) HoverLeaveEventDefault(event gui.QHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_HoverLeaveEventDefault(ptr.Pointer(), gui.PointerFromQHoverEvent(event))
	}
}

//export callbackQQuickItem_HoverMoveEvent
func callbackQQuickItem_HoverMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hoverMoveEvent"); signal != nil {
		signal.(func(*gui.QHoverEvent))(gui.NewQHoverEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).HoverMoveEventDefault(gui.NewQHoverEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectHoverMoveEvent(f func(event *gui.QHoverEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hoverMoveEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hoverMoveEvent", func(event *gui.QHoverEvent) {
				signal.(func(*gui.QHoverEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hoverMoveEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectHoverMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hoverMoveEvent")
	}
}

func (ptr *QQuickItem) HoverMoveEvent(event gui.QHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_HoverMoveEvent(ptr.Pointer(), gui.PointerFromQHoverEvent(event))
	}
}

func (ptr *QQuickItem) HoverMoveEventDefault(event gui.QHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_HoverMoveEventDefault(ptr.Pointer(), gui.PointerFromQHoverEvent(event))
	}
}

//export callbackQQuickItem_InputMethodEvent
func callbackQQuickItem_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodEvent"); signal != nil {
		signal.(func(*gui.QInputMethodEvent))(gui.NewQInputMethodEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectInputMethodEvent(f func(event *gui.QInputMethodEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "inputMethodEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "inputMethodEvent", func(event *gui.QInputMethodEvent) {
				signal.(func(*gui.QInputMethodEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "inputMethodEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectInputMethodEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "inputMethodEvent")
	}
}

func (ptr *QQuickItem) InputMethodEvent(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_InputMethodEvent(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

func (ptr *QQuickItem) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

//export callbackQQuickItem_KeyPressEvent
func callbackQQuickItem_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "keyPressEvent"); signal != nil {
		signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectKeyPressEvent(f func(event *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "keyPressEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keyPressEvent", func(event *gui.QKeyEvent) {
				signal.(func(*gui.QKeyEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keyPressEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectKeyPressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "keyPressEvent")
	}
}

func (ptr *QQuickItem) KeyPressEvent(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_KeyPressEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

func (ptr *QQuickItem) KeyPressEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQQuickItem_KeyReleaseEvent
func callbackQQuickItem_KeyReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "keyReleaseEvent"); signal != nil {
		signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectKeyReleaseEvent(f func(event *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "keyReleaseEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keyReleaseEvent", func(event *gui.QKeyEvent) {
				signal.(func(*gui.QKeyEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keyReleaseEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectKeyReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "keyReleaseEvent")
	}
}

func (ptr *QQuickItem) KeyReleaseEvent(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_KeyReleaseEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

func (ptr *QQuickItem) KeyReleaseEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQQuickItem_MouseDoubleClickEvent
func callbackQQuickItem_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseDoubleClickEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).MouseDoubleClickEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectMouseDoubleClickEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mouseDoubleClickEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseDoubleClickEvent", func(event *gui.QMouseEvent) {
				signal.(func(*gui.QMouseEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseDoubleClickEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectMouseDoubleClickEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mouseDoubleClickEvent")
	}
}

func (ptr *QQuickItem) MouseDoubleClickEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseDoubleClickEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QQuickItem) MouseDoubleClickEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseDoubleClickEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickItem_MouseMoveEvent
func callbackQQuickItem_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseMoveEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).MouseMoveEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectMouseMoveEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mouseMoveEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseMoveEvent", func(event *gui.QMouseEvent) {
				signal.(func(*gui.QMouseEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseMoveEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectMouseMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mouseMoveEvent")
	}
}

func (ptr *QQuickItem) MouseMoveEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseMoveEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QQuickItem) MouseMoveEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseMoveEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickItem_MousePressEvent
func callbackQQuickItem_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mousePressEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).MousePressEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectMousePressEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mousePressEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mousePressEvent", func(event *gui.QMouseEvent) {
				signal.(func(*gui.QMouseEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mousePressEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectMousePressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mousePressEvent")
	}
}

func (ptr *QQuickItem) MousePressEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MousePressEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QQuickItem) MousePressEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MousePressEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickItem_MouseReleaseEvent
func callbackQQuickItem_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseReleaseEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).MouseReleaseEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectMouseReleaseEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mouseReleaseEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseReleaseEvent", func(event *gui.QMouseEvent) {
				signal.(func(*gui.QMouseEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseReleaseEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectMouseReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mouseReleaseEvent")
	}
}

func (ptr *QQuickItem) MouseReleaseEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseReleaseEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QQuickItem) MouseReleaseEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseReleaseEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickItem_MouseUngrabEvent
func callbackQQuickItem_MouseUngrabEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseUngrabEvent"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).MouseUngrabEventDefault()
	}
}

func (ptr *QQuickItem) ConnectMouseUngrabEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mouseUngrabEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseUngrabEvent", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mouseUngrabEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectMouseUngrabEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mouseUngrabEvent")
	}
}

func (ptr *QQuickItem) MouseUngrabEvent() {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseUngrabEvent(ptr.Pointer())
	}
}

func (ptr *QQuickItem) MouseUngrabEventDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_MouseUngrabEventDefault(ptr.Pointer())
	}
}

func (ptr *QQuickItem) Polish() {
	if ptr.Pointer() != nil {
		C.QQuickItem_Polish(ptr.Pointer())
	}
}

//export callbackQQuickItem_ReleaseResources
func callbackQQuickItem_ReleaseResources(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "releaseResources"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).ReleaseResourcesDefault()
	}
}

func (ptr *QQuickItem) ConnectReleaseResources(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "releaseResources"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectReleaseResources() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources")
	}
}

func (ptr *QQuickItem) ReleaseResources() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ReleaseResources(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ReleaseResourcesDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ReleaseResourcesDefault(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ResetAntialiasing() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ResetAntialiasing(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ResetHeight() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ResetHeight(ptr.Pointer())
	}
}

func (ptr *QQuickItem) ResetWidth() {
	if ptr.Pointer() != nil {
		C.QQuickItem_ResetWidth(ptr.Pointer())
	}
}

func (ptr *QQuickItem) SetAcceptHoverEvents(enabled bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetAcceptHoverEvents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QQuickItem) SetAcceptedMouseButtons(buttons core.Qt__MouseButton) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetAcceptedMouseButtons(ptr.Pointer(), C.longlong(buttons))
	}
}

func (ptr *QQuickItem) SetActiveFocusOnTab(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetActiveFocusOnTab(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetAntialiasing(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetAntialiasing(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetBaselineOffset(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetBaselineOffset(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetClip(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetClip(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetCursor(cursor gui.QCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetCursor(ptr.Pointer(), gui.PointerFromQCursor(cursor))
	}
}

func (ptr *QQuickItem) SetEnabled(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetFiltersChildMouseEvents(filter bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetFiltersChildMouseEvents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(filter))))
	}
}

func (ptr *QQuickItem) SetFlag(flag QQuickItem__Flag, enabled bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetFlag(ptr.Pointer(), C.longlong(flag), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QQuickItem) SetFlags(flags QQuickItem__Flag) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QQuickItem) SetFocus(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetFocus2(focus bool, reason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetFocus2(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(focus))), C.longlong(reason))
	}
}

func (ptr *QQuickItem) SetHeight(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetHeight(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetImplicitHeight(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetImplicitHeight(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetImplicitWidth(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetImplicitWidth(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetKeepMouseGrab(keep bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetKeepMouseGrab(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(keep))))
	}
}

func (ptr *QQuickItem) SetKeepTouchGrab(keep bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetKeepTouchGrab(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(keep))))
	}
}

func (ptr *QQuickItem) SetOpacity(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetOpacity(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetParentItem(parent QQuickItem_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetParentItem(ptr.Pointer(), PointerFromQQuickItem(parent))
	}
}

func (ptr *QQuickItem) SetRotation(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetRotation(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetScale(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetScale(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetSmooth(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetSmooth(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetState(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QQuickItem_SetState(ptr.Pointer(), vqsC)
	}
}

func (ptr *QQuickItem) SetTransformOrigin(vtr QQuickItem__TransformOrigin) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetTransformOrigin(ptr.Pointer(), C.longlong(vtr))
	}
}

func (ptr *QQuickItem) SetVisible(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QQuickItem) SetWidth(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetWidth(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetX(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetX(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetY(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetY(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) SetZ(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickItem_SetZ(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickItem) StackAfter(sibling QQuickItem_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_StackAfter(ptr.Pointer(), PointerFromQQuickItem(sibling))
	}
}

func (ptr *QQuickItem) StackBefore(sibling QQuickItem_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_StackBefore(ptr.Pointer(), PointerFromQQuickItem(sibling))
	}
}

//export callbackQQuickItem_TouchEvent
func callbackQQuickItem_TouchEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "touchEvent"); signal != nil {
		signal.(func(*gui.QTouchEvent))(gui.NewQTouchEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).TouchEventDefault(gui.NewQTouchEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectTouchEvent(f func(event *gui.QTouchEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "touchEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "touchEvent", func(event *gui.QTouchEvent) {
				signal.(func(*gui.QTouchEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "touchEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectTouchEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "touchEvent")
	}
}

func (ptr *QQuickItem) TouchEvent(event gui.QTouchEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_TouchEvent(ptr.Pointer(), gui.PointerFromQTouchEvent(event))
	}
}

func (ptr *QQuickItem) TouchEventDefault(event gui.QTouchEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_TouchEventDefault(ptr.Pointer(), gui.PointerFromQTouchEvent(event))
	}
}

//export callbackQQuickItem_TouchUngrabEvent
func callbackQQuickItem_TouchUngrabEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "touchUngrabEvent"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).TouchUngrabEventDefault()
	}
}

func (ptr *QQuickItem) ConnectTouchUngrabEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "touchUngrabEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "touchUngrabEvent", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "touchUngrabEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectTouchUngrabEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "touchUngrabEvent")
	}
}

func (ptr *QQuickItem) TouchUngrabEvent() {
	if ptr.Pointer() != nil {
		C.QQuickItem_TouchUngrabEvent(ptr.Pointer())
	}
}

func (ptr *QQuickItem) TouchUngrabEventDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_TouchUngrabEventDefault(ptr.Pointer())
	}
}

func (ptr *QQuickItem) UngrabMouse() {
	if ptr.Pointer() != nil {
		C.QQuickItem_UngrabMouse(ptr.Pointer())
	}
}

func (ptr *QQuickItem) UngrabTouchPoints() {
	if ptr.Pointer() != nil {
		C.QQuickItem_UngrabTouchPoints(ptr.Pointer())
	}
}

func (ptr *QQuickItem) UnsetCursor() {
	if ptr.Pointer() != nil {
		C.QQuickItem_UnsetCursor(ptr.Pointer())
	}
}

//export callbackQQuickItem_Update
func callbackQQuickItem_Update(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "update"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).UpdateDefault()
	}
}

func (ptr *QQuickItem) ConnectUpdate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "update"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "update", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "update", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectUpdate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "update")
	}
}

func (ptr *QQuickItem) Update() {
	if ptr.Pointer() != nil {
		C.QQuickItem_Update(ptr.Pointer())
	}
}

func (ptr *QQuickItem) UpdateDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_UpdateDefault(ptr.Pointer())
	}
}

func (ptr *QQuickItem) UpdateInputMethod(queries core.Qt__InputMethodQuery) {
	if ptr.Pointer() != nil {
		C.QQuickItem_UpdateInputMethod(ptr.Pointer(), C.longlong(queries))
	}
}

//export callbackQQuickItem_UpdatePolish
func callbackQQuickItem_UpdatePolish(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "updatePolish"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).UpdatePolishDefault()
	}
}

func (ptr *QQuickItem) ConnectUpdatePolish(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "updatePolish"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updatePolish", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updatePolish", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectUpdatePolish() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "updatePolish")
	}
}

func (ptr *QQuickItem) UpdatePolish() {
	if ptr.Pointer() != nil {
		C.QQuickItem_UpdatePolish(ptr.Pointer())
	}
}

func (ptr *QQuickItem) UpdatePolishDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_UpdatePolishDefault(ptr.Pointer())
	}
}

//export callbackQQuickItem_WheelEvent
func callbackQQuickItem_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "wheelEvent"); signal != nil {
		signal.(func(*gui.QWheelEvent))(gui.NewQWheelEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).WheelEventDefault(gui.NewQWheelEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ConnectWheelEvent(f func(event *gui.QWheelEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "wheelEvent"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "wheelEvent", func(event *gui.QWheelEvent) {
				signal.(func(*gui.QWheelEvent))(event)
				f(event)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "wheelEvent", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectWheelEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "wheelEvent")
	}
}

func (ptr *QQuickItem) WheelEvent(event gui.QWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_WheelEvent(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
	}
}

func (ptr *QQuickItem) WheelEventDefault(event gui.QWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_WheelEventDefault(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
	}
}

//export callbackQQuickItem_WindowChanged
func callbackQQuickItem_WindowChanged(ptr unsafe.Pointer, window unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "windowChanged"); signal != nil {
		signal.(func(*QQuickWindow))(NewQQuickWindowFromPointer(window))
	}

}

func (ptr *QQuickItem) ConnectWindowChanged(f func(window *QQuickWindow)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "windowChanged") {
			C.QQuickItem_ConnectWindowChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "windowChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "windowChanged", func(window *QQuickWindow) {
				signal.(func(*QQuickWindow))(window)
				f(window)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "windowChanged", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectWindowChanged() {
	if ptr.Pointer() != nil {
		C.QQuickItem_DisconnectWindowChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "windowChanged")
	}
}

func (ptr *QQuickItem) WindowChanged(window QQuickWindow_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_WindowChanged(ptr.Pointer(), PointerFromQQuickWindow(window))
	}
}

//export callbackQQuickItem_DestroyQQuickItem
func callbackQQuickItem_DestroyQQuickItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickItem"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).DestroyQQuickItemDefault()
	}
}

func (ptr *QQuickItem) ConnectDestroyQQuickItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickItem"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickItem", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickItem", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectDestroyQQuickItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickItem")
	}
}

func (ptr *QQuickItem) DestroyQQuickItem() {
	if ptr.Pointer() != nil {
		C.QQuickItem_DestroyQQuickItem(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickItem) DestroyQQuickItemDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_DestroyQQuickItemDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickItem) Flags() QQuickItem__Flag {
	if ptr.Pointer() != nil {
		return QQuickItem__Flag(C.QQuickItem_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Cursor() *gui.QCursor {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQCursorFromPointer(C.QQuickItem_Cursor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QCursor).DestroyQCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) ChildItems() []*QQuickItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtQuick_PackedList) []*QQuickItem {
			var out = make([]*QQuickItem, int(l.len))
			for i := 0; i < int(l.len); i++ {
				out[i] = NewQQuickItemFromPointer(l.data).__childItems_atList(i)
			}
			return out
		}(C.QQuickItem_ChildItems(ptr.Pointer()))
	}
	return make([]*QQuickItem, 0)
}

func (ptr *QQuickItem) MapFromGlobal(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQPointFFromPointer(C.QQuickItem_MapFromGlobal(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapFromItem(item QQuickItem_ITF, point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQPointFFromPointer(C.QQuickItem_MapFromItem(ptr.Pointer(), PointerFromQQuickItem(item), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapFromScene(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQPointFFromPointer(C.QQuickItem_MapFromScene(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapToGlobal(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQPointFFromPointer(C.QQuickItem_MapToGlobal(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapToItem(item QQuickItem_ITF, point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQPointFFromPointer(C.QQuickItem_MapToItem(ptr.Pointer(), PointerFromQQuickItem(item), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapToScene(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQPointFFromPointer(C.QQuickItem_MapToScene(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) ChildAt(x float64, y float64) *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickItem_ChildAt(ptr.Pointer(), C.double(x), C.double(y)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) ParentItem() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickItem_ParentItem(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) ScopedFocusItem() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickItem_ScopedFocusItem(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) Window() *QQuickWindow {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickWindowFromPointer(C.QQuickItem_Window(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapRectFromItem(item QQuickItem_ITF, rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QQuickItem_MapRectFromItem(ptr.Pointer(), PointerFromQQuickItem(item), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapRectFromScene(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QQuickItem_MapRectFromScene(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapRectToItem(item QQuickItem_ITF, rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QQuickItem_MapRectToItem(ptr.Pointer(), PointerFromQQuickItem(item), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) MapRectToScene(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QQuickItem_MapRectToScene(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQQuickItem_TextureProvider
func callbackQQuickItem_TextureProvider(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureProvider"); signal != nil {
		return PointerFromQSGTextureProvider(signal.(func() *QSGTextureProvider)())
	}

	return PointerFromQSGTextureProvider(NewQQuickItemFromPointer(ptr).TextureProviderDefault())
}

func (ptr *QQuickItem) ConnectTextureProvider(f func() *QSGTextureProvider) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureProvider"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureProvider", func() *QSGTextureProvider {
				signal.(func() *QSGTextureProvider)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureProvider", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectTextureProvider() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureProvider")
	}
}

func (ptr *QQuickItem) TextureProvider() *QSGTextureProvider {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureProviderFromPointer(C.QQuickItem_TextureProvider(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) TextureProviderDefault() *QSGTextureProvider {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureProviderFromPointer(C.QQuickItem_TextureProviderDefault(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) State() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QQuickItem_State(ptr.Pointer()))
	}
	return ""
}

//export callbackQQuickItem_InputMethodQuery
func callbackQQuickItem_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodQuery"); signal != nil {
		return core.PointerFromQVariant(signal.(func(core.Qt__InputMethodQuery) *core.QVariant)(core.Qt__InputMethodQuery(query)))
	}

	return core.PointerFromQVariant(NewQQuickItemFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
}

func (ptr *QQuickItem) ConnectInputMethodQuery(f func(query core.Qt__InputMethodQuery) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "inputMethodQuery"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "inputMethodQuery", func(query core.Qt__InputMethodQuery) *core.QVariant {
				signal.(func(core.Qt__InputMethodQuery) *core.QVariant)(query)
				return f(query)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "inputMethodQuery", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectInputMethodQuery() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "inputMethodQuery")
	}
}

func (ptr *QQuickItem) InputMethodQuery(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQVariantFromPointer(C.QQuickItem_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQVariantFromPointer(C.QQuickItem_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) AcceptedMouseButtons() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QQuickItem_AcceptedMouseButtons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) TransformOrigin() QQuickItem__TransformOrigin {
	if ptr.Pointer() != nil {
		return QQuickItem__TransformOrigin(C.QQuickItem_TransformOrigin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) AcceptHoverEvents() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_AcceptHoverEvents(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) ActiveFocusOnTab() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_ActiveFocusOnTab(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) Antialiasing() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_Antialiasing(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) Clip() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_Clip(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQQuickItem_Contains
func callbackQQuickItem_Contains(ptr unsafe.Pointer, point unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "contains"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QPointF) bool)(core.NewQPointFFromPointer(point)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemFromPointer(ptr).ContainsDefault(core.NewQPointFFromPointer(point)))))
}

func (ptr *QQuickItem) ConnectContains(f func(point *core.QPointF) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contains"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contains", func(point *core.QPointF) bool {
				signal.(func(*core.QPointF) bool)(point)
				return f(point)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contains", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectContains() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contains")
	}
}

func (ptr *QQuickItem) Contains(point core.QPointF_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_Contains(ptr.Pointer(), core.PointerFromQPointF(point)) != 0
	}
	return false
}

func (ptr *QQuickItem) ContainsDefault(point core.QPointF_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_ContainsDefault(ptr.Pointer(), core.PointerFromQPointF(point)) != 0
	}
	return false
}

func (ptr *QQuickItem) FiltersChildMouseEvents() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_FiltersChildMouseEvents(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) HasActiveFocus() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_HasActiveFocus(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) HasFocus() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_HasFocus(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) HeightValid() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_HeightValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) IsAncestorOf(child QQuickItem_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsAncestorOf(ptr.Pointer(), PointerFromQQuickItem(child)) != 0
	}
	return false
}

func (ptr *QQuickItem) IsComponentComplete() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsComponentComplete(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) IsFocusScope() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsFocusScope(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQQuickItem_IsTextureProvider
func callbackQQuickItem_IsTextureProvider(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "isTextureProvider"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemFromPointer(ptr).IsTextureProviderDefault())))
}

func (ptr *QQuickItem) ConnectIsTextureProvider(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isTextureProvider"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isTextureProvider", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isTextureProvider", f)
		}
	}
}

func (ptr *QQuickItem) DisconnectIsTextureProvider() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isTextureProvider")
	}
}

func (ptr *QQuickItem) IsTextureProvider() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsTextureProvider(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) IsTextureProviderDefault() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsTextureProviderDefault(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) IsVisible() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_IsVisible(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) KeepMouseGrab() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_KeepMouseGrab(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) KeepTouchGrab() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_KeepTouchGrab(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) Smooth() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_Smooth(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) WidthValid() bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_WidthValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickItem) BaselineOffset() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_BaselineOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Height() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) ImplicitHeight() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_ImplicitHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) ImplicitWidth() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_ImplicitWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Opacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Opacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Rotation() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Rotation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Scale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Scale(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Width() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) X() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Y() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Y(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) Z() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickItem_Z(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickItem) __grabTouchPoints_ids_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QQuickItem___grabTouchPoints_ids_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QQuickItem) __grabTouchPoints_ids_setList(i int) {
	if ptr.Pointer() != nil {
		C.QQuickItem___grabTouchPoints_ids_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QQuickItem) __grabTouchPoints_ids_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___grabTouchPoints_ids_newList(ptr.Pointer()))
}

func (ptr *QQuickItem) __childItems_atList(i int) *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickItem___childItems_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) __childItems_setList(i QQuickItem_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem___childItems_setList(ptr.Pointer(), PointerFromQQuickItem(i))
	}
}

func (ptr *QQuickItem) __childItems_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___childItems_newList(ptr.Pointer()))
}

func (ptr *QQuickItem) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickItem___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickItem) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickItem) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItem___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItem) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickItem) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItem___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItem) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickItem) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItem___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItem) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickItem) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItem___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItem) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItem) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItem___children_newList(ptr.Pointer()))
}

//export callbackQQuickItem_EventFilter
func callbackQQuickItem_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickItem) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QQuickItem) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItem_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickItem_ChildEvent
func callbackQQuickItem_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickItem) ChildEvent(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QQuickItem) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickItem_ConnectNotify
func callbackQQuickItem_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickItemFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickItem) ConnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QQuickItem) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickItem_CustomEvent
func callbackQQuickItem_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickItem) CustomEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QQuickItem) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickItem_DeleteLater
func callbackQQuickItem_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickItem) DeleteLater() {
	if ptr.Pointer() != nil {
		C.QQuickItem_DeleteLater(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickItem) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItem_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickItem_Destroyed
func callbackQQuickItem_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickItem_DisconnectNotify
func callbackQQuickItem_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickItemFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickItem) DisconnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QQuickItem) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickItem_ObjectNameChanged
func callbackQQuickItem_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickItem_TimerEvent
func callbackQQuickItem_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickItemFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickItem) TimerEvent(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QQuickItem) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItem_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickItem_MetaObject
func callbackQQuickItem_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickItemFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickItem) MetaObject() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickItem_MetaObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickItem) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickItem_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickItemGrabResult struct {
	core.QObject
}

type QQuickItemGrabResult_ITF interface {
	core.QObject_ITF
	QQuickItemGrabResult_PTR() *QQuickItemGrabResult
}

func (ptr *QQuickItemGrabResult) QQuickItemGrabResult_PTR() *QQuickItemGrabResult {
	return ptr
}

func (ptr *QQuickItemGrabResult) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickItemGrabResult) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQQuickItemGrabResult(ptr QQuickItemGrabResult_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickItemGrabResult_PTR().Pointer()
	}
	return nil
}

func NewQQuickItemGrabResultFromPointer(ptr unsafe.Pointer) *QQuickItemGrabResult {
	var n = new(QQuickItemGrabResult)
	n.SetPointer(ptr)
	return n
}

func (ptr *QQuickItemGrabResult) DestroyQQuickItemGrabResult() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickItemGrabResult) SaveToFile(fileName string) bool {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return C.QQuickItemGrabResult_SaveToFile(ptr.Pointer(), fileNameC) != 0
	}
	return false
}

//export callbackQQuickItemGrabResult_Ready
func callbackQQuickItemGrabResult_Ready(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "ready"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickItemGrabResult) ConnectReady(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "ready") {
			C.QQuickItemGrabResult_ConnectReady(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "ready"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ready", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ready", f)
		}
	}
}

func (ptr *QQuickItemGrabResult) DisconnectReady() {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_DisconnectReady(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "ready")
	}
}

func (ptr *QQuickItemGrabResult) Ready() {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_Ready(ptr.Pointer())
	}
}

func (ptr *QQuickItemGrabResult) Image() *gui.QImage {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQImageFromPointer(C.QQuickItemGrabResult_Image(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) Url() *core.QUrl {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQUrlFromPointer(C.QQuickItemGrabResult_Url(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickItemGrabResult___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickItemGrabResult) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItemGrabResult___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickItemGrabResult) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItemGrabResult___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItemGrabResult) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItemGrabResult___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickItemGrabResult) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItemGrabResult___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItemGrabResult) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItemGrabResult___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickItemGrabResult) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItemGrabResult___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItemGrabResult) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItemGrabResult___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickItemGrabResult) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickItemGrabResult___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickItemGrabResult) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickItemGrabResult) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickItemGrabResult___children_newList(ptr.Pointer()))
}

//export callbackQQuickItemGrabResult_Event
func callbackQQuickItemGrabResult_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemGrabResultFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QQuickItemGrabResult) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItemGrabResult_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQQuickItemGrabResult_EventFilter
func callbackQQuickItemGrabResult_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickItemGrabResultFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickItemGrabResult) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickItemGrabResult_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickItemGrabResult_ChildEvent
func callbackQQuickItemGrabResult_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickItemGrabResultFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickItemGrabResult) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickItemGrabResult_ConnectNotify
func callbackQQuickItemGrabResult_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickItemGrabResultFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickItemGrabResult) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickItemGrabResult_CustomEvent
func callbackQQuickItemGrabResult_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickItemGrabResultFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickItemGrabResult) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickItemGrabResult_DeleteLater
func callbackQQuickItemGrabResult_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickItemGrabResultFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickItemGrabResult) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickItemGrabResult_Destroyed
func callbackQQuickItemGrabResult_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickItemGrabResult_DisconnectNotify
func callbackQQuickItemGrabResult_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickItemGrabResultFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickItemGrabResult) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickItemGrabResult_ObjectNameChanged
func callbackQQuickItemGrabResult_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickItemGrabResult_TimerEvent
func callbackQQuickItemGrabResult_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickItemGrabResultFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickItemGrabResult) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickItemGrabResult_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickItemGrabResult_MetaObject
func callbackQQuickItemGrabResult_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickItemGrabResultFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickItemGrabResult) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickItemGrabResult_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickPaintedItem struct {
	QQuickItem
}

type QQuickPaintedItem_ITF interface {
	QQuickItem_ITF
	QQuickPaintedItem_PTR() *QQuickPaintedItem
}

func (ptr *QQuickPaintedItem) QQuickPaintedItem_PTR() *QQuickPaintedItem {
	return ptr
}

func (ptr *QQuickPaintedItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickPaintedItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QQuickItem_PTR().SetPointer(p)
	}
}

func PointerFromQQuickPaintedItem(ptr QQuickPaintedItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickPaintedItem_PTR().Pointer()
	}
	return nil
}

func NewQQuickPaintedItemFromPointer(ptr unsafe.Pointer) *QQuickPaintedItem {
	var n = new(QQuickPaintedItem)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QQuickPaintedItem__PerformanceHint
//QQuickPaintedItem::PerformanceHint
type QQuickPaintedItem__PerformanceHint int64

const (
	QQuickPaintedItem__FastFBOResizing QQuickPaintedItem__PerformanceHint = QQuickPaintedItem__PerformanceHint(0x1)
)

//go:generate stringer -type=QQuickPaintedItem__RenderTarget
//QQuickPaintedItem::RenderTarget
type QQuickPaintedItem__RenderTarget int64

const (
	QQuickPaintedItem__Image                      QQuickPaintedItem__RenderTarget = QQuickPaintedItem__RenderTarget(0)
	QQuickPaintedItem__FramebufferObject          QQuickPaintedItem__RenderTarget = QQuickPaintedItem__RenderTarget(1)
	QQuickPaintedItem__InvertedYFramebufferObject QQuickPaintedItem__RenderTarget = QQuickPaintedItem__RenderTarget(2)
)

func NewQQuickPaintedItem(parent QQuickItem_ITF) *QQuickPaintedItem {
	var tmpValue = NewQQuickPaintedItemFromPointer(C.QQuickPaintedItem_NewQQuickPaintedItem(PointerFromQQuickItem(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQQuickPaintedItem_ContentsScaleChanged
func callbackQQuickPaintedItem_ContentsScaleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "contentsScaleChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickPaintedItem) ConnectContentsScaleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contentsScaleChanged") {
			C.QQuickPaintedItem_ConnectContentsScaleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contentsScaleChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsScaleChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsScaleChanged", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectContentsScaleChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DisconnectContentsScaleChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contentsScaleChanged")
	}
}

func (ptr *QQuickPaintedItem) ContentsScaleChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_ContentsScaleChanged(ptr.Pointer())
	}
}

//export callbackQQuickPaintedItem_ContentsSizeChanged
func callbackQQuickPaintedItem_ContentsSizeChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "contentsSizeChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickPaintedItem) ConnectContentsSizeChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contentsSizeChanged") {
			C.QQuickPaintedItem_ConnectContentsSizeChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contentsSizeChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsSizeChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsSizeChanged", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectContentsSizeChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DisconnectContentsSizeChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contentsSizeChanged")
	}
}

func (ptr *QQuickPaintedItem) ContentsSizeChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_ContentsSizeChanged(ptr.Pointer())
	}
}

//export callbackQQuickPaintedItem_FillColorChanged
func callbackQQuickPaintedItem_FillColorChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "fillColorChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickPaintedItem) ConnectFillColorChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "fillColorChanged") {
			C.QQuickPaintedItem_ConnectFillColorChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fillColorChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fillColorChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fillColorChanged", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectFillColorChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DisconnectFillColorChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "fillColorChanged")
	}
}

func (ptr *QQuickPaintedItem) FillColorChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_FillColorChanged(ptr.Pointer())
	}
}

//export callbackQQuickPaintedItem_Paint
func callbackQQuickPaintedItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "paint"); signal != nil {
		signal.(func(*gui.QPainter))(gui.NewQPainterFromPointer(painter))
	}

}

func (ptr *QQuickPaintedItem) ConnectPaint(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paint"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", func(painter *gui.QPainter) {
				signal.(func(*gui.QPainter))(painter)
				f(painter)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "paint")
	}
}

func (ptr *QQuickPaintedItem) Paint(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

//export callbackQQuickPaintedItem_RenderTargetChanged
func callbackQQuickPaintedItem_RenderTargetChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "renderTargetChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickPaintedItem) ConnectRenderTargetChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "renderTargetChanged") {
			C.QQuickPaintedItem_ConnectRenderTargetChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "renderTargetChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "renderTargetChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "renderTargetChanged", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectRenderTargetChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DisconnectRenderTargetChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "renderTargetChanged")
	}
}

func (ptr *QQuickPaintedItem) RenderTargetChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_RenderTargetChanged(ptr.Pointer())
	}
}

func (ptr *QQuickPaintedItem) SetContentsScale(vqr float64) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetContentsScale(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QQuickPaintedItem) SetContentsSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetContentsSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QQuickPaintedItem) SetFillColor(vqc gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetFillColor(ptr.Pointer(), gui.PointerFromQColor(vqc))
	}
}

func (ptr *QQuickPaintedItem) SetMipmap(enable bool) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetMipmap(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QQuickPaintedItem) SetOpaquePainting(opaque bool) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetOpaquePainting(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(opaque))))
	}
}

func (ptr *QQuickPaintedItem) SetPerformanceHint(hint QQuickPaintedItem__PerformanceHint, enabled bool) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetPerformanceHint(ptr.Pointer(), C.longlong(hint), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QQuickPaintedItem) SetPerformanceHints(hints QQuickPaintedItem__PerformanceHint) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetPerformanceHints(ptr.Pointer(), C.longlong(hints))
	}
}

func (ptr *QQuickPaintedItem) SetRenderTarget(target QQuickPaintedItem__RenderTarget) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetRenderTarget(ptr.Pointer(), C.longlong(target))
	}
}

func (ptr *QQuickPaintedItem) SetTextureSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_SetTextureSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

//export callbackQQuickPaintedItem_TextureSizeChanged
func callbackQQuickPaintedItem_TextureSizeChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureSizeChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickPaintedItem) ConnectTextureSizeChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "textureSizeChanged") {
			C.QQuickPaintedItem_ConnectTextureSizeChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureSizeChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureSizeChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureSizeChanged", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectTextureSizeChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DisconnectTextureSizeChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureSizeChanged")
	}
}

func (ptr *QQuickPaintedItem) TextureSizeChanged() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_TextureSizeChanged(ptr.Pointer())
	}
}

func (ptr *QQuickPaintedItem) Update(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_Update(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

//export callbackQQuickPaintedItem_DestroyQQuickPaintedItem
func callbackQQuickPaintedItem_DestroyQQuickPaintedItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickPaintedItem"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickPaintedItemFromPointer(ptr).DestroyQQuickPaintedItemDefault()
	}
}

func (ptr *QQuickPaintedItem) ConnectDestroyQQuickPaintedItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickPaintedItem"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickPaintedItem", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickPaintedItem", f)
		}
	}
}

func (ptr *QQuickPaintedItem) DisconnectDestroyQQuickPaintedItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickPaintedItem")
	}
}

func (ptr *QQuickPaintedItem) DestroyQQuickPaintedItem() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DestroyQQuickPaintedItem(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickPaintedItem) DestroyQQuickPaintedItemDefault() {
	if ptr.Pointer() != nil {
		C.QQuickPaintedItem_DestroyQQuickPaintedItemDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickPaintedItem) PerformanceHints() QQuickPaintedItem__PerformanceHint {
	if ptr.Pointer() != nil {
		return QQuickPaintedItem__PerformanceHint(C.QQuickPaintedItem_PerformanceHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickPaintedItem) FillColor() *gui.QColor {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQColorFromPointer(C.QQuickPaintedItem_FillColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickPaintedItem) ContentsSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickPaintedItem_ContentsSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickPaintedItem) TextureSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickPaintedItem_TextureSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickPaintedItem) RenderTarget() QQuickPaintedItem__RenderTarget {
	if ptr.Pointer() != nil {
		return QQuickPaintedItem__RenderTarget(C.QQuickPaintedItem_RenderTarget(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickPaintedItem) Mipmap() bool {
	if ptr.Pointer() != nil {
		return C.QQuickPaintedItem_Mipmap(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickPaintedItem) OpaquePainting() bool {
	if ptr.Pointer() != nil {
		return C.QQuickPaintedItem_OpaquePainting(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickPaintedItem) ContentsScale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickPaintedItem_ContentsScale(ptr.Pointer()))
	}
	return 0
}

type QQuickRenderControl struct {
	core.QObject
}

type QQuickRenderControl_ITF interface {
	core.QObject_ITF
	QQuickRenderControl_PTR() *QQuickRenderControl
}

func (ptr *QQuickRenderControl) QQuickRenderControl_PTR() *QQuickRenderControl {
	return ptr
}

func (ptr *QQuickRenderControl) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickRenderControl) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQQuickRenderControl(ptr QQuickRenderControl_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickRenderControl_PTR().Pointer()
	}
	return nil
}

func NewQQuickRenderControlFromPointer(ptr unsafe.Pointer) *QQuickRenderControl {
	var n = new(QQuickRenderControl)
	n.SetPointer(ptr)
	return n
}
func (ptr *QQuickRenderControl) Grab() *gui.QImage {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQImageFromPointer(C.QQuickRenderControl_Grab(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func NewQQuickRenderControl(parent core.QObject_ITF) *QQuickRenderControl {
	var tmpValue = NewQQuickRenderControlFromPointer(C.QQuickRenderControl_NewQQuickRenderControl(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQQuickRenderControl_RenderWindow
func callbackQQuickRenderControl_RenderWindow(ptr unsafe.Pointer, offset unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "renderWindow"); signal != nil {
		return gui.PointerFromQWindow(signal.(func(*core.QPoint) *gui.QWindow)(core.NewQPointFromPointer(offset)))
	}

	return gui.PointerFromQWindow(NewQQuickRenderControlFromPointer(ptr).RenderWindowDefault(core.NewQPointFromPointer(offset)))
}

func (ptr *QQuickRenderControl) ConnectRenderWindow(f func(offset *core.QPoint) *gui.QWindow) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "renderWindow"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "renderWindow", func(offset *core.QPoint) *gui.QWindow {
				signal.(func(*core.QPoint) *gui.QWindow)(offset)
				return f(offset)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "renderWindow", f)
		}
	}
}

func (ptr *QQuickRenderControl) DisconnectRenderWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "renderWindow")
	}
}

func (ptr *QQuickRenderControl) RenderWindow(offset core.QPoint_ITF) *gui.QWindow {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQWindowFromPointer(C.QQuickRenderControl_RenderWindow(ptr.Pointer(), core.PointerFromQPoint(offset)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickRenderControl) RenderWindowDefault(offset core.QPoint_ITF) *gui.QWindow {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQWindowFromPointer(C.QQuickRenderControl_RenderWindowDefault(ptr.Pointer(), core.PointerFromQPoint(offset)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func QQuickRenderControl_RenderWindowFor(win QQuickWindow_ITF, offset core.QPoint_ITF) *gui.QWindow {
	var tmpValue = gui.NewQWindowFromPointer(C.QQuickRenderControl_QQuickRenderControl_RenderWindowFor(PointerFromQQuickWindow(win), core.PointerFromQPoint(offset)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QQuickRenderControl) RenderWindowFor(win QQuickWindow_ITF, offset core.QPoint_ITF) *gui.QWindow {
	var tmpValue = gui.NewQWindowFromPointer(C.QQuickRenderControl_QQuickRenderControl_RenderWindowFor(PointerFromQQuickWindow(win), core.PointerFromQPoint(offset)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QQuickRenderControl) Sync() bool {
	if ptr.Pointer() != nil {
		return C.QQuickRenderControl_Sync(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickRenderControl) Initialize(gl gui.QOpenGLContext_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_Initialize(ptr.Pointer(), gui.PointerFromQOpenGLContext(gl))
	}
}

func (ptr *QQuickRenderControl) Invalidate() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_Invalidate(ptr.Pointer())
	}
}

func (ptr *QQuickRenderControl) PolishItems() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_PolishItems(ptr.Pointer())
	}
}

func (ptr *QQuickRenderControl) PrepareThread(targetThread core.QThread_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_PrepareThread(ptr.Pointer(), core.PointerFromQThread(targetThread))
	}
}

func (ptr *QQuickRenderControl) Render() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_Render(ptr.Pointer())
	}
}

//export callbackQQuickRenderControl_RenderRequested
func callbackQQuickRenderControl_RenderRequested(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "renderRequested"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickRenderControl) ConnectRenderRequested(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "renderRequested") {
			C.QQuickRenderControl_ConnectRenderRequested(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "renderRequested"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "renderRequested", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "renderRequested", f)
		}
	}
}

func (ptr *QQuickRenderControl) DisconnectRenderRequested() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_DisconnectRenderRequested(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "renderRequested")
	}
}

func (ptr *QQuickRenderControl) RenderRequested() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_RenderRequested(ptr.Pointer())
	}
}

//export callbackQQuickRenderControl_SceneChanged
func callbackQQuickRenderControl_SceneChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickRenderControl) ConnectSceneChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneChanged") {
			C.QQuickRenderControl_ConnectSceneChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneChanged", f)
		}
	}
}

func (ptr *QQuickRenderControl) DisconnectSceneChanged() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_DisconnectSceneChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneChanged")
	}
}

func (ptr *QQuickRenderControl) SceneChanged() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_SceneChanged(ptr.Pointer())
	}
}

func (ptr *QQuickRenderControl) DestroyQQuickRenderControl() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_DestroyQQuickRenderControl(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickRenderControl) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickRenderControl___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickRenderControl) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickRenderControl) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickRenderControl___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickRenderControl) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickRenderControl___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickRenderControl) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickRenderControl) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickRenderControl___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickRenderControl) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickRenderControl___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickRenderControl) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickRenderControl) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickRenderControl___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickRenderControl) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickRenderControl___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickRenderControl) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickRenderControl) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickRenderControl___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickRenderControl) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickRenderControl___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickRenderControl) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickRenderControl) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickRenderControl___children_newList(ptr.Pointer()))
}

//export callbackQQuickRenderControl_Event
func callbackQQuickRenderControl_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickRenderControlFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QQuickRenderControl) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickRenderControl_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQQuickRenderControl_EventFilter
func callbackQQuickRenderControl_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickRenderControlFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickRenderControl) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickRenderControl_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickRenderControl_ChildEvent
func callbackQQuickRenderControl_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickRenderControlFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickRenderControl) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickRenderControl_ConnectNotify
func callbackQQuickRenderControl_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickRenderControlFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickRenderControl) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickRenderControl_CustomEvent
func callbackQQuickRenderControl_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickRenderControlFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickRenderControl) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickRenderControl_DeleteLater
func callbackQQuickRenderControl_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickRenderControlFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickRenderControl) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickRenderControl_Destroyed
func callbackQQuickRenderControl_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickRenderControl_DisconnectNotify
func callbackQQuickRenderControl_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickRenderControlFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickRenderControl) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickRenderControl_ObjectNameChanged
func callbackQQuickRenderControl_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickRenderControl_TimerEvent
func callbackQQuickRenderControl_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickRenderControlFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickRenderControl) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickRenderControl_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickRenderControl_MetaObject
func callbackQQuickRenderControl_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickRenderControlFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickRenderControl) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickRenderControl_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickTextDocument struct {
	core.QObject
}

type QQuickTextDocument_ITF interface {
	core.QObject_ITF
	QQuickTextDocument_PTR() *QQuickTextDocument
}

func (ptr *QQuickTextDocument) QQuickTextDocument_PTR() *QQuickTextDocument {
	return ptr
}

func (ptr *QQuickTextDocument) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickTextDocument) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQQuickTextDocument(ptr QQuickTextDocument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickTextDocument_PTR().Pointer()
	}
	return nil
}

func NewQQuickTextDocumentFromPointer(ptr unsafe.Pointer) *QQuickTextDocument {
	var n = new(QQuickTextDocument)
	n.SetPointer(ptr)
	return n
}

func (ptr *QQuickTextDocument) DestroyQQuickTextDocument() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func NewQQuickTextDocument(parent QQuickItem_ITF) *QQuickTextDocument {
	var tmpValue = NewQQuickTextDocumentFromPointer(C.QQuickTextDocument_NewQQuickTextDocument(PointerFromQQuickItem(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QQuickTextDocument) TextDocument() *gui.QTextDocument {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQTextDocumentFromPointer(C.QQuickTextDocument_TextDocument(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextDocument) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickTextDocument___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextDocument) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickTextDocument) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextDocument___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickTextDocument) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextDocument___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextDocument) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextDocument) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextDocument___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickTextDocument) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextDocument___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextDocument) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextDocument) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextDocument___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickTextDocument) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextDocument___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextDocument) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextDocument) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextDocument___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickTextDocument) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextDocument___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextDocument) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextDocument) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextDocument___children_newList(ptr.Pointer()))
}

//export callbackQQuickTextDocument_Event
func callbackQQuickTextDocument_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickTextDocumentFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QQuickTextDocument) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickTextDocument_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQQuickTextDocument_EventFilter
func callbackQQuickTextDocument_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickTextDocumentFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickTextDocument) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickTextDocument_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickTextDocument_ChildEvent
func callbackQQuickTextDocument_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickTextDocumentFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickTextDocument) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickTextDocument_ConnectNotify
func callbackQQuickTextDocument_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickTextDocumentFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickTextDocument) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickTextDocument_CustomEvent
func callbackQQuickTextDocument_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickTextDocumentFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickTextDocument) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickTextDocument_DeleteLater
func callbackQQuickTextDocument_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickTextDocumentFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickTextDocument) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickTextDocument_Destroyed
func callbackQQuickTextDocument_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickTextDocument_DisconnectNotify
func callbackQQuickTextDocument_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickTextDocumentFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickTextDocument) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickTextDocument_ObjectNameChanged
func callbackQQuickTextDocument_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickTextDocument_TimerEvent
func callbackQQuickTextDocument_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickTextDocumentFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickTextDocument) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextDocument_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickTextDocument_MetaObject
func callbackQQuickTextDocument_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickTextDocumentFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickTextDocument) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickTextDocument_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickTextureFactory struct {
	core.QObject
}

type QQuickTextureFactory_ITF interface {
	core.QObject_ITF
	QQuickTextureFactory_PTR() *QQuickTextureFactory
}

func (ptr *QQuickTextureFactory) QQuickTextureFactory_PTR() *QQuickTextureFactory {
	return ptr
}

func (ptr *QQuickTextureFactory) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickTextureFactory) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQQuickTextureFactory(ptr QQuickTextureFactory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickTextureFactory_PTR().Pointer()
	}
	return nil
}

func NewQQuickTextureFactoryFromPointer(ptr unsafe.Pointer) *QQuickTextureFactory {
	var n = new(QQuickTextureFactory)
	n.SetPointer(ptr)
	return n
}
func QQuickTextureFactory_TextureFactoryForImage(image gui.QImage_ITF) *QQuickTextureFactory {
	var tmpValue = NewQQuickTextureFactoryFromPointer(C.QQuickTextureFactory_QQuickTextureFactory_TextureFactoryForImage(gui.PointerFromQImage(image)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QQuickTextureFactory) TextureFactoryForImage(image gui.QImage_ITF) *QQuickTextureFactory {
	var tmpValue = NewQQuickTextureFactoryFromPointer(C.QQuickTextureFactory_QQuickTextureFactory_TextureFactoryForImage(gui.PointerFromQImage(image)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQQuickTextureFactory() *QQuickTextureFactory {
	var tmpValue = NewQQuickTextureFactoryFromPointer(C.QQuickTextureFactory_NewQQuickTextureFactory())
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQQuickTextureFactory_DestroyQQuickTextureFactory
func callbackQQuickTextureFactory_DestroyQQuickTextureFactory(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickTextureFactory"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).DestroyQQuickTextureFactoryDefault()
	}
}

func (ptr *QQuickTextureFactory) ConnectDestroyQQuickTextureFactory(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickTextureFactory"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickTextureFactory", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickTextureFactory", f)
		}
	}
}

func (ptr *QQuickTextureFactory) DisconnectDestroyQQuickTextureFactory() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickTextureFactory")
	}
}

func (ptr *QQuickTextureFactory) DestroyQQuickTextureFactory() {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_DestroyQQuickTextureFactory(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickTextureFactory) DestroyQQuickTextureFactoryDefault() {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_DestroyQQuickTextureFactoryDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickTextureFactory_Image
func callbackQQuickTextureFactory_Image(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "image"); signal != nil {
		return gui.PointerFromQImage(signal.(func() *gui.QImage)())
	}

	return gui.PointerFromQImage(NewQQuickTextureFactoryFromPointer(ptr).ImageDefault())
}

func (ptr *QQuickTextureFactory) ConnectImage(f func() *gui.QImage) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "image"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "image", func() *gui.QImage {
				signal.(func() *gui.QImage)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "image", f)
		}
	}
}

func (ptr *QQuickTextureFactory) DisconnectImage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "image")
	}
}

func (ptr *QQuickTextureFactory) Image() *gui.QImage {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQImageFromPointer(C.QQuickTextureFactory_Image(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextureFactory) ImageDefault() *gui.QImage {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQImageFromPointer(C.QQuickTextureFactory_ImageDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

//export callbackQQuickTextureFactory_CreateTexture
func callbackQQuickTextureFactory_CreateTexture(ptr unsafe.Pointer, window unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "createTexture"); signal != nil {
		return PointerFromQSGTexture(signal.(func(*QQuickWindow) *QSGTexture)(NewQQuickWindowFromPointer(window)))
	}

	return PointerFromQSGTexture(NewQSGTexture())
}

func (ptr *QQuickTextureFactory) ConnectCreateTexture(f func(window *QQuickWindow) *QSGTexture) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createTexture", func(window *QQuickWindow) *QSGTexture {
				signal.(func(*QQuickWindow) *QSGTexture)(window)
				return f(window)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createTexture", f)
		}
	}
}

func (ptr *QQuickTextureFactory) DisconnectCreateTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "createTexture")
	}
}

func (ptr *QQuickTextureFactory) CreateTexture(window QQuickWindow_ITF) *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QQuickTextureFactory_CreateTexture(ptr.Pointer(), PointerFromQQuickWindow(window)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQQuickTextureFactory_TextureSize
func callbackQQuickTextureFactory_TextureSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureSize"); signal != nil {
		return core.PointerFromQSize(signal.(func() *core.QSize)())
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QQuickTextureFactory) ConnectTextureSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureSize"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureSize", func() *core.QSize {
				signal.(func() *core.QSize)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureSize", f)
		}
	}
}

func (ptr *QQuickTextureFactory) DisconnectTextureSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureSize")
	}
}

func (ptr *QQuickTextureFactory) TextureSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickTextureFactory_TextureSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQQuickTextureFactory_TextureByteCount
func callbackQQuickTextureFactory_TextureByteCount(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureByteCount"); signal != nil {
		return C.int(int32(signal.(func() int)()))
	}

	return C.int(int32(0))
}

func (ptr *QQuickTextureFactory) ConnectTextureByteCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureByteCount"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureByteCount", func() int {
				signal.(func() int)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureByteCount", f)
		}
	}
}

func (ptr *QQuickTextureFactory) DisconnectTextureByteCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureByteCount")
	}
}

func (ptr *QQuickTextureFactory) TextureByteCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QQuickTextureFactory_TextureByteCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QQuickTextureFactory) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickTextureFactory___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextureFactory) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickTextureFactory) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextureFactory___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickTextureFactory) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextureFactory___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextureFactory) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextureFactory) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextureFactory___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickTextureFactory) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextureFactory___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextureFactory) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextureFactory) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextureFactory___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickTextureFactory) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextureFactory___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextureFactory) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextureFactory) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextureFactory___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickTextureFactory) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickTextureFactory___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickTextureFactory) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickTextureFactory) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickTextureFactory___children_newList(ptr.Pointer()))
}

//export callbackQQuickTextureFactory_Event
func callbackQQuickTextureFactory_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickTextureFactoryFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QQuickTextureFactory) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickTextureFactory_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQQuickTextureFactory_EventFilter
func callbackQQuickTextureFactory_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickTextureFactoryFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickTextureFactory) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickTextureFactory_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickTextureFactory_ChildEvent
func callbackQQuickTextureFactory_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickTextureFactory) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickTextureFactory_ConnectNotify
func callbackQQuickTextureFactory_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickTextureFactory) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickTextureFactory_CustomEvent
func callbackQQuickTextureFactory_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickTextureFactory) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickTextureFactory_DeleteLater
func callbackQQuickTextureFactory_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickTextureFactory) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickTextureFactory_Destroyed
func callbackQQuickTextureFactory_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickTextureFactory_DisconnectNotify
func callbackQQuickTextureFactory_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickTextureFactory) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickTextureFactory_ObjectNameChanged
func callbackQQuickTextureFactory_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickTextureFactory_TimerEvent
func callbackQQuickTextureFactory_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickTextureFactoryFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickTextureFactory) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickTextureFactory_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickTextureFactory_MetaObject
func callbackQQuickTextureFactory_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickTextureFactoryFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickTextureFactory) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickTextureFactory_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickView struct {
	QQuickWindow
}

type QQuickView_ITF interface {
	QQuickWindow_ITF
	QQuickView_PTR() *QQuickView
}

func (ptr *QQuickView) QQuickView_PTR() *QQuickView {
	return ptr
}

func (ptr *QQuickView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickWindow_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QQuickWindow_PTR().SetPointer(p)
	}
}

func PointerFromQQuickView(ptr QQuickView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickView_PTR().Pointer()
	}
	return nil
}

func NewQQuickViewFromPointer(ptr unsafe.Pointer) *QQuickView {
	var n = new(QQuickView)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QQuickView__ResizeMode
//QQuickView::ResizeMode
type QQuickView__ResizeMode int64

const (
	QQuickView__SizeViewToRootObject QQuickView__ResizeMode = QQuickView__ResizeMode(0)
	QQuickView__SizeRootObjectToView QQuickView__ResizeMode = QQuickView__ResizeMode(1)
)

//go:generate stringer -type=QQuickView__Status
//QQuickView::Status
type QQuickView__Status int64

const (
	QQuickView__Null    QQuickView__Status = QQuickView__Status(0)
	QQuickView__Ready   QQuickView__Status = QQuickView__Status(1)
	QQuickView__Loading QQuickView__Status = QQuickView__Status(2)
	QQuickView__Error   QQuickView__Status = QQuickView__Status(3)
)

func NewQQuickView2(engine qml.QQmlEngine_ITF, parent gui.QWindow_ITF) *QQuickView {
	var tmpValue = NewQQuickViewFromPointer(C.QQuickView_NewQQuickView2(qml.PointerFromQQmlEngine(engine), gui.PointerFromQWindow(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQQuickView(parent gui.QWindow_ITF) *QQuickView {
	var tmpValue = NewQQuickViewFromPointer(C.QQuickView_NewQQuickView(gui.PointerFromQWindow(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQQuickView3(source core.QUrl_ITF, parent gui.QWindow_ITF) *QQuickView {
	var tmpValue = NewQQuickViewFromPointer(C.QQuickView_NewQQuickView3(core.PointerFromQUrl(source), gui.PointerFromQWindow(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QQuickView) SetResizeMode(vre QQuickView__ResizeMode) {
	if ptr.Pointer() != nil {
		C.QQuickView_SetResizeMode(ptr.Pointer(), C.longlong(vre))
	}
}

//export callbackQQuickView_SetSource
func callbackQQuickView_SetSource(ptr unsafe.Pointer, url unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setSource"); signal != nil {
		signal.(func(*core.QUrl))(core.NewQUrlFromPointer(url))
	} else {
		NewQQuickViewFromPointer(ptr).SetSourceDefault(core.NewQUrlFromPointer(url))
	}
}

func (ptr *QQuickView) ConnectSetSource(f func(url *core.QUrl)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSource"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSource", func(url *core.QUrl) {
				signal.(func(*core.QUrl))(url)
				f(url)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSource", f)
		}
	}
}

func (ptr *QQuickView) DisconnectSetSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSource")
	}
}

func (ptr *QQuickView) SetSource(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickView_SetSource(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

func (ptr *QQuickView) SetSourceDefault(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickView_SetSourceDefault(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

//export callbackQQuickView_StatusChanged
func callbackQQuickView_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
		signal.(func(QQuickView__Status))(QQuickView__Status(status))
	}

}

func (ptr *QQuickView) ConnectStatusChanged(f func(status QQuickView__Status)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
			C.QQuickView_ConnectStatusChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QQuickView__Status) {
				signal.(func(QQuickView__Status))(status)
				f(status)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
		}
	}
}

func (ptr *QQuickView) DisconnectStatusChanged() {
	if ptr.Pointer() != nil {
		C.QQuickView_DisconnectStatusChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
	}
}

func (ptr *QQuickView) StatusChanged(status QQuickView__Status) {
	if ptr.Pointer() != nil {
		C.QQuickView_StatusChanged(ptr.Pointer(), C.longlong(status))
	}
}

//export callbackQQuickView_DestroyQQuickView
func callbackQQuickView_DestroyQQuickView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickView"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickViewFromPointer(ptr).DestroyQQuickViewDefault()
	}
}

func (ptr *QQuickView) ConnectDestroyQQuickView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickView"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickView", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickView", f)
		}
	}
}

func (ptr *QQuickView) DisconnectDestroyQQuickView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickView")
	}
}

func (ptr *QQuickView) DestroyQQuickView() {
	if ptr.Pointer() != nil {
		C.QQuickView_DestroyQQuickView(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickView) DestroyQQuickViewDefault() {
	if ptr.Pointer() != nil {
		C.QQuickView_DestroyQQuickViewDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickView) Errors() []*qml.QQmlError {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtQuick_PackedList) []*qml.QQmlError {
			var out = make([]*qml.QQmlError, int(l.len))
			for i := 0; i < int(l.len); i++ {
				out[i] = NewQQuickViewFromPointer(l.data).__errors_atList(i)
			}
			return out
		}(C.QQuickView_Errors(ptr.Pointer()))
	}
	return make([]*qml.QQmlError, 0)
}

func (ptr *QQuickView) RootContext() *qml.QQmlContext {
	if ptr.Pointer() != nil {
		var tmpValue = qml.NewQQmlContextFromPointer(C.QQuickView_RootContext(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickView) Engine() *qml.QQmlEngine {
	if ptr.Pointer() != nil {
		var tmpValue = qml.NewQQmlEngineFromPointer(C.QQuickView_Engine(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickView) RootObject() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickView_RootObject(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickView) InitialSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickView_InitialSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickView) Source() *core.QUrl {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQUrlFromPointer(C.QQuickView_Source(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickView) ResizeMode() QQuickView__ResizeMode {
	if ptr.Pointer() != nil {
		return QQuickView__ResizeMode(C.QQuickView_ResizeMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickView) Status() QQuickView__Status {
	if ptr.Pointer() != nil {
		return QQuickView__Status(C.QQuickView_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickView) __errors_atList(i int) *qml.QQmlError {
	if ptr.Pointer() != nil {
		var tmpValue = qml.NewQQmlErrorFromPointer(C.QQuickView___errors_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*qml.QQmlError).DestroyQQmlError)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickView) __errors_setList(i qml.QQmlError_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickView___errors_setList(ptr.Pointer(), qml.PointerFromQQmlError(i))
	}
}

func (ptr *QQuickView) __errors_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickView___errors_newList(ptr.Pointer()))
}

type QQuickWidget struct {
	widgets.QWidget
}

type QQuickWidget_ITF interface {
	widgets.QWidget_ITF
	QQuickWidget_PTR() *QQuickWidget
}

func (ptr *QQuickWidget) QQuickWidget_PTR() *QQuickWidget {
	return ptr
}

func (ptr *QQuickWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQQuickWidget(ptr QQuickWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickWidget_PTR().Pointer()
	}
	return nil
}

func NewQQuickWidgetFromPointer(ptr unsafe.Pointer) *QQuickWidget {
	var n = new(QQuickWidget)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QQuickWidget__ResizeMode
//QQuickWidget::ResizeMode
type QQuickWidget__ResizeMode int64

const (
	QQuickWidget__SizeViewToRootObject QQuickWidget__ResizeMode = QQuickWidget__ResizeMode(0)
	QQuickWidget__SizeRootObjectToView QQuickWidget__ResizeMode = QQuickWidget__ResizeMode(1)
)

//go:generate stringer -type=QQuickWidget__Status
//QQuickWidget::Status
type QQuickWidget__Status int64

const (
	QQuickWidget__Null    QQuickWidget__Status = QQuickWidget__Status(0)
	QQuickWidget__Ready   QQuickWidget__Status = QQuickWidget__Status(1)
	QQuickWidget__Loading QQuickWidget__Status = QQuickWidget__Status(2)
	QQuickWidget__Error   QQuickWidget__Status = QQuickWidget__Status(3)
)

func NewQQuickWidget2(engine qml.QQmlEngine_ITF, parent widgets.QWidget_ITF) *QQuickWidget {
	var tmpValue = NewQQuickWidgetFromPointer(C.QQuickWidget_NewQQuickWidget2(qml.PointerFromQQmlEngine(engine), widgets.PointerFromQWidget(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQQuickWidget(parent widgets.QWidget_ITF) *QQuickWidget {
	var tmpValue = NewQQuickWidgetFromPointer(C.QQuickWidget_NewQQuickWidget(widgets.PointerFromQWidget(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQQuickWidget3(source core.QUrl_ITF, parent widgets.QWidget_ITF) *QQuickWidget {
	var tmpValue = NewQQuickWidgetFromPointer(C.QQuickWidget_NewQQuickWidget3(core.PointerFromQUrl(source), widgets.PointerFromQWidget(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQQuickWidget_SceneGraphError
func callbackQQuickWidget_SceneGraphError(ptr unsafe.Pointer, error C.longlong, message C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneGraphError"); signal != nil {
		signal.(func(QQuickWindow__SceneGraphError, string))(QQuickWindow__SceneGraphError(error), cGoUnpackString(message))
	}

}

func (ptr *QQuickWidget) ConnectSceneGraphError(f func(error QQuickWindow__SceneGraphError, message string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError") {
			C.QQuickWidget_ConnectSceneGraphError(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError", func(error QQuickWindow__SceneGraphError, message string) {
				signal.(func(QQuickWindow__SceneGraphError, string))(error, message)
				f(error, message)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError", f)
		}
	}
}

func (ptr *QQuickWidget) DisconnectSceneGraphError() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DisconnectSceneGraphError(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError")
	}
}

func (ptr *QQuickWidget) SceneGraphError(error QQuickWindow__SceneGraphError, message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QQuickWidget_SceneGraphError(ptr.Pointer(), C.longlong(error), messageC)
	}
}

func (ptr *QQuickWidget) SetClearColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetClearColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

func (ptr *QQuickWidget) SetFormat(format gui.QSurfaceFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetFormat(ptr.Pointer(), gui.PointerFromQSurfaceFormat(format))
	}
}

func (ptr *QQuickWidget) SetResizeMode(vre QQuickWidget__ResizeMode) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetResizeMode(ptr.Pointer(), C.longlong(vre))
	}
}

//export callbackQQuickWidget_SetSource
func callbackQQuickWidget_SetSource(ptr unsafe.Pointer, url unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setSource"); signal != nil {
		signal.(func(*core.QUrl))(core.NewQUrlFromPointer(url))
	} else {
		NewQQuickWidgetFromPointer(ptr).SetSourceDefault(core.NewQUrlFromPointer(url))
	}
}

func (ptr *QQuickWidget) ConnectSetSource(f func(url *core.QUrl)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSource"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSource", func(url *core.QUrl) {
				signal.(func(*core.QUrl))(url)
				f(url)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSource", f)
		}
	}
}

func (ptr *QQuickWidget) DisconnectSetSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSource")
	}
}

func (ptr *QQuickWidget) SetSource(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetSource(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

func (ptr *QQuickWidget) SetSourceDefault(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetSourceDefault(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

//export callbackQQuickWidget_StatusChanged
func callbackQQuickWidget_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
		signal.(func(QQuickWidget__Status))(QQuickWidget__Status(status))
	}

}

func (ptr *QQuickWidget) ConnectStatusChanged(f func(status QQuickWidget__Status)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
			C.QQuickWidget_ConnectStatusChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QQuickWidget__Status) {
				signal.(func(QQuickWidget__Status))(status)
				f(status)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
		}
	}
}

func (ptr *QQuickWidget) DisconnectStatusChanged() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DisconnectStatusChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
	}
}

func (ptr *QQuickWidget) StatusChanged(status QQuickWidget__Status) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_StatusChanged(ptr.Pointer(), C.longlong(status))
	}
}

//export callbackQQuickWidget_DestroyQQuickWidget
func callbackQQuickWidget_DestroyQQuickWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickWidget"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).DestroyQQuickWidgetDefault()
	}
}

func (ptr *QQuickWidget) ConnectDestroyQQuickWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWidget"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWidget", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWidget", f)
		}
	}
}

func (ptr *QQuickWidget) DisconnectDestroyQQuickWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWidget")
	}
}

func (ptr *QQuickWidget) DestroyQQuickWidget() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DestroyQQuickWidget(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickWidget) DestroyQQuickWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DestroyQQuickWidgetDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickWidget) GrabFramebuffer() *gui.QImage {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQImageFromPointer(C.QQuickWidget_GrabFramebuffer(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) Errors() []*qml.QQmlError {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtQuick_PackedList) []*qml.QQmlError {
			var out = make([]*qml.QQmlError, int(l.len))
			for i := 0; i < int(l.len); i++ {
				out[i] = NewQQuickWidgetFromPointer(l.data).__errors_atList(i)
			}
			return out
		}(C.QQuickWidget_Errors(ptr.Pointer()))
	}
	return make([]*qml.QQmlError, 0)
}

func (ptr *QQuickWidget) RootContext() *qml.QQmlContext {
	if ptr.Pointer() != nil {
		var tmpValue = qml.NewQQmlContextFromPointer(C.QQuickWidget_RootContext(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) Engine() *qml.QQmlEngine {
	if ptr.Pointer() != nil {
		var tmpValue = qml.NewQQmlEngineFromPointer(C.QQuickWidget_Engine(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) RootObject() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickWidget_RootObject(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) QuickWindow() *QQuickWindow {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickWindowFromPointer(C.QQuickWidget_QuickWindow(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) InitialSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickWidget_InitialSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) Format() *gui.QSurfaceFormat {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQSurfaceFormatFromPointer(C.QQuickWidget_Format(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QSurfaceFormat).DestroyQSurfaceFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) Source() *core.QUrl {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQUrlFromPointer(C.QQuickWidget_Source(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) ResizeMode() QQuickWidget__ResizeMode {
	if ptr.Pointer() != nil {
		return QQuickWidget__ResizeMode(C.QQuickWidget_ResizeMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickWidget) Status() QQuickWidget__Status {
	if ptr.Pointer() != nil {
		return QQuickWidget__Status(C.QQuickWidget_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickWidget) __errors_atList(i int) *qml.QQmlError {
	if ptr.Pointer() != nil {
		var tmpValue = qml.NewQQmlErrorFromPointer(C.QQuickWidget___errors_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*qml.QQmlError).DestroyQQmlError)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __errors_setList(i qml.QQmlError_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___errors_setList(ptr.Pointer(), qml.PointerFromQQmlError(i))
	}
}

func (ptr *QQuickWidget) __errors_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___errors_newList(ptr.Pointer()))
}

func (ptr *QQuickWidget) __addActions_actions_atList(i int) *widgets.QAction {
	if ptr.Pointer() != nil {
		var tmpValue = widgets.NewQActionFromPointer(C.QQuickWidget___addActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __addActions_actions_setList(i widgets.QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___addActions_actions_setList(ptr.Pointer(), widgets.PointerFromQAction(i))
	}
}

func (ptr *QQuickWidget) __addActions_actions_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___addActions_actions_newList(ptr.Pointer()))
}

func (ptr *QQuickWidget) __insertActions_actions_atList(i int) *widgets.QAction {
	if ptr.Pointer() != nil {
		var tmpValue = widgets.NewQActionFromPointer(C.QQuickWidget___insertActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __insertActions_actions_setList(i widgets.QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___insertActions_actions_setList(ptr.Pointer(), widgets.PointerFromQAction(i))
	}
}

func (ptr *QQuickWidget) __insertActions_actions_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___insertActions_actions_newList(ptr.Pointer()))
}

func (ptr *QQuickWidget) __actions_atList(i int) *widgets.QAction {
	if ptr.Pointer() != nil {
		var tmpValue = widgets.NewQActionFromPointer(C.QQuickWidget___actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __actions_setList(i widgets.QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___actions_setList(ptr.Pointer(), widgets.PointerFromQAction(i))
	}
}

func (ptr *QQuickWidget) __actions_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___actions_newList(ptr.Pointer()))
}

func (ptr *QQuickWidget) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickWidget___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickWidget) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickWidget) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWidget___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWidget) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickWidget) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWidget___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWidget) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickWidget) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWidget___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWidget) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickWidget) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWidget___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWidget) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWidget) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWidget___children_newList(ptr.Pointer()))
}

//export callbackQQuickWidget_Close
func callbackQQuickWidget_Close(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "close"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWidgetFromPointer(ptr).CloseDefault())))
}

func (ptr *QQuickWidget) CloseDefault() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWidget_CloseDefault(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQQuickWidget_Event
func callbackQQuickWidget_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickWidget) EventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickWidget_FocusNextPrevChild
func callbackQQuickWidget_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusNextPrevChild"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(bool) bool)(int8(next) != 0))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWidgetFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
}

func (ptr *QQuickWidget) FocusNextPrevChildDefault(next bool) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWidget_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next)))) != 0
	}
	return false
}

//export callbackQQuickWidget_NativeEvent
func callbackQQuickWidget_NativeEvent(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result C.long) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QByteArray, unsafe.Pointer, int) bool)(core.NewQByteArrayFromPointer(eventType), message, int(int32(result))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWidgetFromPointer(ptr).NativeEventDefault(core.NewQByteArrayFromPointer(eventType), message, int(int32(result))))))
}

func (ptr *QQuickWidget) NativeEventDefault(eventType core.QByteArray_ITF, message unsafe.Pointer, result int) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWidget_NativeEventDefault(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, C.long(int32(result))) != 0
	}
	return false
}

//export callbackQQuickWidget_ActionEvent
func callbackQQuickWidget_ActionEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "actionEvent"); signal != nil {
		signal.(func(*gui.QActionEvent))(gui.NewQActionEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).ActionEventDefault(gui.NewQActionEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) ActionEventDefault(event gui.QActionEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ActionEventDefault(ptr.Pointer(), gui.PointerFromQActionEvent(event))
	}
}

//export callbackQQuickWidget_ChangeEvent
func callbackQQuickWidget_ChangeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "changeEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).ChangeEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) ChangeEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ChangeEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickWidget_CloseEvent
func callbackQQuickWidget_CloseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "closeEvent"); signal != nil {
		signal.(func(*gui.QCloseEvent))(gui.NewQCloseEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).CloseEventDefault(gui.NewQCloseEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) CloseEventDefault(event gui.QCloseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_CloseEventDefault(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
	}
}

//export callbackQQuickWidget_ContextMenuEvent
func callbackQQuickWidget_ContextMenuEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "contextMenuEvent"); signal != nil {
		signal.(func(*gui.QContextMenuEvent))(gui.NewQContextMenuEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).ContextMenuEventDefault(gui.NewQContextMenuEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) ContextMenuEventDefault(event gui.QContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ContextMenuEventDefault(ptr.Pointer(), gui.PointerFromQContextMenuEvent(event))
	}
}

//export callbackQQuickWidget_CustomContextMenuRequested
func callbackQQuickWidget_CustomContextMenuRequested(ptr unsafe.Pointer, pos unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customContextMenuRequested"); signal != nil {
		signal.(func(*core.QPoint))(core.NewQPointFromPointer(pos))
	}

}

//export callbackQQuickWidget_DragEnterEvent
func callbackQQuickWidget_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dragEnterEvent"); signal != nil {
		signal.(func(*gui.QDragEnterEvent))(gui.NewQDragEnterEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).DragEnterEventDefault(gui.NewQDragEnterEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) DragEnterEventDefault(event gui.QDragEnterEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DragEnterEventDefault(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
	}
}

//export callbackQQuickWidget_DragLeaveEvent
func callbackQQuickWidget_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dragLeaveEvent"); signal != nil {
		signal.(func(*gui.QDragLeaveEvent))(gui.NewQDragLeaveEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).DragLeaveEventDefault(gui.NewQDragLeaveEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) DragLeaveEventDefault(event gui.QDragLeaveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DragLeaveEventDefault(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
	}
}

//export callbackQQuickWidget_DragMoveEvent
func callbackQQuickWidget_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dragMoveEvent"); signal != nil {
		signal.(func(*gui.QDragMoveEvent))(gui.NewQDragMoveEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).DragMoveEventDefault(gui.NewQDragMoveEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) DragMoveEventDefault(event gui.QDragMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DragMoveEventDefault(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
	}
}

//export callbackQQuickWidget_DropEvent
func callbackQQuickWidget_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "dropEvent"); signal != nil {
		signal.(func(*gui.QDropEvent))(gui.NewQDropEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).DropEventDefault(gui.NewQDropEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) DropEventDefault(event gui.QDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DropEventDefault(ptr.Pointer(), gui.PointerFromQDropEvent(event))
	}
}

//export callbackQQuickWidget_EnterEvent
func callbackQQuickWidget_EnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "enterEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).EnterEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) EnterEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_EnterEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickWidget_FocusInEvent
func callbackQQuickWidget_FocusInEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusInEvent"); signal != nil {
		signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) FocusInEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

//export callbackQQuickWidget_FocusOutEvent
func callbackQQuickWidget_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusOutEvent"); signal != nil {
		signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

//export callbackQQuickWidget_Hide
func callbackQQuickWidget_Hide(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hide"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).HideDefault()
	}
}

func (ptr *QQuickWidget) HideDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_HideDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_HideEvent
func callbackQQuickWidget_HideEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hideEvent"); signal != nil {
		signal.(func(*gui.QHideEvent))(gui.NewQHideEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) HideEventDefault(event gui.QHideEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(event))
	}
}

//export callbackQQuickWidget_InputMethodEvent
func callbackQQuickWidget_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodEvent"); signal != nil {
		signal.(func(*gui.QInputMethodEvent))(gui.NewQInputMethodEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

//export callbackQQuickWidget_KeyPressEvent
func callbackQQuickWidget_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "keyPressEvent"); signal != nil {
		signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) KeyPressEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQQuickWidget_KeyReleaseEvent
func callbackQQuickWidget_KeyReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "keyReleaseEvent"); signal != nil {
		signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) KeyReleaseEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQQuickWidget_LeaveEvent
func callbackQQuickWidget_LeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "leaveEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).LeaveEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) LeaveEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_LeaveEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickWidget_Lower
func callbackQQuickWidget_Lower(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "lower"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).LowerDefault()
	}
}

func (ptr *QQuickWidget) LowerDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_LowerDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_MouseDoubleClickEvent
func callbackQQuickWidget_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseDoubleClickEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).MouseDoubleClickEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) MouseDoubleClickEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_MouseDoubleClickEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWidget_MouseMoveEvent
func callbackQQuickWidget_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseMoveEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).MouseMoveEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) MouseMoveEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_MouseMoveEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWidget_MousePressEvent
func callbackQQuickWidget_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mousePressEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).MousePressEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) MousePressEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_MousePressEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWidget_MouseReleaseEvent
func callbackQQuickWidget_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseReleaseEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).MouseReleaseEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) MouseReleaseEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_MouseReleaseEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWidget_MoveEvent
func callbackQQuickWidget_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "moveEvent"); signal != nil {
		signal.(func(*gui.QMoveEvent))(gui.NewQMoveEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).MoveEventDefault(gui.NewQMoveEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) MoveEventDefault(event gui.QMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_MoveEventDefault(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
	}
}

//export callbackQQuickWidget_PaintEvent
func callbackQQuickWidget_PaintEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "paintEvent"); signal != nil {
		signal.(func(*gui.QPaintEvent))(gui.NewQPaintEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) PaintEventDefault(event gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
	}
}

//export callbackQQuickWidget_Raise
func callbackQQuickWidget_Raise(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "raise"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).RaiseDefault()
	}
}

func (ptr *QQuickWidget) RaiseDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_RaiseDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_Repaint
func callbackQQuickWidget_Repaint(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "repaint"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).RepaintDefault()
	}
}

func (ptr *QQuickWidget) RepaintDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_RepaintDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_ResizeEvent
func callbackQQuickWidget_ResizeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "resizeEvent"); signal != nil {
		signal.(func(*gui.QResizeEvent))(gui.NewQResizeEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).ResizeEventDefault(gui.NewQResizeEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) ResizeEventDefault(event gui.QResizeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ResizeEventDefault(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
	}
}

//export callbackQQuickWidget_SetDisabled
func callbackQQuickWidget_SetDisabled(ptr unsafe.Pointer, disable C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setDisabled"); signal != nil {
		signal.(func(bool))(int8(disable) != 0)
	} else {
		NewQQuickWidgetFromPointer(ptr).SetDisabledDefault(int8(disable) != 0)
	}
}

func (ptr *QQuickWidget) SetDisabledDefault(disable bool) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetDisabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disable))))
	}
}

//export callbackQQuickWidget_SetEnabled
func callbackQQuickWidget_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setEnabled"); signal != nil {
		signal.(func(bool))(int8(vbo) != 0)
	} else {
		NewQQuickWidgetFromPointer(ptr).SetEnabledDefault(int8(vbo) != 0)
	}
}

func (ptr *QQuickWidget) SetEnabledDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQQuickWidget_SetFocus2
func callbackQQuickWidget_SetFocus2(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setFocus2"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).SetFocus2Default()
	}
}

func (ptr *QQuickWidget) SetFocus2Default() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetFocus2Default(ptr.Pointer())
	}
}

//export callbackQQuickWidget_SetHidden
func callbackQQuickWidget_SetHidden(ptr unsafe.Pointer, hidden C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setHidden"); signal != nil {
		signal.(func(bool))(int8(hidden) != 0)
	} else {
		NewQQuickWidgetFromPointer(ptr).SetHiddenDefault(int8(hidden) != 0)
	}
}

func (ptr *QQuickWidget) SetHiddenDefault(hidden bool) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetHiddenDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hidden))))
	}
}

//export callbackQQuickWidget_SetStyleSheet
func callbackQQuickWidget_SetStyleSheet(ptr unsafe.Pointer, styleSheet C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setStyleSheet"); signal != nil {
		signal.(func(string))(cGoUnpackString(styleSheet))
	} else {
		NewQQuickWidgetFromPointer(ptr).SetStyleSheetDefault(cGoUnpackString(styleSheet))
	}
}

func (ptr *QQuickWidget) SetStyleSheetDefault(styleSheet string) {
	if ptr.Pointer() != nil {
		var styleSheetC *C.char
		if styleSheet != "" {
			styleSheetC = C.CString(styleSheet)
			defer C.free(unsafe.Pointer(styleSheetC))
		}
		C.QQuickWidget_SetStyleSheetDefault(ptr.Pointer(), styleSheetC)
	}
}

//export callbackQQuickWidget_SetVisible
func callbackQQuickWidget_SetVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setVisible"); signal != nil {
		signal.(func(bool))(int8(visible) != 0)
	} else {
		NewQQuickWidgetFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QQuickWidget) SetVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQQuickWidget_SetWindowModified
func callbackQQuickWidget_SetWindowModified(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setWindowModified"); signal != nil {
		signal.(func(bool))(int8(vbo) != 0)
	} else {
		NewQQuickWidgetFromPointer(ptr).SetWindowModifiedDefault(int8(vbo) != 0)
	}
}

func (ptr *QQuickWidget) SetWindowModifiedDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_SetWindowModifiedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQQuickWidget_SetWindowTitle
func callbackQQuickWidget_SetWindowTitle(ptr unsafe.Pointer, vqs C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setWindowTitle"); signal != nil {
		signal.(func(string))(cGoUnpackString(vqs))
	} else {
		NewQQuickWidgetFromPointer(ptr).SetWindowTitleDefault(cGoUnpackString(vqs))
	}
}

func (ptr *QQuickWidget) SetWindowTitleDefault(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QQuickWidget_SetWindowTitleDefault(ptr.Pointer(), vqsC)
	}
}

//export callbackQQuickWidget_Show
func callbackQQuickWidget_Show(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "show"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).ShowDefault()
	}
}

func (ptr *QQuickWidget) ShowDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ShowDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_ShowEvent
func callbackQQuickWidget_ShowEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showEvent"); signal != nil {
		signal.(func(*gui.QShowEvent))(gui.NewQShowEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) ShowEventDefault(event gui.QShowEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(event))
	}
}

//export callbackQQuickWidget_ShowFullScreen
func callbackQQuickWidget_ShowFullScreen(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showFullScreen"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).ShowFullScreenDefault()
	}
}

func (ptr *QQuickWidget) ShowFullScreenDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ShowFullScreenDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_ShowMaximized
func callbackQQuickWidget_ShowMaximized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showMaximized"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).ShowMaximizedDefault()
	}
}

func (ptr *QQuickWidget) ShowMaximizedDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ShowMaximizedDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_ShowMinimized
func callbackQQuickWidget_ShowMinimized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showMinimized"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).ShowMinimizedDefault()
	}
}

func (ptr *QQuickWidget) ShowMinimizedDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ShowMinimizedDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_ShowNormal
func callbackQQuickWidget_ShowNormal(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showNormal"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).ShowNormalDefault()
	}
}

func (ptr *QQuickWidget) ShowNormalDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ShowNormalDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_TabletEvent
func callbackQQuickWidget_TabletEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "tabletEvent"); signal != nil {
		signal.(func(*gui.QTabletEvent))(gui.NewQTabletEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).TabletEventDefault(gui.NewQTabletEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) TabletEventDefault(event gui.QTabletEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_TabletEventDefault(ptr.Pointer(), gui.PointerFromQTabletEvent(event))
	}
}

//export callbackQQuickWidget_Update
func callbackQQuickWidget_Update(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "update"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).UpdateDefault()
	}
}

func (ptr *QQuickWidget) UpdateDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_UpdateDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_UpdateMicroFocus
func callbackQQuickWidget_UpdateMicroFocus(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "updateMicroFocus"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).UpdateMicroFocusDefault()
	}
}

func (ptr *QQuickWidget) UpdateMicroFocusDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_UpdateMicroFocusDefault(ptr.Pointer())
	}
}

//export callbackQQuickWidget_WheelEvent
func callbackQQuickWidget_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "wheelEvent"); signal != nil {
		signal.(func(*gui.QWheelEvent))(gui.NewQWheelEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).WheelEventDefault(gui.NewQWheelEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) WheelEventDefault(event gui.QWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_WheelEventDefault(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
	}
}

//export callbackQQuickWidget_WindowIconChanged
func callbackQQuickWidget_WindowIconChanged(ptr unsafe.Pointer, icon unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "windowIconChanged"); signal != nil {
		signal.(func(*gui.QIcon))(gui.NewQIconFromPointer(icon))
	}

}

//export callbackQQuickWidget_WindowTitleChanged
func callbackQQuickWidget_WindowTitleChanged(ptr unsafe.Pointer, title C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "windowTitleChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(title))
	}

}

//export callbackQQuickWidget_PaintEngine
func callbackQQuickWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "paintEngine"); signal != nil {
		return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
	}

	return gui.PointerFromQPaintEngine(NewQQuickWidgetFromPointer(ptr).PaintEngineDefault())
}

func (ptr *QQuickWidget) PaintEngineDefault() *gui.QPaintEngine {
	if ptr.Pointer() != nil {
		return gui.NewQPaintEngineFromPointer(C.QQuickWidget_PaintEngineDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQQuickWidget_MinimumSizeHint
func callbackQQuickWidget_MinimumSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "minimumSizeHint"); signal != nil {
		return core.PointerFromQSize(signal.(func() *core.QSize)())
	}

	return core.PointerFromQSize(NewQQuickWidgetFromPointer(ptr).MinimumSizeHintDefault())
}

func (ptr *QQuickWidget) MinimumSizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickWidget_MinimumSizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQQuickWidget_SizeHint
func callbackQQuickWidget_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sizeHint"); signal != nil {
		return core.PointerFromQSize(signal.(func() *core.QSize)())
	}

	return core.PointerFromQSize(NewQQuickWidgetFromPointer(ptr).SizeHintDefault())
}

func (ptr *QQuickWidget) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickWidget_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQQuickWidget_InputMethodQuery
func callbackQQuickWidget_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodQuery"); signal != nil {
		return core.PointerFromQVariant(signal.(func(core.Qt__InputMethodQuery) *core.QVariant)(core.Qt__InputMethodQuery(query)))
	}

	return core.PointerFromQVariant(NewQQuickWidgetFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
}

func (ptr *QQuickWidget) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQVariantFromPointer(C.QQuickWidget_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQQuickWidget_HasHeightForWidth
func callbackQQuickWidget_HasHeightForWidth(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hasHeightForWidth"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWidgetFromPointer(ptr).HasHeightForWidthDefault())))
}

func (ptr *QQuickWidget) HasHeightForWidthDefault() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWidget_HasHeightForWidthDefault(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQQuickWidget_HeightForWidth
func callbackQQuickWidget_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "heightForWidth"); signal != nil {
		return C.int(int32(signal.(func(int) int)(int(int32(w)))))
	}

	return C.int(int32(NewQQuickWidgetFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
}

func (ptr *QQuickWidget) HeightForWidthDefault(w int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QQuickWidget_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
	}
	return 0
}

//export callbackQQuickWidget_Metric
func callbackQQuickWidget_Metric(ptr unsafe.Pointer, m C.longlong) C.int {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metric"); signal != nil {
		return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(m))))
	}

	return C.int(int32(NewQQuickWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(m))))
}

func (ptr *QQuickWidget) MetricDefault(m gui.QPaintDevice__PaintDeviceMetric) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QQuickWidget_MetricDefault(ptr.Pointer(), C.longlong(m))))
	}
	return 0
}

//export callbackQQuickWidget_EventFilter
func callbackQQuickWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWidgetFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickWidget) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWidget_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickWidget_ChildEvent
func callbackQQuickWidget_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickWidget_ConnectNotify
func callbackQQuickWidget_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickWidgetFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickWidget) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickWidget_CustomEvent
func callbackQQuickWidget_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickWidget_DeleteLater
func callbackQQuickWidget_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWidgetFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickWidget) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickWidget_Destroyed
func callbackQQuickWidget_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickWidget_DisconnectNotify
func callbackQQuickWidget_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickWidgetFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickWidget) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickWidget_ObjectNameChanged
func callbackQQuickWidget_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickWidget_TimerEvent
func callbackQQuickWidget_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickWidgetFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickWidget) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWidget_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickWidget_MetaObject
func callbackQQuickWidget_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickWidgetFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickWidget) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickWidget_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QQuickWindow struct {
	gui.QWindow
}

type QQuickWindow_ITF interface {
	gui.QWindow_ITF
	QQuickWindow_PTR() *QQuickWindow
}

func (ptr *QQuickWindow) QQuickWindow_PTR() *QQuickWindow {
	return ptr
}

func (ptr *QQuickWindow) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWindow_PTR().Pointer()
	}
	return nil
}

func (ptr *QQuickWindow) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWindow_PTR().SetPointer(p)
	}
}

func PointerFromQQuickWindow(ptr QQuickWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuickWindow_PTR().Pointer()
	}
	return nil
}

func NewQQuickWindowFromPointer(ptr unsafe.Pointer) *QQuickWindow {
	var n = new(QQuickWindow)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QQuickWindow__CreateTextureOption
//QQuickWindow::CreateTextureOption
type QQuickWindow__CreateTextureOption int64

const (
	QQuickWindow__TextureHasAlphaChannel QQuickWindow__CreateTextureOption = QQuickWindow__CreateTextureOption(0x0001)
	QQuickWindow__TextureHasMipmaps      QQuickWindow__CreateTextureOption = QQuickWindow__CreateTextureOption(0x0002)
	QQuickWindow__TextureOwnsGLTexture   QQuickWindow__CreateTextureOption = QQuickWindow__CreateTextureOption(0x0004)
	QQuickWindow__TextureCanUseAtlas     QQuickWindow__CreateTextureOption = QQuickWindow__CreateTextureOption(0x0008)
	QQuickWindow__TextureIsOpaque        QQuickWindow__CreateTextureOption = QQuickWindow__CreateTextureOption(0x0010)
)

//go:generate stringer -type=QQuickWindow__RenderStage
//QQuickWindow::RenderStage
type QQuickWindow__RenderStage int64

const (
	QQuickWindow__BeforeSynchronizingStage QQuickWindow__RenderStage = QQuickWindow__RenderStage(0)
	QQuickWindow__AfterSynchronizingStage  QQuickWindow__RenderStage = QQuickWindow__RenderStage(1)
	QQuickWindow__BeforeRenderingStage     QQuickWindow__RenderStage = QQuickWindow__RenderStage(2)
	QQuickWindow__AfterRenderingStage      QQuickWindow__RenderStage = QQuickWindow__RenderStage(3)
	QQuickWindow__AfterSwapStage           QQuickWindow__RenderStage = QQuickWindow__RenderStage(4)
	QQuickWindow__NoStage                  QQuickWindow__RenderStage = QQuickWindow__RenderStage(5)
)

//go:generate stringer -type=QQuickWindow__SceneGraphError
//QQuickWindow::SceneGraphError
type QQuickWindow__SceneGraphError int64

const (
	QQuickWindow__ContextNotAvailable QQuickWindow__SceneGraphError = QQuickWindow__SceneGraphError(1)
)

func (ptr *QQuickWindow) GrabWindow() *gui.QImage {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQImageFromPointer(C.QQuickWindow_GrabWindow(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func NewQQuickWindow(parent gui.QWindow_ITF) *QQuickWindow {
	var tmpValue = NewQQuickWindowFromPointer(C.QQuickWindow_NewQQuickWindow(gui.PointerFromQWindow(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQQuickWindow_Event
func callbackQQuickWindow_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWindowFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QQuickWindow) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

func QQuickWindow_HasDefaultAlphaBuffer() bool {
	return C.QQuickWindow_QQuickWindow_HasDefaultAlphaBuffer() != 0
}

func (ptr *QQuickWindow) HasDefaultAlphaBuffer() bool {
	return C.QQuickWindow_QQuickWindow_HasDefaultAlphaBuffer() != 0
}

//export callbackQQuickWindow_ActiveFocusItemChanged
func callbackQQuickWindow_ActiveFocusItemChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "activeFocusItemChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectActiveFocusItemChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeFocusItemChanged") {
			C.QQuickWindow_ConnectActiveFocusItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeFocusItemChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeFocusItemChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeFocusItemChanged", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectActiveFocusItemChanged() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectActiveFocusItemChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeFocusItemChanged")
	}
}

func (ptr *QQuickWindow) ActiveFocusItemChanged() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ActiveFocusItemChanged(ptr.Pointer())
	}
}

//export callbackQQuickWindow_AfterAnimating
func callbackQQuickWindow_AfterAnimating(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "afterAnimating"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectAfterAnimating(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "afterAnimating") {
			C.QQuickWindow_ConnectAfterAnimating(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "afterAnimating"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "afterAnimating", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "afterAnimating", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectAfterAnimating() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectAfterAnimating(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "afterAnimating")
	}
}

func (ptr *QQuickWindow) AfterAnimating() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_AfterAnimating(ptr.Pointer())
	}
}

//export callbackQQuickWindow_AfterRendering
func callbackQQuickWindow_AfterRendering(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "afterRendering"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectAfterRendering(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "afterRendering") {
			C.QQuickWindow_ConnectAfterRendering(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "afterRendering"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "afterRendering", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "afterRendering", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectAfterRendering() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectAfterRendering(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "afterRendering")
	}
}

func (ptr *QQuickWindow) AfterRendering() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_AfterRendering(ptr.Pointer())
	}
}

//export callbackQQuickWindow_AfterSynchronizing
func callbackQQuickWindow_AfterSynchronizing(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "afterSynchronizing"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectAfterSynchronizing(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "afterSynchronizing") {
			C.QQuickWindow_ConnectAfterSynchronizing(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "afterSynchronizing"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "afterSynchronizing", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "afterSynchronizing", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectAfterSynchronizing() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectAfterSynchronizing(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "afterSynchronizing")
	}
}

func (ptr *QQuickWindow) AfterSynchronizing() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_AfterSynchronizing(ptr.Pointer())
	}
}

//export callbackQQuickWindow_BeforeRendering
func callbackQQuickWindow_BeforeRendering(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "beforeRendering"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectBeforeRendering(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "beforeRendering") {
			C.QQuickWindow_ConnectBeforeRendering(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "beforeRendering"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beforeRendering", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beforeRendering", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectBeforeRendering() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectBeforeRendering(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "beforeRendering")
	}
}

func (ptr *QQuickWindow) BeforeRendering() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_BeforeRendering(ptr.Pointer())
	}
}

//export callbackQQuickWindow_BeforeSynchronizing
func callbackQQuickWindow_BeforeSynchronizing(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "beforeSynchronizing"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectBeforeSynchronizing(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "beforeSynchronizing") {
			C.QQuickWindow_ConnectBeforeSynchronizing(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "beforeSynchronizing"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beforeSynchronizing", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beforeSynchronizing", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectBeforeSynchronizing() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectBeforeSynchronizing(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "beforeSynchronizing")
	}
}

func (ptr *QQuickWindow) BeforeSynchronizing() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_BeforeSynchronizing(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ColorChanged
func callbackQQuickWindow_ColorChanged(ptr unsafe.Pointer, vqc unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "colorChanged"); signal != nil {
		signal.(func(*gui.QColor))(gui.NewQColorFromPointer(vqc))
	}

}

func (ptr *QQuickWindow) ConnectColorChanged(f func(vqc *gui.QColor)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "colorChanged") {
			C.QQuickWindow_ConnectColorChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "colorChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "colorChanged", func(vqc *gui.QColor) {
				signal.(func(*gui.QColor))(vqc)
				f(vqc)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "colorChanged", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectColorChanged() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectColorChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "colorChanged")
	}
}

func (ptr *QQuickWindow) ColorChanged(vqc gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ColorChanged(ptr.Pointer(), gui.PointerFromQColor(vqc))
	}
}

//export callbackQQuickWindow_ExposeEvent
func callbackQQuickWindow_ExposeEvent(ptr unsafe.Pointer, vqe unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "exposeEvent"); signal != nil {
		signal.(func(*gui.QExposeEvent))(gui.NewQExposeEventFromPointer(vqe))
	} else {
		NewQQuickWindowFromPointer(ptr).ExposeEventDefault(gui.NewQExposeEventFromPointer(vqe))
	}
}

func (ptr *QQuickWindow) ExposeEventDefault(vqe gui.QExposeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ExposeEventDefault(ptr.Pointer(), gui.PointerFromQExposeEvent(vqe))
	}
}

//export callbackQQuickWindow_FocusInEvent
func callbackQQuickWindow_FocusInEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusInEvent"); signal != nil {
		signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(ev))
	} else {
		NewQQuickWindowFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QQuickWindow) FocusInEventDefault(ev gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(ev))
	}
}

//export callbackQQuickWindow_FocusOutEvent
func callbackQQuickWindow_FocusOutEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusOutEvent"); signal != nil {
		signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(ev))
	} else {
		NewQQuickWindowFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QQuickWindow) FocusOutEventDefault(ev gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(ev))
	}
}

//export callbackQQuickWindow_FrameSwapped
func callbackQQuickWindow_FrameSwapped(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "frameSwapped"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectFrameSwapped(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "frameSwapped") {
			C.QQuickWindow_ConnectFrameSwapped(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "frameSwapped"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frameSwapped", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frameSwapped", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectFrameSwapped() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectFrameSwapped(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "frameSwapped")
	}
}

func (ptr *QQuickWindow) FrameSwapped() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_FrameSwapped(ptr.Pointer())
	}
}

//export callbackQQuickWindow_HideEvent
func callbackQQuickWindow_HideEvent(ptr unsafe.Pointer, vqh unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hideEvent"); signal != nil {
		signal.(func(*gui.QHideEvent))(gui.NewQHideEventFromPointer(vqh))
	} else {
		NewQQuickWindowFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(vqh))
	}
}

func (ptr *QQuickWindow) HideEventDefault(vqh gui.QHideEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(vqh))
	}
}

//export callbackQQuickWindow_KeyPressEvent
func callbackQQuickWindow_KeyPressEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "keyPressEvent"); signal != nil {
		signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(e))
	} else {
		NewQQuickWindowFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(e))
	}
}

func (ptr *QQuickWindow) KeyPressEventDefault(e gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(e))
	}
}

//export callbackQQuickWindow_KeyReleaseEvent
func callbackQQuickWindow_KeyReleaseEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "keyReleaseEvent"); signal != nil {
		signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(e))
	} else {
		NewQQuickWindowFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(e))
	}
}

func (ptr *QQuickWindow) KeyReleaseEventDefault(e gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(e))
	}
}

//export callbackQQuickWindow_MouseDoubleClickEvent
func callbackQQuickWindow_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseDoubleClickEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).MouseDoubleClickEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) MouseDoubleClickEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_MouseDoubleClickEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWindow_MouseMoveEvent
func callbackQQuickWindow_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseMoveEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).MouseMoveEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) MouseMoveEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_MouseMoveEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWindow_MousePressEvent
func callbackQQuickWindow_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mousePressEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).MousePressEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) MousePressEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_MousePressEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWindow_MouseReleaseEvent
func callbackQQuickWindow_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseReleaseEvent"); signal != nil {
		signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).MouseReleaseEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) MouseReleaseEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_MouseReleaseEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQQuickWindow_OpenglContextCreated
func callbackQQuickWindow_OpenglContextCreated(ptr unsafe.Pointer, context unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "openglContextCreated"); signal != nil {
		signal.(func(*gui.QOpenGLContext))(gui.NewQOpenGLContextFromPointer(context))
	}

}

func (ptr *QQuickWindow) ConnectOpenglContextCreated(f func(context *gui.QOpenGLContext)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "openglContextCreated") {
			C.QQuickWindow_ConnectOpenglContextCreated(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "openglContextCreated"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "openglContextCreated", func(context *gui.QOpenGLContext) {
				signal.(func(*gui.QOpenGLContext))(context)
				f(context)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "openglContextCreated", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectOpenglContextCreated() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectOpenglContextCreated(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "openglContextCreated")
	}
}

func (ptr *QQuickWindow) OpenglContextCreated(context gui.QOpenGLContext_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_OpenglContextCreated(ptr.Pointer(), gui.PointerFromQOpenGLContext(context))
	}
}

//export callbackQQuickWindow_ReleaseResources
func callbackQQuickWindow_ReleaseResources(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "releaseResources"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).ReleaseResourcesDefault()
	}
}

func (ptr *QQuickWindow) ConnectReleaseResources(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "releaseResources"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectReleaseResources() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources")
	}
}

func (ptr *QQuickWindow) ReleaseResources() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ReleaseResources(ptr.Pointer())
	}
}

func (ptr *QQuickWindow) ReleaseResourcesDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ReleaseResourcesDefault(ptr.Pointer())
	}
}

func (ptr *QQuickWindow) ResetOpenGLState() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ResetOpenGLState(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ResizeEvent
func callbackQQuickWindow_ResizeEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "resizeEvent"); signal != nil {
		signal.(func(*gui.QResizeEvent))(gui.NewQResizeEventFromPointer(ev))
	} else {
		NewQQuickWindowFromPointer(ptr).ResizeEventDefault(gui.NewQResizeEventFromPointer(ev))
	}
}

func (ptr *QQuickWindow) ResizeEventDefault(ev gui.QResizeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ResizeEventDefault(ptr.Pointer(), gui.PointerFromQResizeEvent(ev))
	}
}

//export callbackQQuickWindow_SceneGraphAboutToStop
func callbackQQuickWindow_SceneGraphAboutToStop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneGraphAboutToStop"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectSceneGraphAboutToStop(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphAboutToStop") {
			C.QQuickWindow_ConnectSceneGraphAboutToStop(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphAboutToStop"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphAboutToStop", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphAboutToStop", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectSceneGraphAboutToStop() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectSceneGraphAboutToStop(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphAboutToStop")
	}
}

func (ptr *QQuickWindow) SceneGraphAboutToStop() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SceneGraphAboutToStop(ptr.Pointer())
	}
}

//export callbackQQuickWindow_SceneGraphError
func callbackQQuickWindow_SceneGraphError(ptr unsafe.Pointer, error C.longlong, message C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneGraphError"); signal != nil {
		signal.(func(QQuickWindow__SceneGraphError, string))(QQuickWindow__SceneGraphError(error), cGoUnpackString(message))
	}

}

func (ptr *QQuickWindow) ConnectSceneGraphError(f func(error QQuickWindow__SceneGraphError, message string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError") {
			C.QQuickWindow_ConnectSceneGraphError(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError", func(error QQuickWindow__SceneGraphError, message string) {
				signal.(func(QQuickWindow__SceneGraphError, string))(error, message)
				f(error, message)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectSceneGraphError() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectSceneGraphError(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphError")
	}
}

func (ptr *QQuickWindow) SceneGraphError(error QQuickWindow__SceneGraphError, message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QQuickWindow_SceneGraphError(ptr.Pointer(), C.longlong(error), messageC)
	}
}

//export callbackQQuickWindow_SceneGraphInitialized
func callbackQQuickWindow_SceneGraphInitialized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneGraphInitialized"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectSceneGraphInitialized(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInitialized") {
			C.QQuickWindow_ConnectSceneGraphInitialized(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInitialized"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInitialized", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInitialized", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectSceneGraphInitialized() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectSceneGraphInitialized(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInitialized")
	}
}

func (ptr *QQuickWindow) SceneGraphInitialized() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SceneGraphInitialized(ptr.Pointer())
	}
}

//export callbackQQuickWindow_SceneGraphInvalidated
func callbackQQuickWindow_SceneGraphInvalidated(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneGraphInvalidated"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QQuickWindow) ConnectSceneGraphInvalidated(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInvalidated") {
			C.QQuickWindow_ConnectSceneGraphInvalidated(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInvalidated"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInvalidated", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInvalidated", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectSceneGraphInvalidated() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectSceneGraphInvalidated(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphInvalidated")
	}
}

func (ptr *QQuickWindow) SceneGraphInvalidated() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SceneGraphInvalidated(ptr.Pointer())
	}
}

func (ptr *QQuickWindow) ScheduleRenderJob(job core.QRunnable_ITF, stage QQuickWindow__RenderStage) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ScheduleRenderJob(ptr.Pointer(), core.PointerFromQRunnable(job), C.longlong(stage))
	}
}

func (ptr *QQuickWindow) SetClearBeforeRendering(enabled bool) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetClearBeforeRendering(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QQuickWindow) SetColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

func QQuickWindow_SetDefaultAlphaBuffer(useAlpha bool) {
	C.QQuickWindow_QQuickWindow_SetDefaultAlphaBuffer(C.char(int8(qt.GoBoolToInt(useAlpha))))
}

func (ptr *QQuickWindow) SetDefaultAlphaBuffer(useAlpha bool) {
	C.QQuickWindow_QQuickWindow_SetDefaultAlphaBuffer(C.char(int8(qt.GoBoolToInt(useAlpha))))
}

func (ptr *QQuickWindow) SetPersistentOpenGLContext(persistent bool) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetPersistentOpenGLContext(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(persistent))))
	}
}

func (ptr *QQuickWindow) SetPersistentSceneGraph(persistent bool) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetPersistentSceneGraph(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(persistent))))
	}
}

func (ptr *QQuickWindow) SetRenderTarget(fbo gui.QOpenGLFramebufferObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetRenderTarget(ptr.Pointer(), gui.PointerFromQOpenGLFramebufferObject(fbo))
	}
}

func (ptr *QQuickWindow) SetRenderTarget2(fboId uint, size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetRenderTarget2(ptr.Pointer(), C.uint(uint32(fboId)), core.PointerFromQSize(size))
	}
}

func QQuickWindow_SetSceneGraphBackend(api QSGRendererInterface__GraphicsApi) {
	C.QQuickWindow_QQuickWindow_SetSceneGraphBackend(C.longlong(api))
}

func (ptr *QQuickWindow) SetSceneGraphBackend(api QSGRendererInterface__GraphicsApi) {
	C.QQuickWindow_QQuickWindow_SetSceneGraphBackend(C.longlong(api))
}

func QQuickWindow_SetSceneGraphBackend2(backend string) {
	var backendC *C.char
	if backend != "" {
		backendC = C.CString(backend)
		defer C.free(unsafe.Pointer(backendC))
	}
	C.QQuickWindow_QQuickWindow_SetSceneGraphBackend2(backendC)
}

func (ptr *QQuickWindow) SetSceneGraphBackend2(backend string) {
	var backendC *C.char
	if backend != "" {
		backendC = C.CString(backend)
		defer C.free(unsafe.Pointer(backendC))
	}
	C.QQuickWindow_QQuickWindow_SetSceneGraphBackend2(backendC)
}

//export callbackQQuickWindow_ShowEvent
func callbackQQuickWindow_ShowEvent(ptr unsafe.Pointer, vqs unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showEvent"); signal != nil {
		signal.(func(*gui.QShowEvent))(gui.NewQShowEventFromPointer(vqs))
	} else {
		NewQQuickWindowFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(vqs))
	}
}

func (ptr *QQuickWindow) ShowEventDefault(vqs gui.QShowEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(vqs))
	}
}

//export callbackQQuickWindow_Update
func callbackQQuickWindow_Update(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "update"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).UpdateDefault()
	}
}

func (ptr *QQuickWindow) ConnectUpdate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "update"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "update", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "update", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectUpdate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "update")
	}
}

func (ptr *QQuickWindow) Update() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_Update(ptr.Pointer())
	}
}

func (ptr *QQuickWindow) UpdateDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_UpdateDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_WheelEvent
func callbackQQuickWindow_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "wheelEvent"); signal != nil {
		signal.(func(*gui.QWheelEvent))(gui.NewQWheelEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).WheelEventDefault(gui.NewQWheelEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) WheelEventDefault(event gui.QWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_WheelEventDefault(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
	}
}

//export callbackQQuickWindow_DestroyQQuickWindow
func callbackQQuickWindow_DestroyQQuickWindow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QQuickWindow"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).DestroyQQuickWindowDefault()
	}
}

func (ptr *QQuickWindow) ConnectDestroyQQuickWindow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWindow"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWindow", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWindow", f)
		}
	}
}

func (ptr *QQuickWindow) DisconnectDestroyQQuickWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QQuickWindow")
	}
}

func (ptr *QQuickWindow) DestroyQQuickWindow() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DestroyQQuickWindow(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickWindow) DestroyQQuickWindowDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DestroyQQuickWindowDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QQuickWindow) AccessibleRoot() *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QQuickWindow_AccessibleRoot(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickWindow) Color() *gui.QColor {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQColorFromPointer(C.QQuickWindow_Color(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) OpenglContext() *gui.QOpenGLContext {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQOpenGLContextFromPointer(C.QQuickWindow_OpenglContext(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) RenderTarget() *gui.QOpenGLFramebufferObject {
	if ptr.Pointer() != nil {
		return gui.NewQOpenGLFramebufferObjectFromPointer(C.QQuickWindow_RenderTarget(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickWindow) IncubationController() *qml.QQmlIncubationController {
	if ptr.Pointer() != nil {
		return qml.NewQQmlIncubationControllerFromPointer(C.QQuickWindow_IncubationController(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickWindow) ActiveFocusItem() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickWindow_ActiveFocusItem(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) ContentItem() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickWindow_ContentItem(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) MouseGrabberItem() *QQuickItem {
	if ptr.Pointer() != nil {
		var tmpValue = NewQQuickItemFromPointer(C.QQuickWindow_MouseGrabberItem(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) CreateImageNode() *QSGImageNode {
	if ptr.Pointer() != nil {
		return NewQSGImageNodeFromPointer(C.QQuickWindow_CreateImageNode(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickWindow) CreateRectangleNode() *QSGRectangleNode {
	if ptr.Pointer() != nil {
		return NewQSGRectangleNodeFromPointer(C.QQuickWindow_CreateRectangleNode(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickWindow) RendererInterface() *QSGRendererInterface {
	if ptr.Pointer() != nil {
		return NewQSGRendererInterfaceFromPointer(C.QQuickWindow_RendererInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QQuickWindow) CreateTextureFromId(id uint, size core.QSize_ITF, options QQuickWindow__CreateTextureOption) *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QQuickWindow_CreateTextureFromId(ptr.Pointer(), C.uint(uint32(id)), core.PointerFromQSize(size), C.longlong(options)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) CreateTextureFromImage2(image gui.QImage_ITF) *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QQuickWindow_CreateTextureFromImage2(ptr.Pointer(), gui.PointerFromQImage(image)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) CreateTextureFromImage(image gui.QImage_ITF, options QQuickWindow__CreateTextureOption) *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QQuickWindow_CreateTextureFromImage(ptr.Pointer(), gui.PointerFromQImage(image), C.longlong(options)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) RenderTargetSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickWindow_RenderTargetSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) ClearBeforeRendering() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_ClearBeforeRendering(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickWindow) IsPersistentOpenGLContext() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_IsPersistentOpenGLContext(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickWindow) IsPersistentSceneGraph() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_IsPersistentSceneGraph(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickWindow) IsSceneGraphInitialized() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_IsSceneGraphInitialized(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuickWindow) EffectiveDevicePixelRatio() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QQuickWindow_EffectiveDevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

func (ptr *QQuickWindow) RenderTargetId() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QQuickWindow_RenderTargetId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QQuickWindow) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QQuickWindow___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QQuickWindow) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWindow___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QQuickWindow) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWindow___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWindow) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWindow___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QQuickWindow) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWindow___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWindow) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWindow___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QQuickWindow) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWindow___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWindow) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWindow___findChildren_newList(ptr.Pointer()))
}

func (ptr *QQuickWindow) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWindow___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QQuickWindow) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QQuickWindow) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QQuickWindow___children_newList(ptr.Pointer()))
}

//export callbackQQuickWindow_Close
func callbackQQuickWindow_Close(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "close"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWindowFromPointer(ptr).CloseDefault())))
}

func (ptr *QQuickWindow) CloseDefault() bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_CloseDefault(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQQuickWindow_NativeEvent
func callbackQQuickWindow_NativeEvent(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result C.long) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QByteArray, unsafe.Pointer, int) bool)(core.NewQByteArrayFromPointer(eventType), message, int(int32(result))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWindowFromPointer(ptr).NativeEventDefault(core.NewQByteArrayFromPointer(eventType), message, int(int32(result))))))
}

func (ptr *QQuickWindow) NativeEventDefault(eventType core.QByteArray_ITF, message unsafe.Pointer, result int) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_NativeEventDefault(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, C.long(int32(result))) != 0
	}
	return false
}

//export callbackQQuickWindow_ActiveChanged
func callbackQQuickWindow_ActiveChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "activeChanged"); signal != nil {
		signal.(func())()
	}

}

//export callbackQQuickWindow_Alert
func callbackQQuickWindow_Alert(ptr unsafe.Pointer, msec C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "alert"); signal != nil {
		signal.(func(int))(int(int32(msec)))
	} else {
		NewQQuickWindowFromPointer(ptr).AlertDefault(int(int32(msec)))
	}
}

func (ptr *QQuickWindow) AlertDefault(msec int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_AlertDefault(ptr.Pointer(), C.int(int32(msec)))
	}
}

//export callbackQQuickWindow_ContentOrientationChanged
func callbackQQuickWindow_ContentOrientationChanged(ptr unsafe.Pointer, orientation C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "contentOrientationChanged"); signal != nil {
		signal.(func(core.Qt__ScreenOrientation))(core.Qt__ScreenOrientation(orientation))
	}

}

//export callbackQQuickWindow_FocusObjectChanged
func callbackQQuickWindow_FocusObjectChanged(ptr unsafe.Pointer, object unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusObjectChanged"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(object))
	}

}

//export callbackQQuickWindow_HeightChanged
func callbackQQuickWindow_HeightChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "heightChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_Hide
func callbackQQuickWindow_Hide(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hide"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).HideDefault()
	}
}

func (ptr *QQuickWindow) HideDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_HideDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_Lower
func callbackQQuickWindow_Lower(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "lower"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).LowerDefault()
	}
}

func (ptr *QQuickWindow) LowerDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_LowerDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_MaximumHeightChanged
func callbackQQuickWindow_MaximumHeightChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumHeightChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_MaximumWidthChanged
func callbackQQuickWindow_MaximumWidthChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumWidthChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_MinimumHeightChanged
func callbackQQuickWindow_MinimumHeightChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "minimumHeightChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_MinimumWidthChanged
func callbackQQuickWindow_MinimumWidthChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "minimumWidthChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_ModalityChanged
func callbackQQuickWindow_ModalityChanged(ptr unsafe.Pointer, modality C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "modalityChanged"); signal != nil {
		signal.(func(core.Qt__WindowModality))(core.Qt__WindowModality(modality))
	}

}

//export callbackQQuickWindow_MoveEvent
func callbackQQuickWindow_MoveEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "moveEvent"); signal != nil {
		signal.(func(*gui.QMoveEvent))(gui.NewQMoveEventFromPointer(ev))
	} else {
		NewQQuickWindowFromPointer(ptr).MoveEventDefault(gui.NewQMoveEventFromPointer(ev))
	}
}

func (ptr *QQuickWindow) MoveEventDefault(ev gui.QMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_MoveEventDefault(ptr.Pointer(), gui.PointerFromQMoveEvent(ev))
	}
}

//export callbackQQuickWindow_OpacityChanged
func callbackQQuickWindow_OpacityChanged(ptr unsafe.Pointer, opacity C.double) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "opacityChanged"); signal != nil {
		signal.(func(float64))(float64(opacity))
	}

}

//export callbackQQuickWindow_Raise
func callbackQQuickWindow_Raise(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "raise"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).RaiseDefault()
	}
}

func (ptr *QQuickWindow) RaiseDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_RaiseDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_RequestActivate
func callbackQQuickWindow_RequestActivate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "requestActivate"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).RequestActivateDefault()
	}
}

func (ptr *QQuickWindow) RequestActivateDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_RequestActivateDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_RequestUpdate
func callbackQQuickWindow_RequestUpdate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "requestUpdate"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).RequestUpdateDefault()
	}
}

func (ptr *QQuickWindow) RequestUpdateDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_RequestUpdateDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ScreenChanged
func callbackQQuickWindow_ScreenChanged(ptr unsafe.Pointer, screen unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "screenChanged"); signal != nil {
		signal.(func(*gui.QScreen))(gui.NewQScreenFromPointer(screen))
	}

}

//export callbackQQuickWindow_SetHeight
func callbackQQuickWindow_SetHeight(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setHeight"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetHeightDefault(int(int32(arg)))
	}
}

func (ptr *QQuickWindow) SetHeightDefault(arg int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetHeightDefault(ptr.Pointer(), C.int(int32(arg)))
	}
}

//export callbackQQuickWindow_SetMaximumHeight
func callbackQQuickWindow_SetMaximumHeight(ptr unsafe.Pointer, h C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setMaximumHeight"); signal != nil {
		signal.(func(int))(int(int32(h)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetMaximumHeightDefault(int(int32(h)))
	}
}

func (ptr *QQuickWindow) SetMaximumHeightDefault(h int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetMaximumHeightDefault(ptr.Pointer(), C.int(int32(h)))
	}
}

//export callbackQQuickWindow_SetMaximumWidth
func callbackQQuickWindow_SetMaximumWidth(ptr unsafe.Pointer, w C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setMaximumWidth"); signal != nil {
		signal.(func(int))(int(int32(w)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetMaximumWidthDefault(int(int32(w)))
	}
}

func (ptr *QQuickWindow) SetMaximumWidthDefault(w int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetMaximumWidthDefault(ptr.Pointer(), C.int(int32(w)))
	}
}

//export callbackQQuickWindow_SetMinimumHeight
func callbackQQuickWindow_SetMinimumHeight(ptr unsafe.Pointer, h C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setMinimumHeight"); signal != nil {
		signal.(func(int))(int(int32(h)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetMinimumHeightDefault(int(int32(h)))
	}
}

func (ptr *QQuickWindow) SetMinimumHeightDefault(h int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetMinimumHeightDefault(ptr.Pointer(), C.int(int32(h)))
	}
}

//export callbackQQuickWindow_SetMinimumWidth
func callbackQQuickWindow_SetMinimumWidth(ptr unsafe.Pointer, w C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setMinimumWidth"); signal != nil {
		signal.(func(int))(int(int32(w)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetMinimumWidthDefault(int(int32(w)))
	}
}

func (ptr *QQuickWindow) SetMinimumWidthDefault(w int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetMinimumWidthDefault(ptr.Pointer(), C.int(int32(w)))
	}
}

//export callbackQQuickWindow_SetTitle
func callbackQQuickWindow_SetTitle(ptr unsafe.Pointer, vqs C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setTitle"); signal != nil {
		signal.(func(string))(cGoUnpackString(vqs))
	} else {
		NewQQuickWindowFromPointer(ptr).SetTitleDefault(cGoUnpackString(vqs))
	}
}

func (ptr *QQuickWindow) SetTitleDefault(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QQuickWindow_SetTitleDefault(ptr.Pointer(), vqsC)
	}
}

//export callbackQQuickWindow_SetVisible
func callbackQQuickWindow_SetVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setVisible"); signal != nil {
		signal.(func(bool))(int8(visible) != 0)
	} else {
		NewQQuickWindowFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QQuickWindow) SetVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQQuickWindow_SetWidth
func callbackQQuickWindow_SetWidth(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setWidth"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetWidthDefault(int(int32(arg)))
	}
}

func (ptr *QQuickWindow) SetWidthDefault(arg int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetWidthDefault(ptr.Pointer(), C.int(int32(arg)))
	}
}

//export callbackQQuickWindow_SetX
func callbackQQuickWindow_SetX(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setX"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetXDefault(int(int32(arg)))
	}
}

func (ptr *QQuickWindow) SetXDefault(arg int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetXDefault(ptr.Pointer(), C.int(int32(arg)))
	}
}

//export callbackQQuickWindow_SetY
func callbackQQuickWindow_SetY(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setY"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	} else {
		NewQQuickWindowFromPointer(ptr).SetYDefault(int(int32(arg)))
	}
}

func (ptr *QQuickWindow) SetYDefault(arg int) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_SetYDefault(ptr.Pointer(), C.int(int32(arg)))
	}
}

//export callbackQQuickWindow_Show
func callbackQQuickWindow_Show(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "show"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).ShowDefault()
	}
}

func (ptr *QQuickWindow) ShowDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ShowDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ShowFullScreen
func callbackQQuickWindow_ShowFullScreen(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showFullScreen"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).ShowFullScreenDefault()
	}
}

func (ptr *QQuickWindow) ShowFullScreenDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ShowFullScreenDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ShowMaximized
func callbackQQuickWindow_ShowMaximized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showMaximized"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).ShowMaximizedDefault()
	}
}

func (ptr *QQuickWindow) ShowMaximizedDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ShowMaximizedDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ShowMinimized
func callbackQQuickWindow_ShowMinimized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showMinimized"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).ShowMinimizedDefault()
	}
}

func (ptr *QQuickWindow) ShowMinimizedDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ShowMinimizedDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_ShowNormal
func callbackQQuickWindow_ShowNormal(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "showNormal"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).ShowNormalDefault()
	}
}

func (ptr *QQuickWindow) ShowNormalDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ShowNormalDefault(ptr.Pointer())
	}
}

//export callbackQQuickWindow_TabletEvent
func callbackQQuickWindow_TabletEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "tabletEvent"); signal != nil {
		signal.(func(*gui.QTabletEvent))(gui.NewQTabletEventFromPointer(ev))
	} else {
		NewQQuickWindowFromPointer(ptr).TabletEventDefault(gui.NewQTabletEventFromPointer(ev))
	}
}

func (ptr *QQuickWindow) TabletEventDefault(ev gui.QTabletEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_TabletEventDefault(ptr.Pointer(), gui.PointerFromQTabletEvent(ev))
	}
}

//export callbackQQuickWindow_TouchEvent
func callbackQQuickWindow_TouchEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "touchEvent"); signal != nil {
		signal.(func(*gui.QTouchEvent))(gui.NewQTouchEventFromPointer(ev))
	} else {
		NewQQuickWindowFromPointer(ptr).TouchEventDefault(gui.NewQTouchEventFromPointer(ev))
	}
}

func (ptr *QQuickWindow) TouchEventDefault(ev gui.QTouchEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_TouchEventDefault(ptr.Pointer(), gui.PointerFromQTouchEvent(ev))
	}
}

//export callbackQQuickWindow_VisibilityChanged
func callbackQQuickWindow_VisibilityChanged(ptr unsafe.Pointer, visibility C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "visibilityChanged"); signal != nil {
		signal.(func(gui.QWindow__Visibility))(gui.QWindow__Visibility(visibility))
	}

}

//export callbackQQuickWindow_VisibleChanged
func callbackQQuickWindow_VisibleChanged(ptr unsafe.Pointer, arg C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "visibleChanged"); signal != nil {
		signal.(func(bool))(int8(arg) != 0)
	}

}

//export callbackQQuickWindow_WidthChanged
func callbackQQuickWindow_WidthChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "widthChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_WindowStateChanged
func callbackQQuickWindow_WindowStateChanged(ptr unsafe.Pointer, windowState C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "windowStateChanged"); signal != nil {
		signal.(func(core.Qt__WindowState))(core.Qt__WindowState(windowState))
	}

}

//export callbackQQuickWindow_WindowTitleChanged
func callbackQQuickWindow_WindowTitleChanged(ptr unsafe.Pointer, title C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "windowTitleChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(title))
	}

}

//export callbackQQuickWindow_XChanged
func callbackQQuickWindow_XChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "xChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_YChanged
func callbackQQuickWindow_YChanged(ptr unsafe.Pointer, arg C.int) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "yChanged"); signal != nil {
		signal.(func(int))(int(int32(arg)))
	}

}

//export callbackQQuickWindow_FocusObject
func callbackQQuickWindow_FocusObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "focusObject"); signal != nil {
		return core.PointerFromQObject(signal.(func() *core.QObject)())
	}

	return core.PointerFromQObject(NewQQuickWindowFromPointer(ptr).FocusObjectDefault())
}

func (ptr *QQuickWindow) FocusObjectDefault() *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QQuickWindow_FocusObjectDefault(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQQuickWindow_Size
func callbackQQuickWindow_Size(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "size"); signal != nil {
		return core.PointerFromQSize(signal.(func() *core.QSize)())
	}

	return core.PointerFromQSize(NewQQuickWindowFromPointer(ptr).SizeDefault())
}

func (ptr *QQuickWindow) SizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QQuickWindow_SizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQQuickWindow_Format
func callbackQQuickWindow_Format(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "format"); signal != nil {
		return gui.PointerFromQSurfaceFormat(signal.(func() *gui.QSurfaceFormat)())
	}

	return gui.PointerFromQSurfaceFormat(NewQQuickWindowFromPointer(ptr).FormatDefault())
}

func (ptr *QQuickWindow) FormatDefault() *gui.QSurfaceFormat {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQSurfaceFormatFromPointer(C.QQuickWindow_FormatDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QSurfaceFormat).DestroyQSurfaceFormat)
		return tmpValue
	}
	return nil
}

//export callbackQQuickWindow_SurfaceType
func callbackQQuickWindow_SurfaceType(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "surfaceType"); signal != nil {
		return C.longlong(signal.(func() gui.QSurface__SurfaceType)())
	}

	return C.longlong(NewQQuickWindowFromPointer(ptr).SurfaceTypeDefault())
}

func (ptr *QQuickWindow) SurfaceTypeDefault() gui.QSurface__SurfaceType {
	if ptr.Pointer() != nil {
		return gui.QSurface__SurfaceType(C.QQuickWindow_SurfaceTypeDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQQuickWindow_EventFilter
func callbackQQuickWindow_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQQuickWindowFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QQuickWindow) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QQuickWindow_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQQuickWindow_ChildEvent
func callbackQQuickWindow_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQQuickWindow_ConnectNotify
func callbackQQuickWindow_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickWindowFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickWindow) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickWindow_CustomEvent
func callbackQQuickWindow_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQQuickWindow_DeleteLater
func callbackQQuickWindow_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQQuickWindowFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QQuickWindow) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQQuickWindow_Destroyed
func callbackQQuickWindow_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQQuickWindow_DisconnectNotify
func callbackQQuickWindow_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQQuickWindowFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QQuickWindow) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQQuickWindow_ObjectNameChanged
func callbackQQuickWindow_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQQuickWindow_TimerEvent
func callbackQQuickWindow_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQQuickWindowFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QQuickWindow) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QQuickWindow_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQQuickWindow_MetaObject
func callbackQQuickWindow_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQQuickWindowFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QQuickWindow) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QQuickWindow_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QSGAbstractRenderer struct {
	core.QObject
}

type QSGAbstractRenderer_ITF interface {
	core.QObject_ITF
	QSGAbstractRenderer_PTR() *QSGAbstractRenderer
}

func (ptr *QSGAbstractRenderer) QSGAbstractRenderer_PTR() *QSGAbstractRenderer {
	return ptr
}

func (ptr *QSGAbstractRenderer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGAbstractRenderer) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQSGAbstractRenderer(ptr QSGAbstractRenderer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGAbstractRenderer_PTR().Pointer()
	}
	return nil
}

func NewQSGAbstractRendererFromPointer(ptr unsafe.Pointer) *QSGAbstractRenderer {
	var n = new(QSGAbstractRenderer)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGAbstractRenderer) DestroyQSGAbstractRenderer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//go:generate stringer -type=QSGAbstractRenderer__ClearModeBit
//QSGAbstractRenderer::ClearModeBit
type QSGAbstractRenderer__ClearModeBit int64

const (
	QSGAbstractRenderer__ClearColorBuffer   QSGAbstractRenderer__ClearModeBit = QSGAbstractRenderer__ClearModeBit(0x0001)
	QSGAbstractRenderer__ClearDepthBuffer   QSGAbstractRenderer__ClearModeBit = QSGAbstractRenderer__ClearModeBit(0x0002)
	QSGAbstractRenderer__ClearStencilBuffer QSGAbstractRenderer__ClearModeBit = QSGAbstractRenderer__ClearModeBit(0x0004)
)

//export callbackQSGAbstractRenderer_SceneGraphChanged
func callbackQSGAbstractRenderer_SceneGraphChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneGraphChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QSGAbstractRenderer) ConnectSceneGraphChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphChanged") {
			C.QSGAbstractRenderer_ConnectSceneGraphChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphChanged", f)
		}
	}
}

func (ptr *QSGAbstractRenderer) DisconnectSceneGraphChanged() {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_DisconnectSceneGraphChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sceneGraphChanged")
	}
}

func (ptr *QSGAbstractRenderer) SceneGraphChanged() {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SceneGraphChanged(ptr.Pointer())
	}
}

func (ptr *QSGAbstractRenderer) SetClearColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetClearColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

func (ptr *QSGAbstractRenderer) SetClearMode(mode QSGAbstractRenderer__ClearModeBit) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetClearMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QSGAbstractRenderer) SetDeviceRect(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetDeviceRect(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QSGAbstractRenderer) SetDeviceRect2(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetDeviceRect2(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QSGAbstractRenderer) SetProjectionMatrix(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetProjectionMatrix(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

func (ptr *QSGAbstractRenderer) SetProjectionMatrixToRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetProjectionMatrixToRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QSGAbstractRenderer) SetViewportRect(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetViewportRect(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QSGAbstractRenderer) SetViewportRect2(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_SetViewportRect2(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QSGAbstractRenderer) ClearMode() QSGAbstractRenderer__ClearModeBit {
	if ptr.Pointer() != nil {
		return QSGAbstractRenderer__ClearModeBit(C.QSGAbstractRenderer_ClearMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGAbstractRenderer) ClearColor() *gui.QColor {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQColorFromPointer(C.QSGAbstractRenderer_ClearColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) ProjectionMatrix() *gui.QMatrix4x4 {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQMatrix4x4FromPointer(C.QSGAbstractRenderer_ProjectionMatrix(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QMatrix4x4).DestroyQMatrix4x4)
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) DeviceRect() *core.QRect {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFromPointer(C.QSGAbstractRenderer_DeviceRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) ViewportRect() *core.QRect {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFromPointer(C.QSGAbstractRenderer_ViewportRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QSGAbstractRenderer___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QSGAbstractRenderer) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGAbstractRenderer___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QSGAbstractRenderer) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGAbstractRenderer___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGAbstractRenderer) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QSGAbstractRenderer___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QSGAbstractRenderer) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGAbstractRenderer___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGAbstractRenderer) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QSGAbstractRenderer___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QSGAbstractRenderer) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGAbstractRenderer___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGAbstractRenderer) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGAbstractRenderer___findChildren_newList(ptr.Pointer()))
}

func (ptr *QSGAbstractRenderer) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGAbstractRenderer___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGAbstractRenderer) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGAbstractRenderer) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGAbstractRenderer___children_newList(ptr.Pointer()))
}

//export callbackQSGAbstractRenderer_Event
func callbackQSGAbstractRenderer_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGAbstractRendererFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QSGAbstractRenderer) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGAbstractRenderer_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQSGAbstractRenderer_EventFilter
func callbackQSGAbstractRenderer_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGAbstractRendererFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QSGAbstractRenderer) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGAbstractRenderer_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQSGAbstractRenderer_ChildEvent
func callbackQSGAbstractRenderer_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSGAbstractRendererFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSGAbstractRenderer) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQSGAbstractRenderer_ConnectNotify
func callbackQSGAbstractRenderer_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGAbstractRendererFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGAbstractRenderer) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGAbstractRenderer_CustomEvent
func callbackQSGAbstractRenderer_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQSGAbstractRendererFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSGAbstractRenderer) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQSGAbstractRenderer_DeleteLater
func callbackQSGAbstractRenderer_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQSGAbstractRendererFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QSGAbstractRenderer) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGAbstractRenderer_Destroyed
func callbackQSGAbstractRenderer_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQSGAbstractRenderer_DisconnectNotify
func callbackQSGAbstractRenderer_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGAbstractRendererFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGAbstractRenderer) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGAbstractRenderer_ObjectNameChanged
func callbackQSGAbstractRenderer_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQSGAbstractRenderer_TimerEvent
func callbackQSGAbstractRenderer_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSGAbstractRendererFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSGAbstractRenderer) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGAbstractRenderer_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQSGAbstractRenderer_MetaObject
func callbackQSGAbstractRenderer_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQSGAbstractRendererFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QSGAbstractRenderer) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QSGAbstractRenderer_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QSGBasicGeometryNode struct {
	QSGNode
}

type QSGBasicGeometryNode_ITF interface {
	QSGNode_ITF
	QSGBasicGeometryNode_PTR() *QSGBasicGeometryNode
}

func (ptr *QSGBasicGeometryNode) QSGBasicGeometryNode_PTR() *QSGBasicGeometryNode {
	return ptr
}

func (ptr *QSGBasicGeometryNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGBasicGeometryNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGBasicGeometryNode(ptr QSGBasicGeometryNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGBasicGeometryNode_PTR().Pointer()
	}
	return nil
}

func NewQSGBasicGeometryNodeFromPointer(ptr unsafe.Pointer) *QSGBasicGeometryNode {
	var n = new(QSGBasicGeometryNode)
	n.SetPointer(ptr)
	return n
}
func (ptr *QSGBasicGeometryNode) Geometry2() *QSGGeometry {
	if ptr.Pointer() != nil {
		return NewQSGGeometryFromPointer(C.QSGBasicGeometryNode_Geometry2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGBasicGeometryNode) SetGeometry(geometry QSGGeometry_ITF) {
	if ptr.Pointer() != nil {
		C.QSGBasicGeometryNode_SetGeometry(ptr.Pointer(), PointerFromQSGGeometry(geometry))
	}
}

func (ptr *QSGBasicGeometryNode) DestroyQSGBasicGeometryNode() {
	if ptr.Pointer() != nil {
		C.QSGBasicGeometryNode_DestroyQSGBasicGeometryNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGBasicGeometryNode) Geometry() *QSGGeometry {
	if ptr.Pointer() != nil {
		return NewQSGGeometryFromPointer(C.QSGBasicGeometryNode_Geometry(ptr.Pointer()))
	}
	return nil
}

type QSGBatchRenderer struct {
	ptr unsafe.Pointer
}

type QSGBatchRenderer_ITF interface {
	QSGBatchRenderer_PTR() *QSGBatchRenderer
}

func (ptr *QSGBatchRenderer) QSGBatchRenderer_PTR() *QSGBatchRenderer {
	return ptr
}

func (ptr *QSGBatchRenderer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGBatchRenderer) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGBatchRenderer(ptr QSGBatchRenderer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGBatchRenderer_PTR().Pointer()
	}
	return nil
}

func NewQSGBatchRendererFromPointer(ptr unsafe.Pointer) *QSGBatchRenderer {
	var n = new(QSGBatchRenderer)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGBatchRenderer) DestroyQSGBatchRenderer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

//go:generate stringer -type=QSGBatchRenderer__BatchCompatibility
//QSGBatchRenderer::BatchCompatibility
type QSGBatchRenderer__BatchCompatibility int64

const (
	QSGBatchRenderer__BatchBreaksOnCompare QSGBatchRenderer__BatchCompatibility = QSGBatchRenderer__BatchCompatibility(0)
	QSGBatchRenderer__BatchIsCompatible    QSGBatchRenderer__BatchCompatibility = QSGBatchRenderer__BatchCompatibility(1)
)

type QSGClipNode struct {
	QSGBasicGeometryNode
}

type QSGClipNode_ITF interface {
	QSGBasicGeometryNode_ITF
	QSGClipNode_PTR() *QSGClipNode
}

func (ptr *QSGClipNode) QSGClipNode_PTR() *QSGClipNode {
	return ptr
}

func (ptr *QSGClipNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGBasicGeometryNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGClipNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGBasicGeometryNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGClipNode(ptr QSGClipNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGClipNode_PTR().Pointer()
	}
	return nil
}

func NewQSGClipNodeFromPointer(ptr unsafe.Pointer) *QSGClipNode {
	var n = new(QSGClipNode)
	n.SetPointer(ptr)
	return n
}
func NewQSGClipNode() *QSGClipNode {
	return NewQSGClipNodeFromPointer(C.QSGClipNode_NewQSGClipNode())
}

func (ptr *QSGClipNode) SetClipRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QSGClipNode_SetClipRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QSGClipNode) SetIsRectangular(rectHint bool) {
	if ptr.Pointer() != nil {
		C.QSGClipNode_SetIsRectangular(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(rectHint))))
	}
}

func (ptr *QSGClipNode) DestroyQSGClipNode() {
	if ptr.Pointer() != nil {
		C.QSGClipNode_DestroyQSGClipNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGClipNode) ClipRect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGClipNode_ClipRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QSGClipNode) IsRectangular() bool {
	if ptr.Pointer() != nil {
		return C.QSGClipNode_IsRectangular(ptr.Pointer()) != 0
	}
	return false
}

type QSGDynamicTexture struct {
	QSGTexture
}

type QSGDynamicTexture_ITF interface {
	QSGTexture_ITF
	QSGDynamicTexture_PTR() *QSGDynamicTexture
}

func (ptr *QSGDynamicTexture) QSGDynamicTexture_PTR() *QSGDynamicTexture {
	return ptr
}

func (ptr *QSGDynamicTexture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGTexture_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGDynamicTexture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGTexture_PTR().SetPointer(p)
	}
}

func PointerFromQSGDynamicTexture(ptr QSGDynamicTexture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGDynamicTexture_PTR().Pointer()
	}
	return nil
}

func NewQSGDynamicTextureFromPointer(ptr unsafe.Pointer) *QSGDynamicTexture {
	var n = new(QSGDynamicTexture)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGDynamicTexture) DestroyQSGDynamicTexture() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGDynamicTexture_UpdateTexture
func callbackQSGDynamicTexture_UpdateTexture(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "updateTexture"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QSGDynamicTexture) ConnectUpdateTexture(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "updateTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateTexture", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateTexture", f)
		}
	}
}

func (ptr *QSGDynamicTexture) DisconnectUpdateTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "updateTexture")
	}
}

func (ptr *QSGDynamicTexture) UpdateTexture() bool {
	if ptr.Pointer() != nil {
		return C.QSGDynamicTexture_UpdateTexture(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQSGDynamicTexture_Bind
func callbackQSGDynamicTexture_Bind(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "bind"); signal != nil {
		signal.(func())()
	} else {
		NewQSGDynamicTextureFromPointer(ptr).BindDefault()
	}
}

func (ptr *QSGDynamicTexture) Bind() {
	if ptr.Pointer() != nil {
		C.QSGDynamicTexture_Bind(ptr.Pointer())
	}
}

func (ptr *QSGDynamicTexture) BindDefault() {
	if ptr.Pointer() != nil {
		C.QSGDynamicTexture_BindDefault(ptr.Pointer())
	}
}

//export callbackQSGDynamicTexture_TextureSize
func callbackQSGDynamicTexture_TextureSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureSize"); signal != nil {
		return core.PointerFromQSize(signal.(func() *core.QSize)())
	}

	return core.PointerFromQSize(NewQSGDynamicTextureFromPointer(ptr).TextureSizeDefault())
}

func (ptr *QSGDynamicTexture) TextureSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QSGDynamicTexture_TextureSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSGDynamicTexture) TextureSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QSGDynamicTexture_TextureSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQSGDynamicTexture_HasAlphaChannel
func callbackQSGDynamicTexture_HasAlphaChannel(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hasAlphaChannel"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGDynamicTextureFromPointer(ptr).HasAlphaChannelDefault())))
}

func (ptr *QSGDynamicTexture) HasAlphaChannel() bool {
	if ptr.Pointer() != nil {
		return C.QSGDynamicTexture_HasAlphaChannel(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSGDynamicTexture) HasAlphaChannelDefault() bool {
	if ptr.Pointer() != nil {
		return C.QSGDynamicTexture_HasAlphaChannelDefault(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQSGDynamicTexture_HasMipmaps
func callbackQSGDynamicTexture_HasMipmaps(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hasMipmaps"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGDynamicTextureFromPointer(ptr).HasMipmapsDefault())))
}

func (ptr *QSGDynamicTexture) HasMipmaps() bool {
	if ptr.Pointer() != nil {
		return C.QSGDynamicTexture_HasMipmaps(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSGDynamicTexture) HasMipmapsDefault() bool {
	if ptr.Pointer() != nil {
		return C.QSGDynamicTexture_HasMipmapsDefault(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQSGDynamicTexture_TextureId
func callbackQSGDynamicTexture_TextureId(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureId"); signal != nil {
		return C.int(int32(signal.(func() int)()))
	}

	return C.int(int32(NewQSGDynamicTextureFromPointer(ptr).TextureIdDefault()))
}

func (ptr *QSGDynamicTexture) TextureId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGDynamicTexture_TextureId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGDynamicTexture) TextureIdDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGDynamicTexture_TextureIdDefault(ptr.Pointer())))
	}
	return 0
}

type QSGEngine struct {
	core.QObject
}

type QSGEngine_ITF interface {
	core.QObject_ITF
	QSGEngine_PTR() *QSGEngine
}

func (ptr *QSGEngine) QSGEngine_PTR() *QSGEngine {
	return ptr
}

func (ptr *QSGEngine) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGEngine) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQSGEngine(ptr QSGEngine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGEngine_PTR().Pointer()
	}
	return nil
}

func NewQSGEngineFromPointer(ptr unsafe.Pointer) *QSGEngine {
	var n = new(QSGEngine)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGEngine__CreateTextureOption
//QSGEngine::CreateTextureOption
type QSGEngine__CreateTextureOption int64

const (
	QSGEngine__TextureHasAlphaChannel QSGEngine__CreateTextureOption = QSGEngine__CreateTextureOption(0x0001)
	QSGEngine__TextureOwnsGLTexture   QSGEngine__CreateTextureOption = QSGEngine__CreateTextureOption(0x0004)
	QSGEngine__TextureCanUseAtlas     QSGEngine__CreateTextureOption = QSGEngine__CreateTextureOption(0x0008)
	QSGEngine__TextureIsOpaque        QSGEngine__CreateTextureOption = QSGEngine__CreateTextureOption(0x0010)
)

func NewQSGEngine(parent core.QObject_ITF) *QSGEngine {
	var tmpValue = NewQSGEngineFromPointer(C.QSGEngine_NewQSGEngine(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSGEngine) Initialize(context gui.QOpenGLContext_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine_Initialize(ptr.Pointer(), gui.PointerFromQOpenGLContext(context))
	}
}

func (ptr *QSGEngine) Invalidate() {
	if ptr.Pointer() != nil {
		C.QSGEngine_Invalidate(ptr.Pointer())
	}
}

func (ptr *QSGEngine) DestroyQSGEngine() {
	if ptr.Pointer() != nil {
		C.QSGEngine_DestroyQSGEngine(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGEngine) CreateRenderer() *QSGAbstractRenderer {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGAbstractRendererFromPointer(C.QSGEngine_CreateRenderer(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) CreateImageNode() *QSGImageNode {
	if ptr.Pointer() != nil {
		return NewQSGImageNodeFromPointer(C.QSGEngine_CreateImageNode(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGEngine) CreateRectangleNode() *QSGRectangleNode {
	if ptr.Pointer() != nil {
		return NewQSGRectangleNodeFromPointer(C.QSGEngine_CreateRectangleNode(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGEngine) RendererInterface() *QSGRendererInterface {
	if ptr.Pointer() != nil {
		return NewQSGRendererInterfaceFromPointer(C.QSGEngine_RendererInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGEngine) CreateTextureFromId(id uint, size core.QSize_ITF, options QSGEngine__CreateTextureOption) *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGEngine_CreateTextureFromId(ptr.Pointer(), C.uint(uint32(id)), core.PointerFromQSize(size), C.longlong(options)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) CreateTextureFromImage(image gui.QImage_ITF, options QSGEngine__CreateTextureOption) *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGEngine_CreateTextureFromImage(ptr.Pointer(), gui.PointerFromQImage(image), C.longlong(options)))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QSGEngine___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QSGEngine) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGEngine___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QSGEngine) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGEngine___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGEngine) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QSGEngine___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QSGEngine) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGEngine___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGEngine) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QSGEngine___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QSGEngine) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGEngine___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGEngine) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGEngine___findChildren_newList(ptr.Pointer()))
}

func (ptr *QSGEngine) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGEngine___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGEngine) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGEngine) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGEngine___children_newList(ptr.Pointer()))
}

//export callbackQSGEngine_Event
func callbackQSGEngine_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGEngineFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QSGEngine) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGEngine_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQSGEngine_EventFilter
func callbackQSGEngine_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGEngineFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QSGEngine) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGEngine_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQSGEngine_ChildEvent
func callbackQSGEngine_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSGEngineFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSGEngine) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQSGEngine_ConnectNotify
func callbackQSGEngine_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGEngineFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGEngine) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGEngine_CustomEvent
func callbackQSGEngine_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQSGEngineFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSGEngine) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQSGEngine_DeleteLater
func callbackQSGEngine_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQSGEngineFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QSGEngine) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QSGEngine_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGEngine_Destroyed
func callbackQSGEngine_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQSGEngine_DisconnectNotify
func callbackQSGEngine_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGEngineFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGEngine) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGEngine_ObjectNameChanged
func callbackQSGEngine_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQSGEngine_TimerEvent
func callbackQSGEngine_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSGEngineFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSGEngine) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGEngine_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQSGEngine_MetaObject
func callbackQSGEngine_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQSGEngineFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QSGEngine) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QSGEngine_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QSGFlatColorMaterial struct {
	QSGMaterial
}

type QSGFlatColorMaterial_ITF interface {
	QSGMaterial_ITF
	QSGFlatColorMaterial_PTR() *QSGFlatColorMaterial
}

func (ptr *QSGFlatColorMaterial) QSGFlatColorMaterial_PTR() *QSGFlatColorMaterial {
	return ptr
}

func (ptr *QSGFlatColorMaterial) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterial_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGFlatColorMaterial) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGMaterial_PTR().SetPointer(p)
	}
}

func PointerFromQSGFlatColorMaterial(ptr QSGFlatColorMaterial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGFlatColorMaterial_PTR().Pointer()
	}
	return nil
}

func NewQSGFlatColorMaterialFromPointer(ptr unsafe.Pointer) *QSGFlatColorMaterial {
	var n = new(QSGFlatColorMaterial)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGFlatColorMaterial) DestroyQSGFlatColorMaterial() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func NewQSGFlatColorMaterial() *QSGFlatColorMaterial {
	return NewQSGFlatColorMaterialFromPointer(C.QSGFlatColorMaterial_NewQSGFlatColorMaterial())
}

func (ptr *QSGFlatColorMaterial) SetColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QSGFlatColorMaterial_SetColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

func (ptr *QSGFlatColorMaterial) Color() *gui.QColor {
	if ptr.Pointer() != nil {
		return gui.NewQColorFromPointer(C.QSGFlatColorMaterial_Color(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGFlatColorMaterial_CreateShader
func callbackQSGFlatColorMaterial_CreateShader(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "createShader"); signal != nil {
		return PointerFromQSGMaterialShader(signal.(func() *QSGMaterialShader)())
	}

	return PointerFromQSGMaterialShader(NewQSGFlatColorMaterialFromPointer(ptr).CreateShaderDefault())
}

func (ptr *QSGFlatColorMaterial) CreateShader() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGFlatColorMaterial_CreateShader(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGFlatColorMaterial) CreateShaderDefault() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGFlatColorMaterial_CreateShaderDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGFlatColorMaterial_Type
func callbackQSGFlatColorMaterial_Type(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "type"); signal != nil {
		return PointerFromQSGMaterialType(signal.(func() *QSGMaterialType)())
	}

	return PointerFromQSGMaterialType(NewQSGFlatColorMaterialFromPointer(ptr).TypeDefault())
}

func (ptr *QSGFlatColorMaterial) Type() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGFlatColorMaterial_Type(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGFlatColorMaterial) TypeDefault() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGFlatColorMaterial_TypeDefault(ptr.Pointer()))
	}
	return nil
}

type QSGGeometry struct {
	ptr unsafe.Pointer
}

type QSGGeometry_ITF interface {
	QSGGeometry_PTR() *QSGGeometry
}

func (ptr *QSGGeometry) QSGGeometry_PTR() *QSGGeometry {
	return ptr
}

func (ptr *QSGGeometry) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGGeometry) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGGeometry(ptr QSGGeometry_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGGeometry_PTR().Pointer()
	}
	return nil
}

func NewQSGGeometryFromPointer(ptr unsafe.Pointer) *QSGGeometry {
	var n = new(QSGGeometry)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGGeometry__AttributeType
//QSGGeometry::AttributeType
type QSGGeometry__AttributeType int64

const (
	QSGGeometry__UnknownAttribute   QSGGeometry__AttributeType = QSGGeometry__AttributeType(0)
	QSGGeometry__PositionAttribute  QSGGeometry__AttributeType = QSGGeometry__AttributeType(1)
	QSGGeometry__ColorAttribute     QSGGeometry__AttributeType = QSGGeometry__AttributeType(2)
	QSGGeometry__TexCoordAttribute  QSGGeometry__AttributeType = QSGGeometry__AttributeType(3)
	QSGGeometry__TexCoord1Attribute QSGGeometry__AttributeType = QSGGeometry__AttributeType(4)
	QSGGeometry__TexCoord2Attribute QSGGeometry__AttributeType = QSGGeometry__AttributeType(5)
)

//go:generate stringer -type=QSGGeometry__DataPattern
//QSGGeometry::DataPattern
type QSGGeometry__DataPattern int64

const (
	QSGGeometry__AlwaysUploadPattern QSGGeometry__DataPattern = QSGGeometry__DataPattern(0)
	QSGGeometry__StreamPattern       QSGGeometry__DataPattern = QSGGeometry__DataPattern(1)
	QSGGeometry__DynamicPattern      QSGGeometry__DataPattern = QSGGeometry__DataPattern(2)
	QSGGeometry__StaticPattern       QSGGeometry__DataPattern = QSGGeometry__DataPattern(3)
)

//go:generate stringer -type=QSGGeometry__DrawingMode
//QSGGeometry::DrawingMode
type QSGGeometry__DrawingMode int64

const (
	QSGGeometry__DrawPoints        QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0000)
	QSGGeometry__DrawLines         QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0001)
	QSGGeometry__DrawLineLoop      QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0002)
	QSGGeometry__DrawLineStrip     QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0003)
	QSGGeometry__DrawTriangles     QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0004)
	QSGGeometry__DrawTriangleStrip QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0005)
	QSGGeometry__DrawTriangleFan   QSGGeometry__DrawingMode = QSGGeometry__DrawingMode(0x0006)
)

//go:generate stringer -type=QSGGeometry__Type
//QSGGeometry::Type
type QSGGeometry__Type int64

const (
	QSGGeometry__ByteType          QSGGeometry__Type = QSGGeometry__Type(0x1400)
	QSGGeometry__UnsignedByteType  QSGGeometry__Type = QSGGeometry__Type(0x1401)
	QSGGeometry__ShortType         QSGGeometry__Type = QSGGeometry__Type(0x1402)
	QSGGeometry__UnsignedShortType QSGGeometry__Type = QSGGeometry__Type(0x1403)
	QSGGeometry__IntType           QSGGeometry__Type = QSGGeometry__Type(0x1404)
	QSGGeometry__UnsignedIntType   QSGGeometry__Type = QSGGeometry__Type(0x1405)
	QSGGeometry__FloatType         QSGGeometry__Type = QSGGeometry__Type(0x1406)
)

func (ptr *QSGGeometry) IndexDataAsUShort() uint16 {
	if ptr.Pointer() != nil {
		return uint16(C.QSGGeometry_IndexDataAsUShort(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGGeometry) IndexDataAsUInt() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QSGGeometry_IndexDataAsUInt(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) IndexData() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSGGeometry_IndexData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGGeometry) VertexData() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSGGeometry_VertexData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGGeometry) Allocate(vertexCount int, indexCount int) {
	if ptr.Pointer() != nil {
		C.QSGGeometry_Allocate(ptr.Pointer(), C.int(int32(vertexCount)), C.int(int32(indexCount)))
	}
}

func (ptr *QSGGeometry) MarkIndexDataDirty() {
	if ptr.Pointer() != nil {
		C.QSGGeometry_MarkIndexDataDirty(ptr.Pointer())
	}
}

func (ptr *QSGGeometry) MarkVertexDataDirty() {
	if ptr.Pointer() != nil {
		C.QSGGeometry_MarkVertexDataDirty(ptr.Pointer())
	}
}

func (ptr *QSGGeometry) SetDrawingMode(mode uint) {
	if ptr.Pointer() != nil {
		C.QSGGeometry_SetDrawingMode(ptr.Pointer(), C.uint(uint32(mode)))
	}
}

func (ptr *QSGGeometry) SetIndexDataPattern(p QSGGeometry__DataPattern) {
	if ptr.Pointer() != nil {
		C.QSGGeometry_SetIndexDataPattern(ptr.Pointer(), C.longlong(p))
	}
}

func (ptr *QSGGeometry) SetLineWidth(width float32) {
	if ptr.Pointer() != nil {
		C.QSGGeometry_SetLineWidth(ptr.Pointer(), C.float(width))
	}
}

func (ptr *QSGGeometry) SetVertexDataPattern(p QSGGeometry__DataPattern) {
	if ptr.Pointer() != nil {
		C.QSGGeometry_SetVertexDataPattern(ptr.Pointer(), C.longlong(p))
	}
}

func QSGGeometry_UpdateColoredRectGeometry(g QSGGeometry_ITF, rect core.QRectF_ITF) {
	C.QSGGeometry_QSGGeometry_UpdateColoredRectGeometry(PointerFromQSGGeometry(g), core.PointerFromQRectF(rect))
}

func (ptr *QSGGeometry) UpdateColoredRectGeometry(g QSGGeometry_ITF, rect core.QRectF_ITF) {
	C.QSGGeometry_QSGGeometry_UpdateColoredRectGeometry(PointerFromQSGGeometry(g), core.PointerFromQRectF(rect))
}

func QSGGeometry_UpdateRectGeometry(g QSGGeometry_ITF, rect core.QRectF_ITF) {
	C.QSGGeometry_QSGGeometry_UpdateRectGeometry(PointerFromQSGGeometry(g), core.PointerFromQRectF(rect))
}

func (ptr *QSGGeometry) UpdateRectGeometry(g QSGGeometry_ITF, rect core.QRectF_ITF) {
	C.QSGGeometry_QSGGeometry_UpdateRectGeometry(PointerFromQSGGeometry(g), core.PointerFromQRectF(rect))
}

func QSGGeometry_UpdateTexturedRectGeometry(g QSGGeometry_ITF, rect core.QRectF_ITF, textureRect core.QRectF_ITF) {
	C.QSGGeometry_QSGGeometry_UpdateTexturedRectGeometry(PointerFromQSGGeometry(g), core.PointerFromQRectF(rect), core.PointerFromQRectF(textureRect))
}

func (ptr *QSGGeometry) UpdateTexturedRectGeometry(g QSGGeometry_ITF, rect core.QRectF_ITF, textureRect core.QRectF_ITF) {
	C.QSGGeometry_QSGGeometry_UpdateTexturedRectGeometry(PointerFromQSGGeometry(g), core.PointerFromQRectF(rect), core.PointerFromQRectF(textureRect))
}

//export callbackQSGGeometry_DestroyQSGGeometry
func callbackQSGGeometry_DestroyQSGGeometry(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSGGeometry"); signal != nil {
		signal.(func())()
	} else {
		NewQSGGeometryFromPointer(ptr).DestroyQSGGeometryDefault()
	}
}

func (ptr *QSGGeometry) ConnectDestroyQSGGeometry(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSGGeometry"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGGeometry", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGGeometry", f)
		}
	}
}

func (ptr *QSGGeometry) DisconnectDestroyQSGGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGGeometry")
	}
}

func (ptr *QSGGeometry) DestroyQSGGeometry() {
	if ptr.Pointer() != nil {
		C.QSGGeometry_DestroyQSGGeometry(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGGeometry) DestroyQSGGeometryDefault() {
	if ptr.Pointer() != nil {
		C.QSGGeometry_DestroyQSGGeometryDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGGeometry) IndexDataPattern() QSGGeometry__DataPattern {
	if ptr.Pointer() != nil {
		return QSGGeometry__DataPattern(C.QSGGeometry_IndexDataPattern(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGGeometry) VertexDataPattern() QSGGeometry__DataPattern {
	if ptr.Pointer() != nil {
		return QSGGeometry__DataPattern(C.QSGGeometry_VertexDataPattern(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGGeometry) IndexDataAsUShort2() uint16 {
	if ptr.Pointer() != nil {
		return uint16(C.QSGGeometry_IndexDataAsUShort2(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGGeometry) IndexDataAsUInt2() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QSGGeometry_IndexDataAsUInt2(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) IndexData2() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSGGeometry_IndexData2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGGeometry) VertexData2() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSGGeometry_VertexData2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGGeometry) LineWidth() float32 {
	if ptr.Pointer() != nil {
		return float32(C.QSGGeometry_LineWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGGeometry) AttributeCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGGeometry_AttributeCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) IndexCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGGeometry_IndexCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) IndexType() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGGeometry_IndexType(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) SizeOfIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGGeometry_SizeOfIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) SizeOfVertex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGGeometry_SizeOfVertex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) VertexCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGGeometry_VertexCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGGeometry) DrawingMode() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QSGGeometry_DrawingMode(ptr.Pointer())))
	}
	return 0
}

type QSGGeometryNode struct {
	QSGBasicGeometryNode
}

type QSGGeometryNode_ITF interface {
	QSGBasicGeometryNode_ITF
	QSGGeometryNode_PTR() *QSGGeometryNode
}

func (ptr *QSGGeometryNode) QSGGeometryNode_PTR() *QSGGeometryNode {
	return ptr
}

func (ptr *QSGGeometryNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGBasicGeometryNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGGeometryNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGBasicGeometryNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGGeometryNode(ptr QSGGeometryNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGGeometryNode_PTR().Pointer()
	}
	return nil
}

func NewQSGGeometryNodeFromPointer(ptr unsafe.Pointer) *QSGGeometryNode {
	var n = new(QSGGeometryNode)
	n.SetPointer(ptr)
	return n
}
func NewQSGGeometryNode() *QSGGeometryNode {
	return NewQSGGeometryNodeFromPointer(C.QSGGeometryNode_NewQSGGeometryNode())
}

func (ptr *QSGGeometryNode) SetMaterial(material QSGMaterial_ITF) {
	if ptr.Pointer() != nil {
		C.QSGGeometryNode_SetMaterial(ptr.Pointer(), PointerFromQSGMaterial(material))
	}
}

func (ptr *QSGGeometryNode) SetOpaqueMaterial(material QSGMaterial_ITF) {
	if ptr.Pointer() != nil {
		C.QSGGeometryNode_SetOpaqueMaterial(ptr.Pointer(), PointerFromQSGMaterial(material))
	}
}

func (ptr *QSGGeometryNode) DestroyQSGGeometryNode() {
	if ptr.Pointer() != nil {
		C.QSGGeometryNode_DestroyQSGGeometryNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGGeometryNode) Material() *QSGMaterial {
	if ptr.Pointer() != nil {
		return NewQSGMaterialFromPointer(C.QSGGeometryNode_Material(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGGeometryNode) OpaqueMaterial() *QSGMaterial {
	if ptr.Pointer() != nil {
		return NewQSGMaterialFromPointer(C.QSGGeometryNode_OpaqueMaterial(ptr.Pointer()))
	}
	return nil
}

type QSGImageNode struct {
	QSGGeometryNode
}

type QSGImageNode_ITF interface {
	QSGGeometryNode_ITF
	QSGImageNode_PTR() *QSGImageNode
}

func (ptr *QSGImageNode) QSGImageNode_PTR() *QSGImageNode {
	return ptr
}

func (ptr *QSGImageNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGGeometryNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGImageNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGGeometryNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGImageNode(ptr QSGImageNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGImageNode_PTR().Pointer()
	}
	return nil
}

func NewQSGImageNodeFromPointer(ptr unsafe.Pointer) *QSGImageNode {
	var n = new(QSGImageNode)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGImageNode__TextureCoordinatesTransformFlag
//QSGImageNode::TextureCoordinatesTransformFlag
type QSGImageNode__TextureCoordinatesTransformFlag int64

const (
	QSGImageNode__NoTransform        QSGImageNode__TextureCoordinatesTransformFlag = QSGImageNode__TextureCoordinatesTransformFlag(0x00)
	QSGImageNode__MirrorHorizontally QSGImageNode__TextureCoordinatesTransformFlag = QSGImageNode__TextureCoordinatesTransformFlag(0x01)
	QSGImageNode__MirrorVertically   QSGImageNode__TextureCoordinatesTransformFlag = QSGImageNode__TextureCoordinatesTransformFlag(0x02)
)

func QSGImageNode_RebuildGeometry(g QSGGeometry_ITF, texture QSGTexture_ITF, rect core.QRectF_ITF, sourceRect core.QRectF_ITF, texCoordMode QSGImageNode__TextureCoordinatesTransformFlag) {
	C.QSGImageNode_QSGImageNode_RebuildGeometry(PointerFromQSGGeometry(g), PointerFromQSGTexture(texture), core.PointerFromQRectF(rect), core.PointerFromQRectF(sourceRect), C.longlong(texCoordMode))
}

func (ptr *QSGImageNode) RebuildGeometry(g QSGGeometry_ITF, texture QSGTexture_ITF, rect core.QRectF_ITF, sourceRect core.QRectF_ITF, texCoordMode QSGImageNode__TextureCoordinatesTransformFlag) {
	C.QSGImageNode_QSGImageNode_RebuildGeometry(PointerFromQSGGeometry(g), PointerFromQSGTexture(texture), core.PointerFromQRectF(rect), core.PointerFromQRectF(sourceRect), C.longlong(texCoordMode))
}

//export callbackQSGImageNode_SetFiltering
func callbackQSGImageNode_SetFiltering(ptr unsafe.Pointer, filtering C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setFiltering"); signal != nil {
		signal.(func(QSGTexture__Filtering))(QSGTexture__Filtering(filtering))
	}

}

func (ptr *QSGImageNode) ConnectSetFiltering(f func(filtering QSGTexture__Filtering)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFiltering"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFiltering", func(filtering QSGTexture__Filtering) {
				signal.(func(QSGTexture__Filtering))(filtering)
				f(filtering)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFiltering", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetFiltering() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFiltering")
	}
}

func (ptr *QSGImageNode) SetFiltering(filtering QSGTexture__Filtering) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetFiltering(ptr.Pointer(), C.longlong(filtering))
	}
}

//export callbackQSGImageNode_SetMipmapFiltering
func callbackQSGImageNode_SetMipmapFiltering(ptr unsafe.Pointer, filtering C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setMipmapFiltering"); signal != nil {
		signal.(func(QSGTexture__Filtering))(QSGTexture__Filtering(filtering))
	}

}

func (ptr *QSGImageNode) ConnectSetMipmapFiltering(f func(filtering QSGTexture__Filtering)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMipmapFiltering"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMipmapFiltering", func(filtering QSGTexture__Filtering) {
				signal.(func(QSGTexture__Filtering))(filtering)
				f(filtering)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMipmapFiltering", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetMipmapFiltering() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMipmapFiltering")
	}
}

func (ptr *QSGImageNode) SetMipmapFiltering(filtering QSGTexture__Filtering) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetMipmapFiltering(ptr.Pointer(), C.longlong(filtering))
	}
}

//export callbackQSGImageNode_SetOwnsTexture
func callbackQSGImageNode_SetOwnsTexture(ptr unsafe.Pointer, owns C.char) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setOwnsTexture"); signal != nil {
		signal.(func(bool))(int8(owns) != 0)
	}

}

func (ptr *QSGImageNode) ConnectSetOwnsTexture(f func(owns bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setOwnsTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOwnsTexture", func(owns bool) {
				signal.(func(bool))(owns)
				f(owns)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOwnsTexture", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetOwnsTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setOwnsTexture")
	}
}

func (ptr *QSGImageNode) SetOwnsTexture(owns bool) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetOwnsTexture(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(owns))))
	}
}

//export callbackQSGImageNode_SetRect
func callbackQSGImageNode_SetRect(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setRect"); signal != nil {
		signal.(func(*core.QRectF))(core.NewQRectFFromPointer(rect))
	}

}

func (ptr *QSGImageNode) ConnectSetRect(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setRect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRect", func(rect *core.QRectF) {
				signal.(func(*core.QRectF))(rect)
				f(rect)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRect", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setRect")
	}
}

func (ptr *QSGImageNode) SetRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QSGImageNode) SetRect2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

//export callbackQSGImageNode_SetSourceRect
func callbackQSGImageNode_SetSourceRect(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setSourceRect"); signal != nil {
		signal.(func(*core.QRectF))(core.NewQRectFFromPointer(rect))
	}

}

func (ptr *QSGImageNode) ConnectSetSourceRect(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSourceRect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceRect", func(rect *core.QRectF) {
				signal.(func(*core.QRectF))(rect)
				f(rect)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceRect", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetSourceRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceRect")
	}
}

func (ptr *QSGImageNode) SetSourceRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetSourceRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QSGImageNode) SetSourceRect2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetSourceRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

//export callbackQSGImageNode_SetTexture
func callbackQSGImageNode_SetTexture(ptr unsafe.Pointer, texture unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setTexture"); signal != nil {
		signal.(func(*QSGTexture))(NewQSGTextureFromPointer(texture))
	}

}

func (ptr *QSGImageNode) ConnectSetTexture(f func(texture *QSGTexture)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTexture", func(texture *QSGTexture) {
				signal.(func(*QSGTexture))(texture)
				f(texture)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTexture", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setTexture")
	}
}

func (ptr *QSGImageNode) SetTexture(texture QSGTexture_ITF) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetTexture(ptr.Pointer(), PointerFromQSGTexture(texture))
	}
}

//export callbackQSGImageNode_SetTextureCoordinatesTransform
func callbackQSGImageNode_SetTextureCoordinatesTransform(ptr unsafe.Pointer, mode C.longlong) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setTextureCoordinatesTransform"); signal != nil {
		signal.(func(QSGImageNode__TextureCoordinatesTransformFlag))(QSGImageNode__TextureCoordinatesTransformFlag(mode))
	}

}

func (ptr *QSGImageNode) ConnectSetTextureCoordinatesTransform(f func(mode QSGImageNode__TextureCoordinatesTransformFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setTextureCoordinatesTransform"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTextureCoordinatesTransform", func(mode QSGImageNode__TextureCoordinatesTransformFlag) {
				signal.(func(QSGImageNode__TextureCoordinatesTransformFlag))(mode)
				f(mode)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTextureCoordinatesTransform", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSetTextureCoordinatesTransform() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setTextureCoordinatesTransform")
	}
}

func (ptr *QSGImageNode) SetTextureCoordinatesTransform(mode QSGImageNode__TextureCoordinatesTransformFlag) {
	if ptr.Pointer() != nil {
		C.QSGImageNode_SetTextureCoordinatesTransform(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQSGImageNode_DestroyQSGImageNode
func callbackQSGImageNode_DestroyQSGImageNode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSGImageNode"); signal != nil {
		signal.(func())()
	} else {
		NewQSGImageNodeFromPointer(ptr).DestroyQSGImageNodeDefault()
	}
}

func (ptr *QSGImageNode) ConnectDestroyQSGImageNode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSGImageNode"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGImageNode", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGImageNode", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectDestroyQSGImageNode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGImageNode")
	}
}

func (ptr *QSGImageNode) DestroyQSGImageNode() {
	if ptr.Pointer() != nil {
		C.QSGImageNode_DestroyQSGImageNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGImageNode) DestroyQSGImageNodeDefault() {
	if ptr.Pointer() != nil {
		C.QSGImageNode_DestroyQSGImageNodeDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGImageNode_Rect
func callbackQSGImageNode_Rect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "rect"); signal != nil {
		return core.PointerFromQRectF(signal.(func() *core.QRectF)())
	}

	return core.PointerFromQRectF(core.NewQRectF())
}

func (ptr *QSGImageNode) ConnectRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "rect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rect", func() *core.QRectF {
				signal.(func() *core.QRectF)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rect", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "rect")
	}
}

func (ptr *QSGImageNode) Rect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGImageNode_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQSGImageNode_SourceRect
func callbackQSGImageNode_SourceRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "sourceRect"); signal != nil {
		return core.PointerFromQRectF(signal.(func() *core.QRectF)())
	}

	return core.PointerFromQRectF(core.NewQRectF())
}

func (ptr *QSGImageNode) ConnectSourceRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sourceRect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceRect", func() *core.QRectF {
				signal.(func() *core.QRectF)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceRect", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectSourceRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sourceRect")
	}
}

func (ptr *QSGImageNode) SourceRect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGImageNode_SourceRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQSGImageNode_Texture
func callbackQSGImageNode_Texture(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "texture"); signal != nil {
		return PointerFromQSGTexture(signal.(func() *QSGTexture)())
	}

	return PointerFromQSGTexture(NewQSGTexture())
}

func (ptr *QSGImageNode) ConnectTexture(f func() *QSGTexture) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "texture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "texture", func() *QSGTexture {
				signal.(func() *QSGTexture)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "texture", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "texture")
	}
}

func (ptr *QSGImageNode) Texture() *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGImageNode_Texture(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQSGImageNode_Filtering
func callbackQSGImageNode_Filtering(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "filtering"); signal != nil {
		return C.longlong(signal.(func() QSGTexture__Filtering)())
	}

	return C.longlong(0)
}

func (ptr *QSGImageNode) ConnectFiltering(f func() QSGTexture__Filtering) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filtering"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filtering", func() QSGTexture__Filtering {
				signal.(func() QSGTexture__Filtering)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filtering", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectFiltering() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filtering")
	}
}

func (ptr *QSGImageNode) Filtering() QSGTexture__Filtering {
	if ptr.Pointer() != nil {
		return QSGTexture__Filtering(C.QSGImageNode_Filtering(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGImageNode_MipmapFiltering
func callbackQSGImageNode_MipmapFiltering(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "mipmapFiltering"); signal != nil {
		return C.longlong(signal.(func() QSGTexture__Filtering)())
	}

	return C.longlong(0)
}

func (ptr *QSGImageNode) ConnectMipmapFiltering(f func() QSGTexture__Filtering) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mipmapFiltering"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mipmapFiltering", func() QSGTexture__Filtering {
				signal.(func() QSGTexture__Filtering)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mipmapFiltering", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectMipmapFiltering() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mipmapFiltering")
	}
}

func (ptr *QSGImageNode) MipmapFiltering() QSGTexture__Filtering {
	if ptr.Pointer() != nil {
		return QSGTexture__Filtering(C.QSGImageNode_MipmapFiltering(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGImageNode_TextureCoordinatesTransform
func callbackQSGImageNode_TextureCoordinatesTransform(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureCoordinatesTransform"); signal != nil {
		return C.longlong(signal.(func() QSGImageNode__TextureCoordinatesTransformFlag)())
	}

	return C.longlong(0)
}

func (ptr *QSGImageNode) ConnectTextureCoordinatesTransform(f func() QSGImageNode__TextureCoordinatesTransformFlag) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureCoordinatesTransform"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureCoordinatesTransform", func() QSGImageNode__TextureCoordinatesTransformFlag {
				signal.(func() QSGImageNode__TextureCoordinatesTransformFlag)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureCoordinatesTransform", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectTextureCoordinatesTransform() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureCoordinatesTransform")
	}
}

func (ptr *QSGImageNode) TextureCoordinatesTransform() QSGImageNode__TextureCoordinatesTransformFlag {
	if ptr.Pointer() != nil {
		return QSGImageNode__TextureCoordinatesTransformFlag(C.QSGImageNode_TextureCoordinatesTransform(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGImageNode_OwnsTexture
func callbackQSGImageNode_OwnsTexture(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "ownsTexture"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QSGImageNode) ConnectOwnsTexture(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "ownsTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ownsTexture", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ownsTexture", f)
		}
	}
}

func (ptr *QSGImageNode) DisconnectOwnsTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "ownsTexture")
	}
}

func (ptr *QSGImageNode) OwnsTexture() bool {
	if ptr.Pointer() != nil {
		return C.QSGImageNode_OwnsTexture(ptr.Pointer()) != 0
	}
	return false
}

type QSGMaterial struct {
	ptr unsafe.Pointer
}

type QSGMaterial_ITF interface {
	QSGMaterial_PTR() *QSGMaterial
}

func (ptr *QSGMaterial) QSGMaterial_PTR() *QSGMaterial {
	return ptr
}

func (ptr *QSGMaterial) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGMaterial) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGMaterial(ptr QSGMaterial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterial_PTR().Pointer()
	}
	return nil
}

func NewQSGMaterialFromPointer(ptr unsafe.Pointer) *QSGMaterial {
	var n = new(QSGMaterial)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGMaterial) DestroyQSGMaterial() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//go:generate stringer -type=QSGMaterial__Flag
//QSGMaterial::Flag
type QSGMaterial__Flag int64

const (
	QSGMaterial__Blending                          QSGMaterial__Flag = QSGMaterial__Flag(0x0001)
	QSGMaterial__RequiresDeterminant               QSGMaterial__Flag = QSGMaterial__Flag(0x0002)
	QSGMaterial__RequiresFullMatrixExceptTranslate QSGMaterial__Flag = QSGMaterial__Flag(0x0004 | QSGMaterial__RequiresDeterminant)
	QSGMaterial__RequiresFullMatrix                QSGMaterial__Flag = QSGMaterial__Flag(0x0008 | QSGMaterial__RequiresFullMatrixExceptTranslate)
	QSGMaterial__CustomCompileStep                 QSGMaterial__Flag = QSGMaterial__Flag(0x0010)
)

func (ptr *QSGMaterial) SetFlag(flags QSGMaterial__Flag, on bool) {
	if ptr.Pointer() != nil {
		C.QSGMaterial_SetFlag(ptr.Pointer(), C.longlong(flags), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QSGMaterial) Flags() QSGMaterial__Flag {
	if ptr.Pointer() != nil {
		return QSGMaterial__Flag(C.QSGMaterial_Flags(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGMaterial_CreateShader
func callbackQSGMaterial_CreateShader(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "createShader"); signal != nil {
		return PointerFromQSGMaterialShader(signal.(func() *QSGMaterialShader)())
	}

	return PointerFromQSGMaterialShader(nil)
}

func (ptr *QSGMaterial) ConnectCreateShader(f func() *QSGMaterialShader) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createShader"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createShader", func() *QSGMaterialShader {
				signal.(func() *QSGMaterialShader)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createShader", f)
		}
	}
}

func (ptr *QSGMaterial) DisconnectCreateShader() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "createShader")
	}
}

func (ptr *QSGMaterial) CreateShader() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGMaterial_CreateShader(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGMaterial_Type
func callbackQSGMaterial_Type(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "type"); signal != nil {
		return PointerFromQSGMaterialType(signal.(func() *QSGMaterialType)())
	}

	return PointerFromQSGMaterialType(nil)
}

func (ptr *QSGMaterial) ConnectType(f func() *QSGMaterialType) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "type"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "type", func() *QSGMaterialType {
				signal.(func() *QSGMaterialType)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "type", f)
		}
	}
}

func (ptr *QSGMaterial) DisconnectType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "type")
	}
}

func (ptr *QSGMaterial) Type() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGMaterial_Type(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGMaterial_Compare
func callbackQSGMaterial_Compare(ptr unsafe.Pointer, other unsafe.Pointer) C.int {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "compare"); signal != nil {
		return C.int(int32(signal.(func(*QSGMaterial) int)(NewQSGMaterialFromPointer(other))))
	}

	return C.int(int32(NewQSGMaterialFromPointer(ptr).CompareDefault(NewQSGMaterialFromPointer(other))))
}

func (ptr *QSGMaterial) ConnectCompare(f func(other *QSGMaterial) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "compare"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compare", func(other *QSGMaterial) int {
				signal.(func(*QSGMaterial) int)(other)
				return f(other)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compare", f)
		}
	}
}

func (ptr *QSGMaterial) DisconnectCompare() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "compare")
	}
}

func (ptr *QSGMaterial) Compare(other QSGMaterial_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGMaterial_Compare(ptr.Pointer(), PointerFromQSGMaterial(other))))
	}
	return 0
}

func (ptr *QSGMaterial) CompareDefault(other QSGMaterial_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGMaterial_CompareDefault(ptr.Pointer(), PointerFromQSGMaterial(other))))
	}
	return 0
}

type QSGMaterialShader struct {
	ptr unsafe.Pointer
}

type QSGMaterialShader_ITF interface {
	QSGMaterialShader_PTR() *QSGMaterialShader
}

func (ptr *QSGMaterialShader) QSGMaterialShader_PTR() *QSGMaterialShader {
	return ptr
}

func (ptr *QSGMaterialShader) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGMaterialShader) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGMaterialShader(ptr QSGMaterialShader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterialShader_PTR().Pointer()
	}
	return nil
}

func NewQSGMaterialShaderFromPointer(ptr unsafe.Pointer) *QSGMaterialShader {
	var n = new(QSGMaterialShader)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGMaterialShader) DestroyQSGMaterialShader() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGMaterialShader_FragmentShader
func callbackQSGMaterialShader_FragmentShader(ptr unsafe.Pointer) *C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "fragmentShader"); signal != nil {
		return C.CString(signal.(func() string)())
	}

	return C.CString(NewQSGMaterialShaderFromPointer(ptr).FragmentShaderDefault())
}

func (ptr *QSGMaterialShader) ConnectFragmentShader(f func() string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fragmentShader"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fragmentShader", func() string {
				signal.(func() string)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fragmentShader", f)
		}
	}
}

func (ptr *QSGMaterialShader) DisconnectFragmentShader() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "fragmentShader")
	}
}

func (ptr *QSGMaterialShader) FragmentShader() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSGMaterialShader_FragmentShader(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSGMaterialShader) FragmentShaderDefault() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSGMaterialShader_FragmentShaderDefault(ptr.Pointer()))
	}
	return ""
}

//export callbackQSGMaterialShader_VertexShader
func callbackQSGMaterialShader_VertexShader(ptr unsafe.Pointer) *C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "vertexShader"); signal != nil {
		return C.CString(signal.(func() string)())
	}

	return C.CString(NewQSGMaterialShaderFromPointer(ptr).VertexShaderDefault())
}

func (ptr *QSGMaterialShader) ConnectVertexShader(f func() string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "vertexShader"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "vertexShader", func() string {
				signal.(func() string)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "vertexShader", f)
		}
	}
}

func (ptr *QSGMaterialShader) DisconnectVertexShader() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "vertexShader")
	}
}

func (ptr *QSGMaterialShader) VertexShader() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSGMaterialShader_VertexShader(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSGMaterialShader) VertexShaderDefault() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSGMaterialShader_VertexShaderDefault(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSGMaterialShader) Program() *gui.QOpenGLShaderProgram {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQOpenGLShaderProgramFromPointer(C.QSGMaterialShader_Program(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQSGMaterialShader_Activate
func callbackQSGMaterialShader_Activate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "activate"); signal != nil {
		signal.(func())()
	} else {
		NewQSGMaterialShaderFromPointer(ptr).ActivateDefault()
	}
}

func (ptr *QSGMaterialShader) ConnectActivate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activate"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activate", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activate", f)
		}
	}
}

func (ptr *QSGMaterialShader) DisconnectActivate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activate")
	}
}

func (ptr *QSGMaterialShader) Activate() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_Activate(ptr.Pointer())
	}
}

func (ptr *QSGMaterialShader) ActivateDefault() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_ActivateDefault(ptr.Pointer())
	}
}

//export callbackQSGMaterialShader_Compile
func callbackQSGMaterialShader_Compile(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "compile"); signal != nil {
		signal.(func())()
	} else {
		NewQSGMaterialShaderFromPointer(ptr).CompileDefault()
	}
}

func (ptr *QSGMaterialShader) ConnectCompile(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "compile"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compile", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compile", f)
		}
	}
}

func (ptr *QSGMaterialShader) DisconnectCompile() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "compile")
	}
}

func (ptr *QSGMaterialShader) Compile() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_Compile(ptr.Pointer())
	}
}

func (ptr *QSGMaterialShader) CompileDefault() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_CompileDefault(ptr.Pointer())
	}
}

//export callbackQSGMaterialShader_Deactivate
func callbackQSGMaterialShader_Deactivate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deactivate"); signal != nil {
		signal.(func())()
	} else {
		NewQSGMaterialShaderFromPointer(ptr).DeactivateDefault()
	}
}

func (ptr *QSGMaterialShader) ConnectDeactivate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "deactivate"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deactivate", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deactivate", f)
		}
	}
}

func (ptr *QSGMaterialShader) DisconnectDeactivate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "deactivate")
	}
}

func (ptr *QSGMaterialShader) Deactivate() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_Deactivate(ptr.Pointer())
	}
}

func (ptr *QSGMaterialShader) DeactivateDefault() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_DeactivateDefault(ptr.Pointer())
	}
}

//export callbackQSGMaterialShader_Initialize
func callbackQSGMaterialShader_Initialize(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "initialize"); signal != nil {
		signal.(func())()
	} else {
		NewQSGMaterialShaderFromPointer(ptr).InitializeDefault()
	}
}

func (ptr *QSGMaterialShader) ConnectInitialize(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "initialize"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initialize", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initialize", f)
		}
	}
}

func (ptr *QSGMaterialShader) DisconnectInitialize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "initialize")
	}
}

func (ptr *QSGMaterialShader) Initialize() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_Initialize(ptr.Pointer())
	}
}

func (ptr *QSGMaterialShader) InitializeDefault() {
	if ptr.Pointer() != nil {
		C.QSGMaterialShader_InitializeDefault(ptr.Pointer())
	}
}

func (ptr *QSGMaterialShader) SetShaderSourceFile(ty gui.QOpenGLShader__ShaderTypeBit, sourceFile string) {
	if ptr.Pointer() != nil {
		var sourceFileC *C.char
		if sourceFile != "" {
			sourceFileC = C.CString(sourceFile)
			defer C.free(unsafe.Pointer(sourceFileC))
		}
		C.QSGMaterialShader_SetShaderSourceFile(ptr.Pointer(), C.longlong(ty), sourceFileC)
	}
}

func (ptr *QSGMaterialShader) SetShaderSourceFiles(ty gui.QOpenGLShader__ShaderTypeBit, sourceFiles []string) {
	if ptr.Pointer() != nil {
		var sourceFilesC = C.CString(strings.Join(sourceFiles, "|"))
		defer C.free(unsafe.Pointer(sourceFilesC))
		C.QSGMaterialShader_SetShaderSourceFiles(ptr.Pointer(), C.longlong(ty), sourceFilesC)
	}
}

type QSGMaterialType struct {
	ptr unsafe.Pointer
}

type QSGMaterialType_ITF interface {
	QSGMaterialType_PTR() *QSGMaterialType
}

func (ptr *QSGMaterialType) QSGMaterialType_PTR() *QSGMaterialType {
	return ptr
}

func (ptr *QSGMaterialType) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGMaterialType) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGMaterialType(ptr QSGMaterialType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterialType_PTR().Pointer()
	}
	return nil
}

func NewQSGMaterialTypeFromPointer(ptr unsafe.Pointer) *QSGMaterialType {
	var n = new(QSGMaterialType)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGMaterialType) DestroyQSGMaterialType() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QSGNode struct {
	ptr unsafe.Pointer
}

type QSGNode_ITF interface {
	QSGNode_PTR() *QSGNode
}

func (ptr *QSGNode) QSGNode_PTR() *QSGNode {
	return ptr
}

func (ptr *QSGNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGNode(ptr QSGNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGNode_PTR().Pointer()
	}
	return nil
}

func NewQSGNodeFromPointer(ptr unsafe.Pointer) *QSGNode {
	var n = new(QSGNode)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGNode__DirtyStateBit
//QSGNode::DirtyStateBit
type QSGNode__DirtyStateBit int64

const (
	QSGNode__DirtySubtreeBlocked QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x0080)
	QSGNode__DirtyMatrix         QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x0100)
	QSGNode__DirtyNodeAdded      QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x0400)
	QSGNode__DirtyNodeRemoved    QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x0800)
	QSGNode__DirtyGeometry       QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x1000)
	QSGNode__DirtyMaterial       QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x2000)
	QSGNode__DirtyOpacity        QSGNode__DirtyStateBit = QSGNode__DirtyStateBit(0x4000)
)

//go:generate stringer -type=QSGNode__Flag
//QSGNode::Flag
type QSGNode__Flag int64

const (
	QSGNode__OwnedByParent      QSGNode__Flag = QSGNode__Flag(0x0001)
	QSGNode__UsePreprocess      QSGNode__Flag = QSGNode__Flag(0x0002)
	QSGNode__OwnsGeometry       QSGNode__Flag = QSGNode__Flag(0x00010000)
	QSGNode__OwnsMaterial       QSGNode__Flag = QSGNode__Flag(0x00020000)
	QSGNode__OwnsOpaqueMaterial QSGNode__Flag = QSGNode__Flag(0x00040000)
	QSGNode__InternalReserved   QSGNode__Flag = QSGNode__Flag(0x01000000)
)

//go:generate stringer -type=QSGNode__NodeType
//QSGNode::NodeType
type QSGNode__NodeType int64

const (
	QSGNode__BasicNodeType     QSGNode__NodeType = QSGNode__NodeType(0)
	QSGNode__GeometryNodeType  QSGNode__NodeType = QSGNode__NodeType(1)
	QSGNode__TransformNodeType QSGNode__NodeType = QSGNode__NodeType(2)
	QSGNode__ClipNodeType      QSGNode__NodeType = QSGNode__NodeType(3)
	QSGNode__OpacityNodeType   QSGNode__NodeType = QSGNode__NodeType(4)
	QSGNode__RenderNodeType    QSGNode__NodeType = QSGNode__NodeType(5)
)

func NewQSGNode() *QSGNode {
	return NewQSGNodeFromPointer(C.QSGNode_NewQSGNode())
}

func (ptr *QSGNode) AppendChildNode(node QSGNode_ITF) {
	if ptr.Pointer() != nil {
		C.QSGNode_AppendChildNode(ptr.Pointer(), PointerFromQSGNode(node))
	}
}

func (ptr *QSGNode) InsertChildNodeAfter(node QSGNode_ITF, after QSGNode_ITF) {
	if ptr.Pointer() != nil {
		C.QSGNode_InsertChildNodeAfter(ptr.Pointer(), PointerFromQSGNode(node), PointerFromQSGNode(after))
	}
}

func (ptr *QSGNode) InsertChildNodeBefore(node QSGNode_ITF, before QSGNode_ITF) {
	if ptr.Pointer() != nil {
		C.QSGNode_InsertChildNodeBefore(ptr.Pointer(), PointerFromQSGNode(node), PointerFromQSGNode(before))
	}
}

func (ptr *QSGNode) MarkDirty(bits QSGNode__DirtyStateBit) {
	if ptr.Pointer() != nil {
		C.QSGNode_MarkDirty(ptr.Pointer(), C.longlong(bits))
	}
}

func (ptr *QSGNode) PrependChildNode(node QSGNode_ITF) {
	if ptr.Pointer() != nil {
		C.QSGNode_PrependChildNode(ptr.Pointer(), PointerFromQSGNode(node))
	}
}

//export callbackQSGNode_Preprocess
func callbackQSGNode_Preprocess(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "preprocess"); signal != nil {
		signal.(func())()
	} else {
		NewQSGNodeFromPointer(ptr).PreprocessDefault()
	}
}

func (ptr *QSGNode) ConnectPreprocess(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "preprocess"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preprocess", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preprocess", f)
		}
	}
}

func (ptr *QSGNode) DisconnectPreprocess() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "preprocess")
	}
}

func (ptr *QSGNode) Preprocess() {
	if ptr.Pointer() != nil {
		C.QSGNode_Preprocess(ptr.Pointer())
	}
}

func (ptr *QSGNode) PreprocessDefault() {
	if ptr.Pointer() != nil {
		C.QSGNode_PreprocessDefault(ptr.Pointer())
	}
}

func (ptr *QSGNode) RemoveAllChildNodes() {
	if ptr.Pointer() != nil {
		C.QSGNode_RemoveAllChildNodes(ptr.Pointer())
	}
}

func (ptr *QSGNode) RemoveChildNode(node QSGNode_ITF) {
	if ptr.Pointer() != nil {
		C.QSGNode_RemoveChildNode(ptr.Pointer(), PointerFromQSGNode(node))
	}
}

func (ptr *QSGNode) SetFlag(fo QSGNode__Flag, enabled bool) {
	if ptr.Pointer() != nil {
		C.QSGNode_SetFlag(ptr.Pointer(), C.longlong(fo), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QSGNode) SetFlags(fo QSGNode__Flag, enabled bool) {
	if ptr.Pointer() != nil {
		C.QSGNode_SetFlags(ptr.Pointer(), C.longlong(fo), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

//export callbackQSGNode_DestroyQSGNode
func callbackQSGNode_DestroyQSGNode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSGNode"); signal != nil {
		signal.(func())()
	} else {
		NewQSGNodeFromPointer(ptr).DestroyQSGNodeDefault()
	}
}

func (ptr *QSGNode) ConnectDestroyQSGNode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSGNode"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGNode", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGNode", f)
		}
	}
}

func (ptr *QSGNode) DisconnectDestroyQSGNode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGNode")
	}
}

func (ptr *QSGNode) DestroyQSGNode() {
	if ptr.Pointer() != nil {
		C.QSGNode_DestroyQSGNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGNode) DestroyQSGNodeDefault() {
	if ptr.Pointer() != nil {
		C.QSGNode_DestroyQSGNodeDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGNode) Flags() QSGNode__Flag {
	if ptr.Pointer() != nil {
		return QSGNode__Flag(C.QSGNode_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGNode) Type() QSGNode__NodeType {
	if ptr.Pointer() != nil {
		return QSGNode__NodeType(C.QSGNode_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGNode) ChildAtIndex(i int) *QSGNode {
	if ptr.Pointer() != nil {
		return NewQSGNodeFromPointer(C.QSGNode_ChildAtIndex(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QSGNode) FirstChild() *QSGNode {
	if ptr.Pointer() != nil {
		return NewQSGNodeFromPointer(C.QSGNode_FirstChild(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGNode) LastChild() *QSGNode {
	if ptr.Pointer() != nil {
		return NewQSGNodeFromPointer(C.QSGNode_LastChild(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGNode) NextSibling() *QSGNode {
	if ptr.Pointer() != nil {
		return NewQSGNodeFromPointer(C.QSGNode_NextSibling(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGNode) Parent() *QSGNode {
	if ptr.Pointer() != nil {
		return NewQSGNodeFromPointer(C.QSGNode_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGNode) PreviousSibling() *QSGNode {
	if ptr.Pointer() != nil {
		return NewQSGNodeFromPointer(C.QSGNode_PreviousSibling(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGNode_IsSubtreeBlocked
func callbackQSGNode_IsSubtreeBlocked(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "isSubtreeBlocked"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGNodeFromPointer(ptr).IsSubtreeBlockedDefault())))
}

func (ptr *QSGNode) ConnectIsSubtreeBlocked(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isSubtreeBlocked"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isSubtreeBlocked", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isSubtreeBlocked", f)
		}
	}
}

func (ptr *QSGNode) DisconnectIsSubtreeBlocked() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isSubtreeBlocked")
	}
}

func (ptr *QSGNode) IsSubtreeBlocked() bool {
	if ptr.Pointer() != nil {
		return C.QSGNode_IsSubtreeBlocked(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSGNode) IsSubtreeBlockedDefault() bool {
	if ptr.Pointer() != nil {
		return C.QSGNode_IsSubtreeBlockedDefault(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSGNode) ChildCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGNode_ChildCount(ptr.Pointer())))
	}
	return 0
}

type QSGOpacityNode struct {
	QSGNode
}

type QSGOpacityNode_ITF interface {
	QSGNode_ITF
	QSGOpacityNode_PTR() *QSGOpacityNode
}

func (ptr *QSGOpacityNode) QSGOpacityNode_PTR() *QSGOpacityNode {
	return ptr
}

func (ptr *QSGOpacityNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGOpacityNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGOpacityNode(ptr QSGOpacityNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGOpacityNode_PTR().Pointer()
	}
	return nil
}

func NewQSGOpacityNodeFromPointer(ptr unsafe.Pointer) *QSGOpacityNode {
	var n = new(QSGOpacityNode)
	n.SetPointer(ptr)
	return n
}
func NewQSGOpacityNode() *QSGOpacityNode {
	return NewQSGOpacityNodeFromPointer(C.QSGOpacityNode_NewQSGOpacityNode())
}

func (ptr *QSGOpacityNode) SetOpacity(opacity float64) {
	if ptr.Pointer() != nil {
		C.QSGOpacityNode_SetOpacity(ptr.Pointer(), C.double(opacity))
	}
}

func (ptr *QSGOpacityNode) DestroyQSGOpacityNode() {
	if ptr.Pointer() != nil {
		C.QSGOpacityNode_DestroyQSGOpacityNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGOpacityNode) Opacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QSGOpacityNode_Opacity(ptr.Pointer()))
	}
	return 0
}

type QSGOpaqueTextureMaterial struct {
	QSGMaterial
}

type QSGOpaqueTextureMaterial_ITF interface {
	QSGMaterial_ITF
	QSGOpaqueTextureMaterial_PTR() *QSGOpaqueTextureMaterial
}

func (ptr *QSGOpaqueTextureMaterial) QSGOpaqueTextureMaterial_PTR() *QSGOpaqueTextureMaterial {
	return ptr
}

func (ptr *QSGOpaqueTextureMaterial) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterial_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGOpaqueTextureMaterial) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGMaterial_PTR().SetPointer(p)
	}
}

func PointerFromQSGOpaqueTextureMaterial(ptr QSGOpaqueTextureMaterial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGOpaqueTextureMaterial_PTR().Pointer()
	}
	return nil
}

func NewQSGOpaqueTextureMaterialFromPointer(ptr unsafe.Pointer) *QSGOpaqueTextureMaterial {
	var n = new(QSGOpaqueTextureMaterial)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGOpaqueTextureMaterial) DestroyQSGOpaqueTextureMaterial() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func NewQSGOpaqueTextureMaterial() *QSGOpaqueTextureMaterial {
	return NewQSGOpaqueTextureMaterialFromPointer(C.QSGOpaqueTextureMaterial_NewQSGOpaqueTextureMaterial())
}

func (ptr *QSGOpaqueTextureMaterial) SetFiltering(filtering QSGTexture__Filtering) {
	if ptr.Pointer() != nil {
		C.QSGOpaqueTextureMaterial_SetFiltering(ptr.Pointer(), C.longlong(filtering))
	}
}

func (ptr *QSGOpaqueTextureMaterial) SetHorizontalWrapMode(mode QSGTexture__WrapMode) {
	if ptr.Pointer() != nil {
		C.QSGOpaqueTextureMaterial_SetHorizontalWrapMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QSGOpaqueTextureMaterial) SetMipmapFiltering(filtering QSGTexture__Filtering) {
	if ptr.Pointer() != nil {
		C.QSGOpaqueTextureMaterial_SetMipmapFiltering(ptr.Pointer(), C.longlong(filtering))
	}
}

func (ptr *QSGOpaqueTextureMaterial) SetTexture(texture QSGTexture_ITF) {
	if ptr.Pointer() != nil {
		C.QSGOpaqueTextureMaterial_SetTexture(ptr.Pointer(), PointerFromQSGTexture(texture))
	}
}

func (ptr *QSGOpaqueTextureMaterial) SetVerticalWrapMode(mode QSGTexture__WrapMode) {
	if ptr.Pointer() != nil {
		C.QSGOpaqueTextureMaterial_SetVerticalWrapMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QSGOpaqueTextureMaterial) Texture() *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGOpaqueTextureMaterial_Texture(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGOpaqueTextureMaterial) Filtering() QSGTexture__Filtering {
	if ptr.Pointer() != nil {
		return QSGTexture__Filtering(C.QSGOpaqueTextureMaterial_Filtering(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGOpaqueTextureMaterial) MipmapFiltering() QSGTexture__Filtering {
	if ptr.Pointer() != nil {
		return QSGTexture__Filtering(C.QSGOpaqueTextureMaterial_MipmapFiltering(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGOpaqueTextureMaterial) HorizontalWrapMode() QSGTexture__WrapMode {
	if ptr.Pointer() != nil {
		return QSGTexture__WrapMode(C.QSGOpaqueTextureMaterial_HorizontalWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGOpaqueTextureMaterial) VerticalWrapMode() QSGTexture__WrapMode {
	if ptr.Pointer() != nil {
		return QSGTexture__WrapMode(C.QSGOpaqueTextureMaterial_VerticalWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGOpaqueTextureMaterial) M_texture() *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGOpaqueTextureMaterial_M_texture(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGOpaqueTextureMaterial) SetM_texture(vqs QSGTexture_ITF) {
	if ptr.Pointer() != nil {
		C.QSGOpaqueTextureMaterial_SetM_texture(ptr.Pointer(), PointerFromQSGTexture(vqs))
	}
}

//export callbackQSGOpaqueTextureMaterial_CreateShader
func callbackQSGOpaqueTextureMaterial_CreateShader(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "createShader"); signal != nil {
		return PointerFromQSGMaterialShader(signal.(func() *QSGMaterialShader)())
	}

	return PointerFromQSGMaterialShader(NewQSGOpaqueTextureMaterialFromPointer(ptr).CreateShaderDefault())
}

func (ptr *QSGOpaqueTextureMaterial) CreateShader() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGOpaqueTextureMaterial_CreateShader(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGOpaqueTextureMaterial) CreateShaderDefault() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGOpaqueTextureMaterial_CreateShaderDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGOpaqueTextureMaterial_Type
func callbackQSGOpaqueTextureMaterial_Type(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "type"); signal != nil {
		return PointerFromQSGMaterialType(signal.(func() *QSGMaterialType)())
	}

	return PointerFromQSGMaterialType(NewQSGOpaqueTextureMaterialFromPointer(ptr).TypeDefault())
}

func (ptr *QSGOpaqueTextureMaterial) Type() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGOpaqueTextureMaterial_Type(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGOpaqueTextureMaterial) TypeDefault() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGOpaqueTextureMaterial_TypeDefault(ptr.Pointer()))
	}
	return nil
}

type QSGRectangleNode struct {
	QSGGeometryNode
}

type QSGRectangleNode_ITF interface {
	QSGGeometryNode_ITF
	QSGRectangleNode_PTR() *QSGRectangleNode
}

func (ptr *QSGRectangleNode) QSGRectangleNode_PTR() *QSGRectangleNode {
	return ptr
}

func (ptr *QSGRectangleNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGGeometryNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGRectangleNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGGeometryNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGRectangleNode(ptr QSGRectangleNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGRectangleNode_PTR().Pointer()
	}
	return nil
}

func NewQSGRectangleNodeFromPointer(ptr unsafe.Pointer) *QSGRectangleNode {
	var n = new(QSGRectangleNode)
	n.SetPointer(ptr)
	return n
}

//export callbackQSGRectangleNode_SetColor
func callbackQSGRectangleNode_SetColor(ptr unsafe.Pointer, color unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setColor"); signal != nil {
		signal.(func(*gui.QColor))(gui.NewQColorFromPointer(color))
	}

}

func (ptr *QSGRectangleNode) ConnectSetColor(f func(color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setColor"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setColor", func(color *gui.QColor) {
				signal.(func(*gui.QColor))(color)
				f(color)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setColor", f)
		}
	}
}

func (ptr *QSGRectangleNode) DisconnectSetColor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setColor")
	}
}

func (ptr *QSGRectangleNode) SetColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QSGRectangleNode_SetColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

//export callbackQSGRectangleNode_SetRect
func callbackQSGRectangleNode_SetRect(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "setRect"); signal != nil {
		signal.(func(*core.QRectF))(core.NewQRectFFromPointer(rect))
	}

}

func (ptr *QSGRectangleNode) ConnectSetRect(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setRect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRect", func(rect *core.QRectF) {
				signal.(func(*core.QRectF))(rect)
				f(rect)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRect", f)
		}
	}
}

func (ptr *QSGRectangleNode) DisconnectSetRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setRect")
	}
}

func (ptr *QSGRectangleNode) SetRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QSGRectangleNode_SetRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QSGRectangleNode) SetRect2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QSGRectangleNode_SetRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

//export callbackQSGRectangleNode_DestroyQSGRectangleNode
func callbackQSGRectangleNode_DestroyQSGRectangleNode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSGRectangleNode"); signal != nil {
		signal.(func())()
	} else {
		NewQSGRectangleNodeFromPointer(ptr).DestroyQSGRectangleNodeDefault()
	}
}

func (ptr *QSGRectangleNode) ConnectDestroyQSGRectangleNode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSGRectangleNode"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGRectangleNode", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGRectangleNode", f)
		}
	}
}

func (ptr *QSGRectangleNode) DisconnectDestroyQSGRectangleNode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGRectangleNode")
	}
}

func (ptr *QSGRectangleNode) DestroyQSGRectangleNode() {
	if ptr.Pointer() != nil {
		C.QSGRectangleNode_DestroyQSGRectangleNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGRectangleNode) DestroyQSGRectangleNodeDefault() {
	if ptr.Pointer() != nil {
		C.QSGRectangleNode_DestroyQSGRectangleNodeDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGRectangleNode_Color
func callbackQSGRectangleNode_Color(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "color"); signal != nil {
		return gui.PointerFromQColor(signal.(func() *gui.QColor)())
	}

	return gui.PointerFromQColor(gui.NewQColor())
}

func (ptr *QSGRectangleNode) ConnectColor(f func() *gui.QColor) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "color"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "color", func() *gui.QColor {
				signal.(func() *gui.QColor)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "color", f)
		}
	}
}

func (ptr *QSGRectangleNode) DisconnectColor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "color")
	}
}

func (ptr *QSGRectangleNode) Color() *gui.QColor {
	if ptr.Pointer() != nil {
		var tmpValue = gui.NewQColorFromPointer(C.QSGRectangleNode_Color(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

//export callbackQSGRectangleNode_Rect
func callbackQSGRectangleNode_Rect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "rect"); signal != nil {
		return core.PointerFromQRectF(signal.(func() *core.QRectF)())
	}

	return core.PointerFromQRectF(core.NewQRectF())
}

func (ptr *QSGRectangleNode) ConnectRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "rect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rect", func() *core.QRectF {
				signal.(func() *core.QRectF)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rect", f)
		}
	}
}

func (ptr *QSGRectangleNode) DisconnectRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "rect")
	}
}

func (ptr *QSGRectangleNode) Rect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGRectangleNode_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QSGRenderNode struct {
	QSGNode
}

type QSGRenderNode_ITF interface {
	QSGNode_ITF
	QSGRenderNode_PTR() *QSGRenderNode
}

func (ptr *QSGRenderNode) QSGRenderNode_PTR() *QSGRenderNode {
	return ptr
}

func (ptr *QSGRenderNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGRenderNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGRenderNode(ptr QSGRenderNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGRenderNode_PTR().Pointer()
	}
	return nil
}

func NewQSGRenderNodeFromPointer(ptr unsafe.Pointer) *QSGRenderNode {
	var n = new(QSGRenderNode)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGRenderNode__RenderingFlag
//QSGRenderNode::RenderingFlag
type QSGRenderNode__RenderingFlag int64

const (
	QSGRenderNode__BoundedRectRendering QSGRenderNode__RenderingFlag = QSGRenderNode__RenderingFlag(0x01)
	QSGRenderNode__DepthAwareRendering  QSGRenderNode__RenderingFlag = QSGRenderNode__RenderingFlag(0x02)
	QSGRenderNode__OpaqueRendering      QSGRenderNode__RenderingFlag = QSGRenderNode__RenderingFlag(0x04)
)

//go:generate stringer -type=QSGRenderNode__StateFlag
//QSGRenderNode::StateFlag
type QSGRenderNode__StateFlag int64

const (
	QSGRenderNode__DepthState        QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x01)
	QSGRenderNode__StencilState      QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x02)
	QSGRenderNode__ScissorState      QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x04)
	QSGRenderNode__ColorState        QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x08)
	QSGRenderNode__BlendState        QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x10)
	QSGRenderNode__CullState         QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x20)
	QSGRenderNode__ViewportState     QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x40)
	QSGRenderNode__RenderTargetState QSGRenderNode__StateFlag = QSGRenderNode__StateFlag(0x80)
)

//export callbackQSGRenderNode_ReleaseResources
func callbackQSGRenderNode_ReleaseResources(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "releaseResources"); signal != nil {
		signal.(func())()
	} else {
		NewQSGRenderNodeFromPointer(ptr).ReleaseResourcesDefault()
	}
}

func (ptr *QSGRenderNode) ConnectReleaseResources(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "releaseResources"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources", f)
		}
	}
}

func (ptr *QSGRenderNode) DisconnectReleaseResources() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "releaseResources")
	}
}

func (ptr *QSGRenderNode) ReleaseResources() {
	if ptr.Pointer() != nil {
		C.QSGRenderNode_ReleaseResources(ptr.Pointer())
	}
}

func (ptr *QSGRenderNode) ReleaseResourcesDefault() {
	if ptr.Pointer() != nil {
		C.QSGRenderNode_ReleaseResourcesDefault(ptr.Pointer())
	}
}

func (ptr *QSGRenderNode) DestroyQSGRenderNode() {
	if ptr.Pointer() != nil {
		C.QSGRenderNode_DestroyQSGRenderNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGRenderNode_Rect
func callbackQSGRenderNode_Rect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "rect"); signal != nil {
		return core.PointerFromQRectF(signal.(func() *core.QRectF)())
	}

	return core.PointerFromQRectF(NewQSGRenderNodeFromPointer(ptr).RectDefault())
}

func (ptr *QSGRenderNode) ConnectRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "rect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rect", func() *core.QRectF {
				signal.(func() *core.QRectF)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rect", f)
		}
	}
}

func (ptr *QSGRenderNode) DisconnectRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "rect")
	}
}

func (ptr *QSGRenderNode) Rect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGRenderNode_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QSGRenderNode) RectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGRenderNode_RectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQSGRenderNode_Flags
func callbackQSGRenderNode_Flags(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "flags"); signal != nil {
		return C.longlong(signal.(func() QSGRenderNode__RenderingFlag)())
	}

	return C.longlong(NewQSGRenderNodeFromPointer(ptr).FlagsDefault())
}

func (ptr *QSGRenderNode) ConnectFlags(f func() QSGRenderNode__RenderingFlag) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flags"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", func() QSGRenderNode__RenderingFlag {
				signal.(func() QSGRenderNode__RenderingFlag)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", f)
		}
	}
}

func (ptr *QSGRenderNode) DisconnectFlags() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flags")
	}
}

func (ptr *QSGRenderNode) Flags() QSGRenderNode__RenderingFlag {
	if ptr.Pointer() != nil {
		return QSGRenderNode__RenderingFlag(C.QSGRenderNode_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGRenderNode) FlagsDefault() QSGRenderNode__RenderingFlag {
	if ptr.Pointer() != nil {
		return QSGRenderNode__RenderingFlag(C.QSGRenderNode_FlagsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGRenderNode_ChangedStates
func callbackQSGRenderNode_ChangedStates(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "changedStates"); signal != nil {
		return C.longlong(signal.(func() QSGRenderNode__StateFlag)())
	}

	return C.longlong(NewQSGRenderNodeFromPointer(ptr).ChangedStatesDefault())
}

func (ptr *QSGRenderNode) ConnectChangedStates(f func() QSGRenderNode__StateFlag) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "changedStates"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "changedStates", func() QSGRenderNode__StateFlag {
				signal.(func() QSGRenderNode__StateFlag)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "changedStates", f)
		}
	}
}

func (ptr *QSGRenderNode) DisconnectChangedStates() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "changedStates")
	}
}

func (ptr *QSGRenderNode) ChangedStates() QSGRenderNode__StateFlag {
	if ptr.Pointer() != nil {
		return QSGRenderNode__StateFlag(C.QSGRenderNode_ChangedStates(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGRenderNode) ChangedStatesDefault() QSGRenderNode__StateFlag {
	if ptr.Pointer() != nil {
		return QSGRenderNode__StateFlag(C.QSGRenderNode_ChangedStatesDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGRenderNode) Matrix() *gui.QMatrix4x4 {
	if ptr.Pointer() != nil {
		return gui.NewQMatrix4x4FromPointer(C.QSGRenderNode_Matrix(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGRenderNode) ClipList() *QSGClipNode {
	if ptr.Pointer() != nil {
		return NewQSGClipNodeFromPointer(C.QSGRenderNode_ClipList(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGRenderNode) InheritedOpacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QSGRenderNode_InheritedOpacity(ptr.Pointer()))
	}
	return 0
}

type QSGRendererInterface struct {
	ptr unsafe.Pointer
}

type QSGRendererInterface_ITF interface {
	QSGRendererInterface_PTR() *QSGRendererInterface
}

func (ptr *QSGRendererInterface) QSGRendererInterface_PTR() *QSGRendererInterface {
	return ptr
}

func (ptr *QSGRendererInterface) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSGRendererInterface) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSGRendererInterface(ptr QSGRendererInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGRendererInterface_PTR().Pointer()
	}
	return nil
}

func NewQSGRendererInterfaceFromPointer(ptr unsafe.Pointer) *QSGRendererInterface {
	var n = new(QSGRendererInterface)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGRendererInterface__GraphicsApi
//QSGRendererInterface::GraphicsApi
type QSGRendererInterface__GraphicsApi int64

const (
	QSGRendererInterface__Unknown    QSGRendererInterface__GraphicsApi = QSGRendererInterface__GraphicsApi(0)
	QSGRendererInterface__Software   QSGRendererInterface__GraphicsApi = QSGRendererInterface__GraphicsApi(1)
	QSGRendererInterface__OpenGL     QSGRendererInterface__GraphicsApi = QSGRendererInterface__GraphicsApi(2)
	QSGRendererInterface__Direct3D12 QSGRendererInterface__GraphicsApi = QSGRendererInterface__GraphicsApi(3)
)

//go:generate stringer -type=QSGRendererInterface__Resource
//QSGRendererInterface::Resource
type QSGRendererInterface__Resource int64

const (
	QSGRendererInterface__DeviceResource       QSGRendererInterface__Resource = QSGRendererInterface__Resource(0)
	QSGRendererInterface__CommandQueueResource QSGRendererInterface__Resource = QSGRendererInterface__Resource(1)
	QSGRendererInterface__CommandListResource  QSGRendererInterface__Resource = QSGRendererInterface__Resource(2)
	QSGRendererInterface__PainterResource      QSGRendererInterface__Resource = QSGRendererInterface__Resource(3)
)

//go:generate stringer -type=QSGRendererInterface__ShaderCompilationType
//QSGRendererInterface::ShaderCompilationType
type QSGRendererInterface__ShaderCompilationType int64

const (
	QSGRendererInterface__RuntimeCompilation QSGRendererInterface__ShaderCompilationType = QSGRendererInterface__ShaderCompilationType(0x01)
	QSGRendererInterface__OfflineCompilation QSGRendererInterface__ShaderCompilationType = QSGRendererInterface__ShaderCompilationType(0x02)
)

//go:generate stringer -type=QSGRendererInterface__ShaderSourceType
//QSGRendererInterface::ShaderSourceType
type QSGRendererInterface__ShaderSourceType int64

const (
	QSGRendererInterface__ShaderSourceString QSGRendererInterface__ShaderSourceType = QSGRendererInterface__ShaderSourceType(0x01)
	QSGRendererInterface__ShaderSourceFile   QSGRendererInterface__ShaderSourceType = QSGRendererInterface__ShaderSourceType(0x02)
	QSGRendererInterface__ShaderByteCode     QSGRendererInterface__ShaderSourceType = QSGRendererInterface__ShaderSourceType(0x04)
)

//go:generate stringer -type=QSGRendererInterface__ShaderType
//QSGRendererInterface::ShaderType
type QSGRendererInterface__ShaderType int64

const (
	QSGRendererInterface__UnknownShadingLanguage QSGRendererInterface__ShaderType = QSGRendererInterface__ShaderType(0)
	QSGRendererInterface__GLSL                   QSGRendererInterface__ShaderType = QSGRendererInterface__ShaderType(1)
	QSGRendererInterface__HLSL                   QSGRendererInterface__ShaderType = QSGRendererInterface__ShaderType(2)
)

//export callbackQSGRendererInterface_DestroyQSGRendererInterface
func callbackQSGRendererInterface_DestroyQSGRendererInterface(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSGRendererInterface"); signal != nil {
		signal.(func())()
	} else {
		NewQSGRendererInterfaceFromPointer(ptr).DestroyQSGRendererInterfaceDefault()
	}
}

func (ptr *QSGRendererInterface) ConnectDestroyQSGRendererInterface(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSGRendererInterface"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGRendererInterface", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGRendererInterface", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectDestroyQSGRendererInterface() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSGRendererInterface")
	}
}

func (ptr *QSGRendererInterface) DestroyQSGRendererInterface() {
	if ptr.Pointer() != nil {
		C.QSGRendererInterface_DestroyQSGRendererInterface(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGRendererInterface) DestroyQSGRendererInterfaceDefault() {
	if ptr.Pointer() != nil {
		C.QSGRendererInterface_DestroyQSGRendererInterfaceDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGRendererInterface_GraphicsApi
func callbackQSGRendererInterface_GraphicsApi(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "graphicsApi"); signal != nil {
		return C.longlong(signal.(func() QSGRendererInterface__GraphicsApi)())
	}

	return C.longlong(0)
}

func (ptr *QSGRendererInterface) ConnectGraphicsApi(f func() QSGRendererInterface__GraphicsApi) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "graphicsApi"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "graphicsApi", func() QSGRendererInterface__GraphicsApi {
				signal.(func() QSGRendererInterface__GraphicsApi)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "graphicsApi", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectGraphicsApi() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "graphicsApi")
	}
}

func (ptr *QSGRendererInterface) GraphicsApi() QSGRendererInterface__GraphicsApi {
	if ptr.Pointer() != nil {
		return QSGRendererInterface__GraphicsApi(C.QSGRendererInterface_GraphicsApi(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGRendererInterface_ShaderCompilationType
func callbackQSGRendererInterface_ShaderCompilationType(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "shaderCompilationType"); signal != nil {
		return C.longlong(signal.(func() QSGRendererInterface__ShaderCompilationType)())
	}

	return C.longlong(0)
}

func (ptr *QSGRendererInterface) ConnectShaderCompilationType(f func() QSGRendererInterface__ShaderCompilationType) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shaderCompilationType"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shaderCompilationType", func() QSGRendererInterface__ShaderCompilationType {
				signal.(func() QSGRendererInterface__ShaderCompilationType)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shaderCompilationType", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectShaderCompilationType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "shaderCompilationType")
	}
}

func (ptr *QSGRendererInterface) ShaderCompilationType() QSGRendererInterface__ShaderCompilationType {
	if ptr.Pointer() != nil {
		return QSGRendererInterface__ShaderCompilationType(C.QSGRendererInterface_ShaderCompilationType(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGRendererInterface_ShaderSourceType
func callbackQSGRendererInterface_ShaderSourceType(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "shaderSourceType"); signal != nil {
		return C.longlong(signal.(func() QSGRendererInterface__ShaderSourceType)())
	}

	return C.longlong(0)
}

func (ptr *QSGRendererInterface) ConnectShaderSourceType(f func() QSGRendererInterface__ShaderSourceType) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shaderSourceType"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shaderSourceType", func() QSGRendererInterface__ShaderSourceType {
				signal.(func() QSGRendererInterface__ShaderSourceType)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shaderSourceType", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectShaderSourceType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "shaderSourceType")
	}
}

func (ptr *QSGRendererInterface) ShaderSourceType() QSGRendererInterface__ShaderSourceType {
	if ptr.Pointer() != nil {
		return QSGRendererInterface__ShaderSourceType(C.QSGRendererInterface_ShaderSourceType(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGRendererInterface_ShaderType
func callbackQSGRendererInterface_ShaderType(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "shaderType"); signal != nil {
		return C.longlong(signal.(func() QSGRendererInterface__ShaderType)())
	}

	return C.longlong(0)
}

func (ptr *QSGRendererInterface) ConnectShaderType(f func() QSGRendererInterface__ShaderType) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shaderType"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shaderType", func() QSGRendererInterface__ShaderType {
				signal.(func() QSGRendererInterface__ShaderType)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shaderType", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectShaderType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "shaderType")
	}
}

func (ptr *QSGRendererInterface) ShaderType() QSGRendererInterface__ShaderType {
	if ptr.Pointer() != nil {
		return QSGRendererInterface__ShaderType(C.QSGRendererInterface_ShaderType(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGRendererInterface_GetResource
func callbackQSGRendererInterface_GetResource(ptr unsafe.Pointer, window unsafe.Pointer, resource C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "getResource"); signal != nil {
		return signal.(func(*QQuickWindow, QSGRendererInterface__Resource) unsafe.Pointer)(NewQQuickWindowFromPointer(window), QSGRendererInterface__Resource(resource))
	}

	return NewQSGRendererInterfaceFromPointer(ptr).GetResourceDefault(NewQQuickWindowFromPointer(window), QSGRendererInterface__Resource(resource))
}

func (ptr *QSGRendererInterface) ConnectGetResource(f func(window *QQuickWindow, resource QSGRendererInterface__Resource) unsafe.Pointer) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "getResource"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "getResource", func(window *QQuickWindow, resource QSGRendererInterface__Resource) unsafe.Pointer {
				signal.(func(*QQuickWindow, QSGRendererInterface__Resource) unsafe.Pointer)(window, resource)
				return f(window, resource)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "getResource", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectGetResource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "getResource")
	}
}

func (ptr *QSGRendererInterface) GetResource(window QQuickWindow_ITF, resource QSGRendererInterface__Resource) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSGRendererInterface_GetResource(ptr.Pointer(), PointerFromQQuickWindow(window), C.longlong(resource)))
	}
	return nil
}

func (ptr *QSGRendererInterface) GetResourceDefault(window QQuickWindow_ITF, resource QSGRendererInterface__Resource) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSGRendererInterface_GetResourceDefault(ptr.Pointer(), PointerFromQQuickWindow(window), C.longlong(resource)))
	}
	return nil
}

//export callbackQSGRendererInterface_GetResource2
func callbackQSGRendererInterface_GetResource2(ptr unsafe.Pointer, window unsafe.Pointer, resource C.struct_QtQuick_PackedString) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "getResource2"); signal != nil {
		return signal.(func(*QQuickWindow, string) unsafe.Pointer)(NewQQuickWindowFromPointer(window), cGoUnpackString(resource))
	}

	return NewQSGRendererInterfaceFromPointer(ptr).GetResource2Default(NewQQuickWindowFromPointer(window), cGoUnpackString(resource))
}

func (ptr *QSGRendererInterface) ConnectGetResource2(f func(window *QQuickWindow, resource string) unsafe.Pointer) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "getResource2"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "getResource2", func(window *QQuickWindow, resource string) unsafe.Pointer {
				signal.(func(*QQuickWindow, string) unsafe.Pointer)(window, resource)
				return f(window, resource)
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "getResource2", f)
		}
	}
}

func (ptr *QSGRendererInterface) DisconnectGetResource2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "getResource2")
	}
}

func (ptr *QSGRendererInterface) GetResource2(window QQuickWindow_ITF, resource string) unsafe.Pointer {
	if ptr.Pointer() != nil {
		var resourceC *C.char
		if resource != "" {
			resourceC = C.CString(resource)
			defer C.free(unsafe.Pointer(resourceC))
		}
		return unsafe.Pointer(C.QSGRendererInterface_GetResource2(ptr.Pointer(), PointerFromQQuickWindow(window), resourceC))
	}
	return nil
}

func (ptr *QSGRendererInterface) GetResource2Default(window QQuickWindow_ITF, resource string) unsafe.Pointer {
	if ptr.Pointer() != nil {
		var resourceC *C.char
		if resource != "" {
			resourceC = C.CString(resource)
			defer C.free(unsafe.Pointer(resourceC))
		}
		return unsafe.Pointer(C.QSGRendererInterface_GetResource2Default(ptr.Pointer(), PointerFromQQuickWindow(window), resourceC))
	}
	return nil
}

type QSGSimpleMaterial struct {
	QSGMaterial
}

type QSGSimpleMaterial_ITF interface {
	QSGMaterial_ITF
	QSGSimpleMaterial_PTR() *QSGSimpleMaterial
}

func (ptr *QSGSimpleMaterial) QSGSimpleMaterial_PTR() *QSGSimpleMaterial {
	return ptr
}

func (ptr *QSGSimpleMaterial) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterial_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGSimpleMaterial) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGMaterial_PTR().SetPointer(p)
	}
}

func PointerFromQSGSimpleMaterial(ptr QSGSimpleMaterial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGSimpleMaterial_PTR().Pointer()
	}
	return nil
}

func NewQSGSimpleMaterialFromPointer(ptr unsafe.Pointer) *QSGSimpleMaterial {
	var n = new(QSGSimpleMaterial)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGSimpleMaterial) DestroyQSGSimpleMaterial() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

type QSGSimpleMaterialShader struct {
	QSGMaterialShader
}

type QSGSimpleMaterialShader_ITF interface {
	QSGMaterialShader_ITF
	QSGSimpleMaterialShader_PTR() *QSGSimpleMaterialShader
}

func (ptr *QSGSimpleMaterialShader) QSGSimpleMaterialShader_PTR() *QSGSimpleMaterialShader {
	return ptr
}

func (ptr *QSGSimpleMaterialShader) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterialShader_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGSimpleMaterialShader) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGMaterialShader_PTR().SetPointer(p)
	}
}

func PointerFromQSGSimpleMaterialShader(ptr QSGSimpleMaterialShader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGSimpleMaterialShader_PTR().Pointer()
	}
	return nil
}

func NewQSGSimpleMaterialShaderFromPointer(ptr unsafe.Pointer) *QSGSimpleMaterialShader {
	var n = new(QSGSimpleMaterialShader)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGSimpleMaterialShader) DestroyQSGSimpleMaterialShader() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

type QSGTexture struct {
	core.QObject
}

type QSGTexture_ITF interface {
	core.QObject_ITF
	QSGTexture_PTR() *QSGTexture
}

func (ptr *QSGTexture) QSGTexture_PTR() *QSGTexture {
	return ptr
}

func (ptr *QSGTexture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGTexture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQSGTexture(ptr QSGTexture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGTexture_PTR().Pointer()
	}
	return nil
}

func NewQSGTextureFromPointer(ptr unsafe.Pointer) *QSGTexture {
	var n = new(QSGTexture)
	n.SetPointer(ptr)
	return n
}

//go:generate stringer -type=QSGTexture__Filtering
//QSGTexture::Filtering
type QSGTexture__Filtering int64

const (
	QSGTexture__None    QSGTexture__Filtering = QSGTexture__Filtering(0)
	QSGTexture__Nearest QSGTexture__Filtering = QSGTexture__Filtering(1)
	QSGTexture__Linear  QSGTexture__Filtering = QSGTexture__Filtering(2)
)

//go:generate stringer -type=QSGTexture__WrapMode
//QSGTexture::WrapMode
type QSGTexture__WrapMode int64

const (
	QSGTexture__Repeat      QSGTexture__WrapMode = QSGTexture__WrapMode(0)
	QSGTexture__ClampToEdge QSGTexture__WrapMode = QSGTexture__WrapMode(1)
)

func NewQSGTexture() *QSGTexture {
	var tmpValue = NewQSGTextureFromPointer(C.QSGTexture_NewQSGTexture())
	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQSGTexture_Bind
func callbackQSGTexture_Bind(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "bind"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QSGTexture) ConnectBind(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bind"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bind", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bind", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectBind() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bind")
	}
}

func (ptr *QSGTexture) Bind() {
	if ptr.Pointer() != nil {
		C.QSGTexture_Bind(ptr.Pointer())
	}
}

func (ptr *QSGTexture) SetFiltering(filter QSGTexture__Filtering) {
	if ptr.Pointer() != nil {
		C.QSGTexture_SetFiltering(ptr.Pointer(), C.longlong(filter))
	}
}

func (ptr *QSGTexture) SetHorizontalWrapMode(hwrap QSGTexture__WrapMode) {
	if ptr.Pointer() != nil {
		C.QSGTexture_SetHorizontalWrapMode(ptr.Pointer(), C.longlong(hwrap))
	}
}

func (ptr *QSGTexture) SetMipmapFiltering(filter QSGTexture__Filtering) {
	if ptr.Pointer() != nil {
		C.QSGTexture_SetMipmapFiltering(ptr.Pointer(), C.longlong(filter))
	}
}

func (ptr *QSGTexture) SetVerticalWrapMode(vwrap QSGTexture__WrapMode) {
	if ptr.Pointer() != nil {
		C.QSGTexture_SetVerticalWrapMode(ptr.Pointer(), C.longlong(vwrap))
	}
}

func (ptr *QSGTexture) UpdateBindOptions(force bool) {
	if ptr.Pointer() != nil {
		C.QSGTexture_UpdateBindOptions(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(force))))
	}
}

func (ptr *QSGTexture) DestroyQSGTexture() {
	if ptr.Pointer() != nil {
		C.QSGTexture_DestroyQSGTexture(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGTexture) ConvertToNormalizedSourceRect(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGTexture_ConvertToNormalizedSourceRect(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQSGTexture_NormalizedTextureSubRect
func callbackQSGTexture_NormalizedTextureSubRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "normalizedTextureSubRect"); signal != nil {
		return core.PointerFromQRectF(signal.(func() *core.QRectF)())
	}

	return core.PointerFromQRectF(NewQSGTextureFromPointer(ptr).NormalizedTextureSubRectDefault())
}

func (ptr *QSGTexture) ConnectNormalizedTextureSubRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "normalizedTextureSubRect"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "normalizedTextureSubRect", func() *core.QRectF {
				signal.(func() *core.QRectF)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "normalizedTextureSubRect", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectNormalizedTextureSubRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "normalizedTextureSubRect")
	}
}

func (ptr *QSGTexture) NormalizedTextureSubRect() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGTexture_NormalizedTextureSubRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) NormalizedTextureSubRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQRectFFromPointer(C.QSGTexture_NormalizedTextureSubRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQSGTexture_RemovedFromAtlas
func callbackQSGTexture_RemovedFromAtlas(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "removedFromAtlas"); signal != nil {
		return PointerFromQSGTexture(signal.(func() *QSGTexture)())
	}

	return PointerFromQSGTexture(NewQSGTextureFromPointer(ptr).RemovedFromAtlasDefault())
}

func (ptr *QSGTexture) ConnectRemovedFromAtlas(f func() *QSGTexture) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "removedFromAtlas"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "removedFromAtlas", func() *QSGTexture {
				signal.(func() *QSGTexture)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "removedFromAtlas", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectRemovedFromAtlas() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "removedFromAtlas")
	}
}

func (ptr *QSGTexture) RemovedFromAtlas() *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGTexture_RemovedFromAtlas(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) RemovedFromAtlasDefault() *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGTexture_RemovedFromAtlasDefault(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) Filtering() QSGTexture__Filtering {
	if ptr.Pointer() != nil {
		return QSGTexture__Filtering(C.QSGTexture_Filtering(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGTexture) MipmapFiltering() QSGTexture__Filtering {
	if ptr.Pointer() != nil {
		return QSGTexture__Filtering(C.QSGTexture_MipmapFiltering(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGTexture) HorizontalWrapMode() QSGTexture__WrapMode {
	if ptr.Pointer() != nil {
		return QSGTexture__WrapMode(C.QSGTexture_HorizontalWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSGTexture) VerticalWrapMode() QSGTexture__WrapMode {
	if ptr.Pointer() != nil {
		return QSGTexture__WrapMode(C.QSGTexture_VerticalWrapMode(ptr.Pointer()))
	}
	return 0
}

//export callbackQSGTexture_TextureSize
func callbackQSGTexture_TextureSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureSize"); signal != nil {
		return core.PointerFromQSize(signal.(func() *core.QSize)())
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QSGTexture) ConnectTextureSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureSize"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureSize", func() *core.QSize {
				signal.(func() *core.QSize)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureSize", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectTextureSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureSize")
	}
}

func (ptr *QSGTexture) TextureSize() *core.QSize {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQSizeFromPointer(C.QSGTexture_TextureSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQSGTexture_HasAlphaChannel
func callbackQSGTexture_HasAlphaChannel(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hasAlphaChannel"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QSGTexture) ConnectHasAlphaChannel(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasAlphaChannel"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasAlphaChannel", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasAlphaChannel", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectHasAlphaChannel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hasAlphaChannel")
	}
}

func (ptr *QSGTexture) HasAlphaChannel() bool {
	if ptr.Pointer() != nil {
		return C.QSGTexture_HasAlphaChannel(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQSGTexture_HasMipmaps
func callbackQSGTexture_HasMipmaps(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "hasMipmaps"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QSGTexture) ConnectHasMipmaps(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasMipmaps"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasMipmaps", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasMipmaps", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectHasMipmaps() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hasMipmaps")
	}
}

func (ptr *QSGTexture) HasMipmaps() bool {
	if ptr.Pointer() != nil {
		return C.QSGTexture_HasMipmaps(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQSGTexture_IsAtlasTexture
func callbackQSGTexture_IsAtlasTexture(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "isAtlasTexture"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGTextureFromPointer(ptr).IsAtlasTextureDefault())))
}

func (ptr *QSGTexture) ConnectIsAtlasTexture(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isAtlasTexture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAtlasTexture", func() bool {
				signal.(func() bool)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAtlasTexture", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectIsAtlasTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isAtlasTexture")
	}
}

func (ptr *QSGTexture) IsAtlasTexture() bool {
	if ptr.Pointer() != nil {
		return C.QSGTexture_IsAtlasTexture(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSGTexture) IsAtlasTextureDefault() bool {
	if ptr.Pointer() != nil {
		return C.QSGTexture_IsAtlasTextureDefault(ptr.Pointer()) != 0
	}
	return false
}

//export callbackQSGTexture_TextureId
func callbackQSGTexture_TextureId(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureId"); signal != nil {
		return C.int(int32(signal.(func() int)()))
	}

	return C.int(int32(0))
}

func (ptr *QSGTexture) ConnectTextureId(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureId"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureId", func() int {
				signal.(func() int)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureId", f)
		}
	}
}

func (ptr *QSGTexture) DisconnectTextureId() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureId")
	}
}

func (ptr *QSGTexture) TextureId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSGTexture_TextureId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSGTexture) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QSGTexture___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QSGTexture) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTexture___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QSGTexture) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTexture___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTexture) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTexture___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QSGTexture) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTexture___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTexture) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTexture___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QSGTexture) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTexture___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTexture) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTexture___findChildren_newList(ptr.Pointer()))
}

func (ptr *QSGTexture) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTexture___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTexture) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTexture) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTexture___children_newList(ptr.Pointer()))
}

//export callbackQSGTexture_Event
func callbackQSGTexture_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGTextureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QSGTexture) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGTexture_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQSGTexture_EventFilter
func callbackQSGTexture_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGTextureFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QSGTexture) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGTexture_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQSGTexture_ChildEvent
func callbackQSGTexture_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSGTextureFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSGTexture) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQSGTexture_ConnectNotify
func callbackQSGTexture_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGTextureFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGTexture) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGTexture_CustomEvent
func callbackQSGTexture_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQSGTextureFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSGTexture) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQSGTexture_DeleteLater
func callbackQSGTexture_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQSGTextureFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QSGTexture) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QSGTexture_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGTexture_Destroyed
func callbackQSGTexture_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQSGTexture_DisconnectNotify
func callbackQSGTexture_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGTextureFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGTexture) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGTexture_ObjectNameChanged
func callbackQSGTexture_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQSGTexture_TimerEvent
func callbackQSGTexture_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSGTextureFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSGTexture) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTexture_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQSGTexture_MetaObject
func callbackQSGTexture_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQSGTextureFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QSGTexture) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QSGTexture_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QSGTextureMaterial struct {
	QSGOpaqueTextureMaterial
}

type QSGTextureMaterial_ITF interface {
	QSGOpaqueTextureMaterial_ITF
	QSGTextureMaterial_PTR() *QSGTextureMaterial
}

func (ptr *QSGTextureMaterial) QSGTextureMaterial_PTR() *QSGTextureMaterial {
	return ptr
}

func (ptr *QSGTextureMaterial) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGOpaqueTextureMaterial_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGTextureMaterial) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGOpaqueTextureMaterial_PTR().SetPointer(p)
	}
}

func PointerFromQSGTextureMaterial(ptr QSGTextureMaterial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGTextureMaterial_PTR().Pointer()
	}
	return nil
}

func NewQSGTextureMaterialFromPointer(ptr unsafe.Pointer) *QSGTextureMaterial {
	var n = new(QSGTextureMaterial)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGTextureMaterial) DestroyQSGTextureMaterial() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

type QSGTextureProvider struct {
	core.QObject
}

type QSGTextureProvider_ITF interface {
	core.QObject_ITF
	QSGTextureProvider_PTR() *QSGTextureProvider
}

func (ptr *QSGTextureProvider) QSGTextureProvider_PTR() *QSGTextureProvider {
	return ptr
}

func (ptr *QSGTextureProvider) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGTextureProvider) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQSGTextureProvider(ptr QSGTextureProvider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGTextureProvider_PTR().Pointer()
	}
	return nil
}

func NewQSGTextureProviderFromPointer(ptr unsafe.Pointer) *QSGTextureProvider {
	var n = new(QSGTextureProvider)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGTextureProvider) DestroyQSGTextureProvider() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGTextureProvider_TextureChanged
func callbackQSGTextureProvider_TextureChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "textureChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QSGTextureProvider) ConnectTextureChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "textureChanged") {
			C.QSGTextureProvider_ConnectTextureChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textureChanged"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureChanged", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textureChanged", f)
		}
	}
}

func (ptr *QSGTextureProvider) DisconnectTextureChanged() {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_DisconnectTextureChanged(ptr.Pointer())
		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "textureChanged")
	}
}

func (ptr *QSGTextureProvider) TextureChanged() {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_TextureChanged(ptr.Pointer())
	}
}

//export callbackQSGTextureProvider_Texture
func callbackQSGTextureProvider_Texture(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "texture"); signal != nil {
		return PointerFromQSGTexture(signal.(func() *QSGTexture)())
	}

	return PointerFromQSGTexture(NewQSGTexture())
}

func (ptr *QSGTextureProvider) ConnectTexture(f func() *QSGTexture) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "texture"); signal != nil {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "texture", func() *QSGTexture {
				signal.(func() *QSGTexture)()
				return f()
			})
		} else {
			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "texture", f)
		}
	}
}

func (ptr *QSGTextureProvider) DisconnectTexture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "texture")
	}
}

func (ptr *QSGTextureProvider) Texture() *QSGTexture {
	if ptr.Pointer() != nil {
		var tmpValue = NewQSGTextureFromPointer(C.QSGTextureProvider_Texture(ptr.Pointer()))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTextureProvider) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQByteArrayFromPointer(C.QSGTextureProvider___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QSGTextureProvider) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QSGTextureProvider) __dynamicPropertyNames_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTextureProvider___dynamicPropertyNames_newList(ptr.Pointer()))
}

func (ptr *QSGTextureProvider) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTextureProvider___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTextureProvider) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTextureProvider) __findChildren_newList2() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTextureProvider___findChildren_newList2(ptr.Pointer()))
}

func (ptr *QSGTextureProvider) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTextureProvider___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTextureProvider) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTextureProvider) __findChildren_newList3() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTextureProvider___findChildren_newList3(ptr.Pointer()))
}

func (ptr *QSGTextureProvider) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTextureProvider___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTextureProvider) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTextureProvider) __findChildren_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTextureProvider___findChildren_newList(ptr.Pointer()))
}

func (ptr *QSGTextureProvider) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		var tmpValue = core.NewQObjectFromPointer(C.QSGTextureProvider___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSGTextureProvider) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSGTextureProvider) __children_newList() unsafe.Pointer {
	return unsafe.Pointer(C.QSGTextureProvider___children_newList(ptr.Pointer()))
}

//export callbackQSGTextureProvider_Event
func callbackQSGTextureProvider_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGTextureProviderFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QSGTextureProvider) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGTextureProvider_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
	}
	return false
}

//export callbackQSGTextureProvider_EventFilter
func callbackQSGTextureProvider_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSGTextureProviderFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QSGTextureProvider) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return C.QSGTextureProvider_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
	}
	return false
}

//export callbackQSGTextureProvider_ChildEvent
func callbackQSGTextureProvider_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSGTextureProviderFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSGTextureProvider) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQSGTextureProvider_ConnectNotify
func callbackQSGTextureProvider_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGTextureProviderFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGTextureProvider) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGTextureProvider_CustomEvent
func callbackQSGTextureProvider_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQSGTextureProviderFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSGTextureProvider) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQSGTextureProvider_DeleteLater
func callbackQSGTextureProvider_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewQSGTextureProviderFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QSGTextureProvider) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_DeleteLaterDefault(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

//export callbackQSGTextureProvider_Destroyed
func callbackQSGTextureProvider_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQSGTextureProvider_DisconnectNotify
func callbackQSGTextureProvider_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
		signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSGTextureProviderFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSGTextureProvider) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSGTextureProvider_ObjectNameChanged
func callbackQSGTextureProvider_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQuick_PackedString) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackQSGTextureProvider_TimerEvent
func callbackQSGTextureProvider_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSGTextureProviderFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSGTextureProvider) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTextureProvider_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQSGTextureProvider_MetaObject
func callbackQSGTextureProvider_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
		return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
	}

	return core.PointerFromQMetaObject(NewQSGTextureProviderFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QSGTextureProvider) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QSGTextureProvider_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

type QSGTransformNode struct {
	QSGNode
}

type QSGTransformNode_ITF interface {
	QSGNode_ITF
	QSGTransformNode_PTR() *QSGTransformNode
}

func (ptr *QSGTransformNode) QSGTransformNode_PTR() *QSGTransformNode {
	return ptr
}

func (ptr *QSGTransformNode) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGNode_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGTransformNode) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGNode_PTR().SetPointer(p)
	}
}

func PointerFromQSGTransformNode(ptr QSGTransformNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGTransformNode_PTR().Pointer()
	}
	return nil
}

func NewQSGTransformNodeFromPointer(ptr unsafe.Pointer) *QSGTransformNode {
	var n = new(QSGTransformNode)
	n.SetPointer(ptr)
	return n
}
func NewQSGTransformNode() *QSGTransformNode {
	return NewQSGTransformNodeFromPointer(C.QSGTransformNode_NewQSGTransformNode())
}

func (ptr *QSGTransformNode) SetMatrix(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QSGTransformNode_SetMatrix(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

func (ptr *QSGTransformNode) DestroyQSGTransformNode() {
	if ptr.Pointer() != nil {
		C.QSGTransformNode_DestroyQSGTransformNode(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func (ptr *QSGTransformNode) Matrix() *gui.QMatrix4x4 {
	if ptr.Pointer() != nil {
		return gui.NewQMatrix4x4FromPointer(C.QSGTransformNode_Matrix(ptr.Pointer()))
	}
	return nil
}

type QSGVertexColorMaterial struct {
	QSGMaterial
}

type QSGVertexColorMaterial_ITF interface {
	QSGMaterial_ITF
	QSGVertexColorMaterial_PTR() *QSGVertexColorMaterial
}

func (ptr *QSGVertexColorMaterial) QSGVertexColorMaterial_PTR() *QSGVertexColorMaterial {
	return ptr
}

func (ptr *QSGVertexColorMaterial) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGMaterial_PTR().Pointer()
	}
	return nil
}

func (ptr *QSGVertexColorMaterial) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QSGMaterial_PTR().SetPointer(p)
	}
}

func PointerFromQSGVertexColorMaterial(ptr QSGVertexColorMaterial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSGVertexColorMaterial_PTR().Pointer()
	}
	return nil
}

func NewQSGVertexColorMaterialFromPointer(ptr unsafe.Pointer) *QSGVertexColorMaterial {
	var n = new(QSGVertexColorMaterial)
	n.SetPointer(ptr)
	return n
}

func (ptr *QSGVertexColorMaterial) DestroyQSGVertexColorMaterial() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
		ptr.SetPointer(nil)
	}
}

func NewQSGVertexColorMaterial() *QSGVertexColorMaterial {
	return NewQSGVertexColorMaterialFromPointer(C.QSGVertexColorMaterial_NewQSGVertexColorMaterial())
}

//export callbackQSGVertexColorMaterial_CreateShader
func callbackQSGVertexColorMaterial_CreateShader(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "createShader"); signal != nil {
		return PointerFromQSGMaterialShader(signal.(func() *QSGMaterialShader)())
	}

	return PointerFromQSGMaterialShader(NewQSGVertexColorMaterialFromPointer(ptr).CreateShaderDefault())
}

func (ptr *QSGVertexColorMaterial) CreateShader() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGVertexColorMaterial_CreateShader(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGVertexColorMaterial) CreateShaderDefault() *QSGMaterialShader {
	if ptr.Pointer() != nil {
		return NewQSGMaterialShaderFromPointer(C.QSGVertexColorMaterial_CreateShaderDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQSGVertexColorMaterial_Type
func callbackQSGVertexColorMaterial_Type(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(fmt.Sprint(ptr), "type"); signal != nil {
		return PointerFromQSGMaterialType(signal.(func() *QSGMaterialType)())
	}

	return PointerFromQSGMaterialType(NewQSGVertexColorMaterialFromPointer(ptr).TypeDefault())
}

func (ptr *QSGVertexColorMaterial) Type() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGVertexColorMaterial_Type(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSGVertexColorMaterial) TypeDefault() *QSGMaterialType {
	if ptr.Pointer() != nil {
		return NewQSGMaterialTypeFromPointer(C.QSGVertexColorMaterial_TypeDefault(ptr.Pointer()))
	}
	return nil
}